## The CAP Theorem (Brewer’s Theorem) in NoSQL Databases
Published: 2024-05-01 20:53:10

*The CAP theorem, first introduced by Eric Brewer in 2000 and formalized in 2002, outlines the trade-offs between consistency, availability, and partition tolerance in distributed systems. This theorem serves as a guide for designing robust systems that can manage the complexities of distributed data.*

![CAP theorem Euler diagram](https://cdn-images-1.medium.com/max/2000/1*hIZiZINape0a0H84OHKQog.png)

According to the CAP theorem, a distributed data system cannot simultaneously provide consistency, availability, and partition tolerance. It can only guarantee two of the three at any given time.

Before diving into the CAP theorem, let’s define some key terms:

**Consistency**: Consistency ensures that all nodes in a distributed system show the same view of the data at all times. When data is updated or written, all subsequent read requests return the latest version of the data.

**Availability**: Availability means the system is consistently operational and can quickly handle read and write requests. It ensures users can access data and perform transactions even when some nodes are down.

**Partition Tolerance**: Partition tolerance refers to the system’s ability to function despite network partitions or disruptions in communication between different parts of the system. In other words, a partition-tolerant system can handle network failures that cause communication breakdowns between different parts of the system, without completely ceasing operation.

**Node**: In a distributed system, a node is an individual server or instance that stores data and performs operations such as read and write requests. Each node operates independently but can communicate with other nodes through a network.

**Cluster**: In distributed systems, a cluster consists of multiple nodes working together to provide efficient, reliable, and scalable services for applications and data management.

## **How does the CAP theorem apply to NoSQL databases?**

When examing popular nosql databases, it is observed that partition tolerance of CAP is generally esential.

Because one key reason NoSQL databases have gained popularity is their ability to scale horizontally, unlike relational databases, which typically scale by upgrading the database server (vertical scaling). This approach can be costly and limited.

NoSQL databases enable horizontal scaling by spreading data across multiple nodes, which helps manage large data volumes and high traffic more efficiently. Consequently, NoSQL databases have become a top choice for modern applications that require large data handling and high performance.

![Vertical scaling vs. horizontal scaling](https://cdn-images-1.medium.com/max/2000/1*gyEgQhs7QdD2MgNGC1wrzQ.png)

In NoSQL databases, data is shared across multiple nodes, necessitating constant communication and data exchange. The system must continue running even if there are network issues or disconnections. Achieving a true CA (consistency and availability) scenario without sacrificing partition tolerance is not feasible in a distributed system.

Besides partition tolerance is essential for NoSQL databases, many NoSQL databases like Cassandra and MongoDB can be configured to align with either CP or CA.

## MongoDB: A Practical Example

To illustrate how NoSQL databases navigate the trade-offs posed by the CAP theorem, let’s examine MongoDB, a popular NoSQL database.

MongoDB uses a replica set for replication. The primary server manages write operations and replicates changes to the secondary servers. Replication involves maintaining multiple copies of data across different servers, ensuring data remains secure and accessible even if one server experiences an issue.

If the primary server fails, an automatic election process enables one of the secondary servers to become the new primary. Once the original primary server recovers, it becomes a secondary server.

By default, MongoDB clients send all read and write requests to the primary node, ensuring consistency within the system. However, if a client loses connection with the primary node or if the primary node becomes disconnected from the cluster, availability may be compromised.

Thus, in its default configuration, MongoDB offers consistency and partition tolerance but may not maintain high availability in certain scenarios.

If your priority is availability rather than consistency, you should not use this method.

You can adjust the [read preference mode ](https://www.mongodb.com/docs/manual/core/read-preference/#read-preference-modes)to read from any available node, which enhances availability. However, this configuration can compromise consistency because the secondary nodes might not have the latest data updates from the primary node.

This trade-off allows MongoDB to provide availability and partition tolerance but at the expense of consistency in some scenarios.

**Conclusion**

In conclusion, the CAP theorem provides a useful framework for understanding the trade-offs inherent in distributed systems. By making informed choices about your database’s configuration and understanding how the CAP theorem applies, you can optimize your system to suit your application’s requirements and achieve a balance that meets your business objectives.

**Sources:**

* [Cockroach Labs: Vertical Scaling vs. Horizontal Scaling](https://www.cockroachlabs.com/blog/vertical-scaling-vs-horizontal-scaling/)

* [MongoDB Documentation: Replication](https://www.mongodb.com/docs/manual/replication/)

* [Wikipedia: CAP Theorem](https://en.wikipedia.org/wiki/CAP_theorem)