Is there any NoSQL data store that is ACID compliant?

Is there any NoSQL data store that is ACID compliant?

I'll post this as an answer purely to support the conversation - Tim Mahy , nawroth , and CraigTP have suggested viable databases. CouchDB would be my preferred due to the use of Erlang, but there are others out there.

I'd say ACID does not contradict or negate the concept of NoSQL... While there seems to be a trend following the opinion expressed by dove , I would argue the concepts are distinct.

NoSQL is fundamentally about simple key-value (e.g. Redis) or document-style schema (collected key-value pairs in a "document" model, e.g. MongoDB) as a direct alternative to the explicit schema in classical RDBMSs. It allows the developer to treat things asymmetrically, whereas traditional engines have enforced rigid same-ness across the data model. The reason this is so interesting is because it provides a different way to deal with change, and for larger data sets it provides interesting opportunities to deal with volumes and performance.

ACID provides principles governing how changes are applied to a database. In a very simplified way, it states (my own version):

• (A) when you do something to change a database the change should work or fail as a whole
• (C) the database should remain consistent (this is a pretty broad topic)
• (I) if other things are going on at the same time they shouldn't be able to see things mid-update
• (D) if the system blows up (hardware or software) the database needs to be able to pick itself back up; and if it says it finished applying an update, it needs to be certain

The conversation gets a little more excitable when it comes to the idea of propagation and constraints. Some RDBMS engines provide the ability to enforce constraints (e.g. foreign keys) which may have propagation elements (a la cascade). In simpler terms, one "thing" may have a relationship with another "thing" in the database, and if you change an attribute of one it may require the other be changed (updated, deleted, ... lots of options). NoSQL databases, being predominantly (at the moment) focused on high data volumes and high traffic, seem to be tackling the idea of distributed updates which take place within (from a consumer perspective) arbitrary time frames. This is basically a specialized form of replication managed via transaction - so I would say that if a traditional distributed database can support ACID, so can a NoSQL database.

Some resources for further reading:

• Wikipedia article on ACID

• Wikipedia on propagation constraints

• Wikipedia (yeah, I like the site, ok?) on database normalization

• Apache documentation on CouchDB with a good overview of how it applies ACID

• Wikipedia on Cluster Computing

• Wikipedia (again...) on database transactions

UPDATE (27 July 2012): Link to Wikipedia article has been updated to reflect the version of the article that was current when this answer was posted. Please note that the current Wikipedia article has been extensively revised!

Well, according to an older version of a Wikipedia article on NoSQL:

> NoSQL is a movement promoting a > loosely defined class of > non-relational data stores that break > with a long history of relational > databases and ACID guarantees.

and also:

> The name was an attempt to describe > the emergence of a growing number of > non-relational, distributed data > stores that often did not attempt to > provide ACID guarantees.

and

> NoSQL systems often provide weak > consistency guarantees such as > eventual consistency and transactions > restricted to single data items, even > though one can impose full ACID > guarantees by adding a supplementary > middleware layer.

So, in a nutshell, I'd say that one of the main benefits of a "NoSQL" data store is its distinct lack of ACID properties. Furthermore, IMHO, the more one tries to implement and enforce ACID properties, the further away from the "spirit" of a "NoSQL" data store you get, and the closer to a "true" RDBMS you get (relatively speaking, of course).

However, all that said, "NoSQL" is a very vague term and is open to individual interpretations, and depends heavily upon just how much of a purist viewpoint you have. For example, most modern-day RDBMS systems don't actually adhere to all of Edgar F. Codd's 12 rules of his relation model!

Taking a pragmatic approach, it would appear that Apache's CouchDB comes closest to embodying both ACID-compliance whilst retaining loosely-coupled, non-relational "NoSQL" mentality.

Please ensure you read the Martin Fowler introduction about NoSQL databases. And the corresponding video.

First of all, we can distinguish two types of NoSQL databases:

1. Aggregate-oriented databases;
2. Graph-oriented databases (e.g. Neo4J).

By design, most Graph-oriented databases are ACID!

Then, what about the other types?

In Aggregate-oriented databases, we can put three sub-types:

• Document-based NoSQL databases (e.g. MongoDB, CouchDB);
• Key/Value NoSQL databases (e.g. Redis);
• Column family NoSQL databases (e.g. Hibase, Cassandra).

What we call an Aggregate here, is what Eric Evans defined in its Domain-Driven Design as a self-sufficient of Entities and Value-Objects in a given Bounded Context.

> As a consequence, an aggregate is a collection of data that we > interact with as a unit. Aggregates form the boundaries for ACID > operations with the database. (Martin Fowler)

So, at Aggregate level, we can say that most NoSQL databases can be as safe as ACID RDBMS, with the proper settings. Of source, if you tune your server for the best speed, you may come into something non ACID. But replication will help.

My main point is that you have to use NoSQL databases as they are, not as a (cheap) alternative to RDBMS. I have seen too much projects abusing of relations between documents. This can't be ACID. If you stay at document level, i.e. at Aggregate boundaries, you do not need any transaction. And your data will be as safe as with an ACID database, even if it not truly ACID, since you do not need those transactions! If you need transactions and update several "documents" at once, you are not in the NoSQL world any more - so use a RDBMS engine instead!

some 2019 update: Starting in version 4.0, for situations that require atomicity for updates to multiple documents or consistency between reads to multiple documents, MongoDB provides multi-document transactions for replica sets.

In this question someone must mention OrientDB: OrientDB is a NoSQL database, one of the few, that support fully ACID transactions. ACID is not only for RDBMS because it's not part of the Relational algebra. So it IS possible to have a NoSQL database that support ACID.

This feature is the one I miss the most in MongoDB

FoundationDB is ACID compliant:

http://www.foundationdb.com/

It has proper transactions, so you can update multiple disparate data items in an ACID fashion. This is used as the foundation for maintaining indexes at a higher layer.

ACID and NoSQL are completely orthogonal. One does not imply the other.

I have a notebook on my desk, I use it to keep notes on things that I still have to do. This notebook is a NoSQL database. I query it using a linear search with a "page cache" so I don't always have to search every page. It is also ACID compliant as I ensure that I only write one thing at a time and never while I am reading it.

NoSQL simply means that it isn't SQL. Many people get confused and think it means highly-scaleable-wild-west-super-fast-storage. It doesn't. It doesn't mean key-value store, or eventual consistency. All it means is "not SQL", there are a lot of databases in this planet and most of them are not SQL^{[citation needed]}.

You can find many examples in the other answers so I need not list them here, but there are non-SQL databases with ACID compliance for various operations, some are only ACID for single object writes while some guarantee far more. Each database is different.

"NoSQL" is not a well-defined term. It's a very vague concept. As such, it's not even possible to say what is and what is not a "NoSQL" product. Not nearly all of the products typcially branded with the label are key-value stores.

As one of the originators of NoSQL (I was an early contributor to Apache CouchDB, and a speaker at the first NoSQL event held at CBS Interactive / CNET in 2009) I'm excited to see new algorithms create possibilities that didn't exist before. The Calvin protocol offers a new way to think of physical constraints like CAP and PACELC.

Instead of active/passive async replication, or active/active synchronous replication, Calvin preserves correctness and availability during replica outages by using a RAFT-like protocol to maintain a transaction log. Additionally, transactions are processed deterministically at each replica, removing the potential for deadlocks, so agreement is achieved with only a single round of consensus. This makes it fast even on multi-cloud worldwide deployments.

FaunaDB is the only database implementation using the Calvin protocol, making it uniquely suited for workloads that require mainframe-like data integrity with NoSQL scale and flexibility.

Yes, MarkLogic Server is a NoSQL solution (document database I like to call it) that works with ACID transactions

The grandfather of NoSQL: ZODB is ACID compliant. http://www.zodb.org/

However, it's Python only.

If you are looking for an ACID compliant key/value store, there's Berkeley DB. Among graph databases at least Neo4j and HyperGraphDB offer ACID transactions (HyperGraphDB actually uses Berkeley DB for low-level storage at the moment).

FoundationDB was mentioned and at the time it wasn't open source. It's been open sourced by Apple two days ago: https://www.foundationdb.org/blog/foundationdb-is-open-source/

I believe it is ACID compliant.

MongoDB announced that its 4.0 version will be ACID compliant for multi-document transactions.

Version 4.2. is supposed to support it under sharded setups.

https://www.mongodb.com/blog/post/multi-document-transactions-in-mongodb

NewSQL

This concept Wikipedia contributors define as:

>[…] a class of modern relational database management systems that seek to provide the same scalable performance of NoSQL systems for online transaction processing (OLTP) read-write workloads while still maintaining the ACID guarantees of a traditional database system.[1][2][3]

References

[1] Nancy Lynch and Seth Gilbert, “Brewer's conjecture and the feasibility of consistent, available, partition-tolerant web services”, ACM SIGACT News, Volume 33 Issue 2 (2002), pg. 51-59.

[2] "Brewer's CAP Theorem", julianbrowne.com, Retrieved 02-Mar-2010

[3] "Brewers CAP theorem on distributed systems", royans.net

take a look at the CAP theorem

EDIT: RavenDB seems to be ACID compliant

To add to the list of alternatives, another fully ACID compliant NoSQL database is GT.M.

Hyperdex Warp http://hyperdex.org/warp/ Warp (ACID feature) is proprietary, but Hyperdex is free.

db4o

> Unlike roll-your-own persistence or > serialization, db4o is ACID > transaction safe and allows for > querying, replication and schema > changes during runtime

http://www.db4o.com/about/productinformation/db4o/

BergDB is a light-weight, open-source, NoSQL database designed from the start to run ACID transactions. Actually, BergDB is "more" ACID than most SQL databases in the sense that the only way to change the state of the database is to run ACID transactions with the highest isolation level (SQL term: "serializable"). There will never be any issues with dirty reads, non-repeatable reads, or phantom reads.

In my opinion, the database is still highly performant; but don't trust me, I created the software. Try it yourself instead.

Tarantool is a fully ACID NoSQL database. You can issue CRUD operations or stored procedures, everything will be run with strict accordance with an ACID property. You can also read about that here: http://stable.tarantool.org/doc/mpage/data-and-persistence.html

MarkLogic is also ACID complient. I think is one of the biggest players now.

Wait is over.

ACID compliant NoSQL DB is out ----------- have a look at citrusleaf

A lot of modern NoSQL solution don't support ACID transactions (atomic isolated multi-key updates), but most of them support primitives which allow you to implement transactions on the application level.

If a data store supports per key linearizability and compare-and-set (document level atomicity) then it's enough to implement client-side transactions, more over you have several options to choose from:

1. If you need Serializable isolation level then you can follow the same algorithm which Google use for the Percolator system or Cockroach Labs for CockroachDB. I've blogged about it and create a step-by-step visualization, I hope it will help you to understand the main idea behind the algorithm.

2. If you expect high contention but it's fine for you to have Read Committed isolation level then please take a look on the RAMP transactions by Peter Bailis.

3. The third approach is to use compensating transactions also known as the saga pattern. It was described in the late 80s in the Sagas paper but became more actual with the raise of distributed systems. Please see the Applying the Saga Pattern talk for inspiration.

The list of data stores suitable for client side transactions includes Cassandra with lightweight transactions, Riak with consistent buckets, RethinkDB, ZooKeeper, Etdc, HBase, DynamoDB, MongoDB and others.

YugaByte DB supports an ACID Compliant distributed txns as well as Redis and CQL API compatibility on the query layer.

Google Cloud Datastore is a NoSQL database that supports ACID transactions

DynamoDB is a NoSQL database and has ACID transactions.

VoltDB is an entrant which claims ACID compliance, and while it still uses SQL, its goals are the same in terms of scalability

Whilst it's only an embedded engine and not a server, leveldb has WriteBatch and the ability to turn on Synchronous writes to provide ACID behaviour.

Node levelUP is transactional and built on leveldb https://github.com/rvagg/node-levelup#batch

If you add enough pure water and successfully flip a coin, anything can become acidic. Or basic for that matter.

To say a database is ACID compliant means four specific things. And in defining the system (restricting the range) we can arbitrarily water down the meanings so that the result is ACID compliance.

• A—if your NoSQL database only allows one record operation at a time and records either go or they don't then that's atomic.
• C—if the only constraints you allow are simple, like checking JSON schemas against a known schema then that's consistent.
• I—if just append-only transactions are supported (and schema changes are disallowed) then it is impossible for anything to depend on anything else, that's independent.
• D—if you turn off all machines at night and synchronize disks then the transactions will be it in or they won't, that's durable.

Not only NoSQL is not ACID compliant by design. NoSQL movement embrace the BASE (Basically Available, Soft state, Eventual consistency) claimed to be the opposite of ACID. NoSQL database are often called Eventually-Consisted database. To understand the differences you should drill down into the CAP theorem (aka Brewer's theorem)

Visit http://www.julianbrowne.com/article/viewer/brewers-cap-theorem