Skip to main content

CAP & ACID

CAP and ACID are two distinct terms that are used often in database world, where ACID is used to define properties of a database and CAP is actually used to determine distributed systems nature.
ACID stands for
  • Atomicity
  • Consistency
  • Isolation
  • Durability
Before going into the meaning of these terms one should be fairly aware of transactions. A transaction is like a unit of work which may comprise of multiple write operations or just a single operation. Treating a set of operations like this actually enables databases to maintain ACID properties.
Atomicity - Either all statements/queries inside a transaction happen or none of it does. In layman terms, if you start a transaction saying I want these 5 queries to be run. The database will make sure that either all of 5 queries are successful or none of them is. So if 5th query fails automatically the previous 4 queries effect will be wiped off.
Consistency - This ensures that whatever data you put into your database does not violate the rules that you have set for that type of data structure. This also includes the rules for related data and so forth.
Isolation - Every transactions run independent of other transactions. No transaction can refer to the data which is being manipulated by other transaction until it finishes.
Durability - Once a transaction has been committed it is stored in a durable medium (hard disk). This ensures even after crashes or restarts the database will have its state preserved.

CAP stands for
  • Consistency
  • Availability
  • Partition Tolerance
CAP is basically applied to a distributed system architecture where database is not just a single machine but is a set of nodes over a network, say 5 different machines running same database connected through network.
Consistency - Although some confuse CAP's consistency with ACID's one, it is entirely of different meaning when it comes to distributed system. It means that all the nodes will always have latest data, so it doesn't matter from which node you read, you will always get the latest copy.
Availability - This means that a system will always be available i.e. respond to requests even if a node goes down. Although this does not guarantee that other nodes will be in sync with unavailable node.
Partition Tolerance - This means system should be able to tolerate a failure in internal network i.e. communication between nodes. This means that nodes are individually able to serve the clients but are unable to communicate with each other.
This theorem is actually used to describe a system as either CP or AP, there cannot be a practical CA distributed system. In a cluster the nodes transmit the data to each other to maintain its consistency. When does this happen is the question.
In an AP system, the system still functions even if a single node is down. This does not ensure consistency since the failed node might have not updated other nodes with its operations. In this case the running nodes will give outdated data to the clients.
In an CP system, the consistency is of priority. So if a node goes down though the system can run, it chooses to stop responding to requests so that other nodes do not get ahead of failed node in terms of data. When the failed node is restored the system will be back up.

Comments

Popular posts from this blog

Guide : Spring Boot with Apache CXF for REST services

In this series of guide, we are going to explore writing REST services with Apache CXF using Spring Boot. The project is build using maven. I assume that you already know how to use maven. Step 1 : Adding dependencies for Spring Boot By default you have to inherit the parent pom of spring boot, but that cannot be followed everytime, so I use an alternative to that. I basically add spring boot pom as dependency so that it brings all the dependencies. <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> <spring.version>1.4.3.RELEASE</spring.version> <cxf.version>3.1.10</cxf.version> </properties> <dependencies> <dependency> <!-- Alternative to inheriting from parent spring pom --> <groupId>org.springframework.boot</groupI…

Enabling CXF goodies in Spring Boot

In this post we are going to add some of the CXF features to our existing app that we developed in previous post. These features are : ID LoggingJackson Provider for POJO to JSON conversionSwagger 2 documentationStep 1: Configuration class Create a RestServer class in config package as shown below
package org.blog.config;importcom.fasterxml.jackson.jaxrs.json.JacksonJsonProvider;importorg.apache.cxf.feature.LoggingFeature;importorg.apache.cxf.jaxrs.swagger.Swagger2Feature;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configuration;/** * Created by Anand_Rajneesh on 3/23/2017. */@ConfigurationpublicclassRestServer{@Beanpublic JacksonJsonProvider jsonProvider(){returnnewJacksonJsonProvider();}@Beanpublic LoggingFeature loggingFeature(){returnnewLoggingFeature();}@Beanpublic Swagger2Feature swagger(){ Swagger2Feature swagger =new Swagger2Feature(); swagger.setBasePath("/services"); swagger.setContact("…

Power of declarative syntax of Lambda

Since Java has introduced lambda, writing code has become a breeze especially when it comes to expressing what you want to computer to do rather than how to do it. The following is a question from Project Euler and is solved using lambdas in Java8.

Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n). If d(a) = b and d(b) = a, where ab, then a and b are an amicable pair and each of a and b are called amicable numbers. For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220. Evaluate the sum of all the amicable numbers under 10000.  A simple brute force solution is to check every number from 2 to 10000 and if its  an amicable number then add it to sum. Listing it in steps you are basically doing 3 things: Take numbers from 2 to 10000If number is amicableAdd it In Java 7 one will basically start a for loop, mak…