I write this, but as a dispute to Rex's answer.
I dispute the idea that nosql is indifferent and fuzzy.
I worked with CODASYL many years ago with C and Cobol - entity relationships are very tough in CODASYL.
In contrast, relational database systems have a very liberal relationship policy. While you can identify a foreign key, you can create a relationship binding.
It is often taken for granted that SQL is synonymous with RDBMS, but people write SQL drivers for CODASYL, XML, inverted sets, etc.
RDBMS / SQL does not match the accuracy of data or relationships. In fact, an RDBMS is a constant cause of inaccuracies and misperceptions. I do not see how RDBMS offer better data and relationship integrity than, for example, hasoop. Put on a JDO layer - and we can build a network of good and clean relationships between entities in hadoop.
However, I like working with SQL because it gives me the opportunity to script adhoc relations, although I understand that adhoc relations are a constant cause of falsification of relations and problems.
Being able to work with statistical analysis of business processes and production processes, SQL gave me the opportunity to explore relationships in which no relationships were previously found. Being able to work with statistical analysis gave me ideas that usually didn't appear in the way of SQL programmers.
For example, you should design and normalize your circuit to reflect a set of processes. What you may not understand is that relationships change over time. Statistical characteristics would show that a circuit can no longer be “properly normalized” as it once was. That the main components of the processes have mutated over time. But non-statistical programmers do not understand this and continue to advertise RDBMSs as an ideal solution for data integrity and relationship accuracy.
However, in a database linking relationship, you can link objects in relationships as they appear. When relationships mutate, the relationship naturally mutates with data. Relations and their mutation are documented in a database system without the expensive need to renormalize a schema. At this point, the RDBMS is only good as temporary dbs.
But then you can resist the fact that RDBMS also allows you to flexibly mutate your relationship, since that is what SQL does. True, it is very true - while you are doing BCNF or even 4NF. Otherwise, you will begin to see that your queries and data loaders perform replicated operations. But then, your long years in the RDBMS business still, at least, made you realize that BCNF is very expensive and operationally inefficient, and that we are constantly to blame for 2.5 NFing of our circuits.
To say that RDBMS and SQL promotes data and relationship integrity is a gross, false expression. Either you work for a company that is so tiny, or you don’t stay in your position for more than two years — you won’t see the amount of data or information mutation and problems caused by the RDBMS. Violation of the DBMS is the reason that managers are limited in presentation by computer applications and the reason for financial failures of companies that do not see changes in market behavior, because their views were limited to programmers whose views were limited to their respect for their favorite RDBMS Schemes.
That’s why SQL programmers don’t understand why your company’s statistics refuses to use your application, which you developed carefully, but they used a college intern to write SQL to upload data to their personal servers and to let your company managers trust accountants and statistics, and not your elegant multi-tier applications due to the inability of your applications to mutate with processes.
This may not be possible, but I still urge you to get some statistical insight to understand how processes mutate over time so that you can make the right technological decision.
The reason people don't switch to SQL-less is the lack of a good scripting environment, such as SQL, to do adhoc relationship analysis. Not because SQL-less technology does not match accuracy or integrity. Adhoc relationship analysis is very important these days thanks to the fast and flexible approaches and application development strategies we currently have.