Relational vs. NoSQL Databases
Relational databases use structured tables and predefined schemas, but they are not the only option. NoSQL databases provide alternative models that do not follow the traditional relational structure.
Types of NoSQL Databases
NoSQL includes document stores, key-value databases, columnar databases, and graph databases. These systems typically support flexible schemas and unstructured or semi-structured data.
Advantages of NoSQL
NoSQL databases offer schema flexibility, JSON-like data storage, and strong horizontal scalability. They can deliver performance benefits in high-scale or specialized use cases.
Trade-offs and Limitations
In exchange for scalability and flexibility, NoSQL systems often sacrifice strong consistency guarantees and relational features such as joins. Query patterns and data modeling differ significantly from relational systems.
Why Postgres Is Used
Postgres provides a balance by combining relational reliability with support for JSON/JSONB data types. This allows developers to maintain structure and consistency while leveraging flexible data storage when needed.
So far, we have been talking about relational databases, structured tables, rows, relationships,
but relational databases are not the only option out there.
You might have heard of NoSQL databases.
This could be MongoDB, Cassandra, DynamoDB, CouchDB, and a bunch of others.
Let's take a moment to see what they are, when they are useful,
and why we are sticking with Postgres in this course.
The term NoSQL covers a broad set of databases that don't follow the traditional relational model.
Some examples here could include document databases, key value stores,
columnar databases, where you look at columns instead of rows,
graph databases, where instead of rows,
rigid schemas and guarantees,
NoSQL databases often allow for flexibility and unstructured data.
There are some good reasons developers turn to NoSQL.
There is flexibility, JSON-like data,
but I think the most important one is probably scaling,
because you can get some performance in these types of databases that you cannot get in relational databases.
But you need to have a lot of...
Your requirement needs to be exceptionally high for this to really start to matter.
So, there are some trade-offs.
So, yeah, you get performance, but you also get weaker consistency guarantees.
You are missing the relational structures, like joins, for example.
You have to query the data in a different way.
So, for many applications, these trade-offs make relational databases the safer and more reliable choice.
The cool thing is with Postgres, we can actually have the best of both worlds.
It's relational at its core, but it also supports JSON or JSONB data structures.
So, we can actually store JSON data, and we can have all the flexibility in the world that we want,
without losing all of the reliability.
This gives us the flexibility of NoSQL when we need it,
but with the safety and reliability of Postgres.
To recap, NoSQL databases are great for flexibility, scalability, and specialized use cases.
They often sacrifice relational features and consistency,
but Postgres offers a balance.
You can use JSON.
When you need it, for most web apps, including the one we are building,
Postgres is the best default choice.
So, in the next episode, we will be building the database package,
so we can actually connect to a real database in our app.
