NoSQL

NoSQL (originally referring to "non-SQL" or "non-relational")[1] is an approach to database design that

focuses on providing a mechanism for storage and retrieval of data that is modeled in means other than
the tabular relations used in relational databases. Instead of the typical tabular structure of a relational
database, NoSQL databases house data within one data structure. Since this non-relational database
design does not require a schema, it offers rapid scalability to manage large and typically unstructured
data sets.[2] NoSQL systems are also sometimes called "Not only SQL" to emphasize that they may
support SQL-like query languages or sit alongside SQL databases in polyglot-persistent
architectures.[3][4]

Non-relational databases have existed since the late 1960s, but the name "NoSQL" was only coined in the
early 2000s,[5] triggered by the needs of Web 2.0 companies.[6][7] NoSQL databases are increasingly used
in big data and real-time web applications.[8]

Motivations for this approach include simplicity of design, simpler "horizontal" scaling to clusters of
machines (which is a problem for relational databases),[5] finer control over availability, and limiting the
object-relational impedance mismatch.[9] The data structures used by NoSQL databases (e.g. key–value
pair, wide column, graph, or document) are different from those used by default in relational databases,
making some operations faster in NoSQL. The particular suitability of a given NoSQL database depends
on the problem it must solve. Sometimes the data structures used by NoSQL databases are also viewed as
"more flexible" than relational database tables.[10]

Many NoSQL stores compromise consistency (in the sense of the CAP theorem) in favor of availability,
partition tolerance, and speed. Barriers to the greater adoption of NoSQL stores include the use of low-
level query languages (instead of SQL, for instance), lack of ability to perform ad hoc joins across tables,
lack of standardized interfaces, and huge previous investments in existing relational databases.[11] Most
NoSQL stores lack true ACID transactions, although a few databases like MongoDB have made them
central to their designs.[12]

Instead, most NoSQL databases offer a concept of "eventual consistency", in which database changes are
propagated to all nodes "eventually" (typically within milliseconds), so queries for data might not return
updated data immediately or might result in reading data that is not accurate, a problem known as stale
read.[13] Additionally, some NoSQL systems may exhibit lost writes and other forms of data loss.[14]
Some NoSQL systems provide concepts such as write-ahead logging to avoid data loss.[15] For
distributed transaction processing across multiple databases, data consistency is an even bigger challenge
that is difficult for both NoSQL and relational databases. Relational databases "do not allow referential
integrity constraints to span databases".[16] Few systems maintain both ACID transactions and X/Open
XA standards for distributed transaction processing.[17] Interactive relational databases share
conformational relay analysis techniques as a common feature.[18] Limitations within the interface
environment are overcome using semantic virtualization protocols, such that NoSQL services are
accessible to most operating systems.[19]

History
The term NoSQL was used by Carlo Strozzi in 1998 to name his lightweight Strozzi NoSQL open-source
relational database that did not expose the standard Structured Query Language (SQL) interface, but was
still relational.[20] His NoSQL RDBMS is distinct from the around-2009 general concept of NoSQL
databases. Strozzi suggests that, because the current NoSQL movement "departs from the relational
model altogether, it should therefore have been called more appropriately 'NoREL'",[21] referring to "not
relational".

Johan Oskarsson, then a developer at Last.fm, reintroduced the term NoSQL in early 2009 when he
organized an event to discuss "open-source distributed, non-relational databases".[22] The name attempted
to label the emergence of an increasing number of non-relational, distributed data stores, including open
source clones of Google's Bigtable/MapReduce and Amazon's DynamoDB.

Types and examples

There are various ways to classify NoSQL databases, with different categories and subcategories, some of
which overlap. What follows is a non-exhaustive classification by data model, with examples:[23]
 Type Notable examples of this type

Key–value Apache Ignite, Couchbase, Coherence, eXtreme Scale, Hazelcast, Infinispan, Memcached,
cache Redis, Velocity

Key–value store Azure Cosmos DB, ArangoDB, Amazon DynamoDB, Aerospike, Couchbase, ScyllaDB
Key–value store
(eventually Azure Cosmos DB, Oracle NoSQL Database, Riak, Voldemort
consistent)

Key–value store
FoundationDB, InfinityDB, LMDB, MemcacheDB
(ordered)

Tuple store Apache River, GigaSpaces, Tarantool, TIBCO ActiveSpaces, OpenLink Virtuoso
AllegroGraph, MarkLogic, Ontotext-OWLIM, Oracle NoSQL database, Profium Sense,
Triplestore
Virtuoso Universal Server

Objectivity/DB, Perst, ZODB, db4o, GemStone/S, InterSystems Caché, JADE,

Object database ObjectDatabase++, ObjectDB, ObjectStore, ODABA, Realm, OpenLink Virtuoso, Versant
Object Database

Azure Cosmos DB, ArangoDB, BaseX, Clusterpoint, Couchbase, CouchDB, DocumentDB,

Document store eXist-db, Google Cloud Firestore, IBM Domino, MarkLogic, MongoDB, RavenDB, Qizx,
RethinkDB, Elasticsearch, OrientDB
Wide-column Azure Cosmos DB, Amazon DynamoDB, Bigtable, Cassandra, Google Cloud Datastore,
store HBase, Hypertable, ScyllaDB

Native multi- ArangoDB, Azure Cosmos DB, OrientDB, MarkLogic, Apache Ignite,[24][25] Couchbase,
model database FoundationDB, Oracle Database

Azure Cosmos DB, AllegroGraph, ArangoDB, InfiniteGraph, Apache Giraph, MarkLogic,

Graph database
Neo4J, OrientDB, Virtuoso

D3 Pick database, Extensible Storage Engine (ESE/NT), InfinityDB, InterSystems Caché,

jBASE Pick database, mvBase Rocket Software, mvEnterprise Rocket Software, Northgate
Multivalue
Information Solutions Reality (the original Pick/MV Database), OpenQM, Revelation
database
Software's OpenInsight (Windows) and Advanced Revelation (DOS), UniData Rocket U2,
UniVerse Rocket U2

Key–value store
Key–value (KV) stores use the associative array (also called a map or dictionary) as their fundamental
data model. In this model, data is represented as a collection of key–value pairs, such that each possible
key appears at most once in the collection.[26][27]

The key–value model is one of the simplest non-trivial data models, and richer data models are often
implemented as an extension of it. The key–value model can be extended to a discretely ordered model
that maintains keys in lexicographic order. This extension is computationally powerful, in that it can
efficiently retrieve selective key ranges.[28]

Key–value stores can use consistency models ranging from eventual consistency to serializability. Some
databases support ordering of keys. There are various hardware implementations, and some users store
data in memory (RAM), while others on solid-state drives (SSD) or rotating disks (aka hard disk drive
(HDD)).

Document store
The central concept of a document store is that of a "document". While the details of this definition differ
among document-oriented databases, they all assume that documents encapsulate and encode data (or
information) in some standard formats or encodings. Encodings in use include XML, YAML, and JSON
and binary forms like BSON. Documents are addressed in the database via a unique key that represents
that document. Another defining characteristic of a document-oriented database is an API or query
language to retrieve documents based on their contents.

Different implementations offer different ways of organizing and/or grouping documents:

Collections
Tags
Non-visible metadata
Directory hierarchies
Compared to relational databases, collections could be considered analogous to tables and documents
analogous to records. But they are different – every record in a table has the same sequence of fields,
while documents in a collection may have fields that are completely different.

Graph
Graph databases are designed for data whose relations are well represented as a graph consisting of
elements connected by a finite number of relations. Examples of data include social relations, public
transport links, road maps, network topologies, etc.

Graph databases and their query language

 Name Language(s) Notes

AllegroGraph SPARQL RDF triple store

Amazon Neptune Gremlin, SPARQL Graph database

Multi-model DBMS Document, Graph database and Key-
ArangoDB AQL, JavaScript, GraphQL
value store

Azure Cosmos
Gremlin Graph database
DB

DEX/Sparksee C++, Java, C#, Python Graph database

FlockDB Scala Graph database

IBM Db2 SPARQL RDF triple store added in DB2 10

InfiniteGraph Java Graph database

JanusGraph Java Graph database

Java, JavaScript, SPARQL,

MarkLogic Multi-model document database and RDF triple store
XQuery

Neo4j Cypher Graph database

OpenLink
C++, C#, Java, SPARQL Middleware and database engine hybrid
Virtuoso

Oracle SPARQL 1.1 RDF triple store added in 11g

OrientDB Java, SQL Multi-model document and graph database

OWLIM Java, SPARQL 1.1 RDF triple store

Profium Sense Java, SPARQL RDF triple store

RedisGraph Cypher Graph database

Sqrrl Enterprise Java Graph database

TerminusDB JavaScript, Python, datalog Open source RDF triple-store and document store[29]

Performance
The performance of NoSQL databases is usually evaluated using the metric of throughput, which is
measured as operations/second. Performance evaluation must pay attention to the right benchmarks such
as production configurations, parameters of the databases, anticipated data volume, and concurrent user
workloads.

Ben Scofield rated different categories of NoSQL databases as follows:[30]

 Data
Data model Performance Scalability Flexibility Complexity Functionality
Integrity

Key–value store high high high none low variable (none)

Column-oriented
high high moderate low low minimal
store
Document- variable
high high low low variable (low)
oriented store (high)

Graph database variable variable high high low-med graph theory

Relational relational
variable variable low moderate high
database algebra

Performance and scalability comparisons are most commonly done using the YCSB benchmark.

Handling relational data

Since most NoSQL databases lack ability for joins in queries, the database schema generally needs to be
designed differently. There are three main techniques for handling relational data in a NoSQL database.
(See table Join and ACID Support for NoSQL databases that support joins.)

Multiple queries
Instead of retrieving all the data with one query, it is common to do several queries to get the desired data.
NoSQL queries are often faster than traditional SQL queries so the cost of additional queries may be
acceptable. If an excessive number of queries would be necessary, one of the other two approaches is
more appropriate.

Caching, replication and non-normalized data

Instead of only storing foreign keys, it is common to store actual foreign values along with the model's
data. For example, each blog comment might include the username in addition to a user id, thus providing
easy access to the username without requiring another lookup. When a username changes however, this
will now need to be changed in many places in the database. Thus this approach works better when reads
are much more common than writes.[31]

Nesting data
With document databases like MongoDB it is common to put more data in a smaller number of
collections. For example, in a blogging application, one might choose to store comments within the blog
post document so that with a single retrieval one gets all the comments. Thus in this approach a single
document contains all the data you need for a specific task.

ACID and join support

A database is marked as supporting ACID properties (Atomicity, Consistency, Isolation, Durability) or
join operations if the documentation for the database makes that claim. However, this doesn't necessarily
mean that the capability is fully supported in a manner similar to most SQL databases.

Database ACID Joins

Aerospike Yes No

Apache Ignite Yes Yes

ArangoDB Yes Yes

Amazon DynamoDB Yes No

Couchbase Yes Yes

CouchDB Yes Yes

IBM Db2 Yes Yes

InfinityDB Yes No
LMDB Yes No

MarkLogic Yes Yes[nb 1]

MongoDB Yes Yes[nb 2]

OrientDB Yes Yes[nb 3]

1. Joins do not necessarily apply to document databases, but MarkLogic can do joins using
semantics.[32]
2. MongoDB did not support joining from a sharded collection until version 5.1.[33]
3. OrientDB can resolve 1:1 joins using links by storing direct links to foreign records.[34]

See also
CAP theorem
Comparison of object database management systems
Comparison of structured storage software
C++
Database scalability
Distributed cache
Faceted search
MultiValue database
Multi-model database
Schema-agnostic databases
Triplestore
Vector database

References
1. http://nosql-database.org/ "NoSQL DEFINITION: Next Generation Databases mostly
addressing some of the points : being non-relational, distributed, open-source and
 horizontally scalable".
2. "What Is a NoSQL Database? | IBM" (https://www.ibm.com/topics/nosql-databases).
www.ibm.com. 12 December 2022. Retrieved 9 August 2024.
3. "NoSQL (Not Only SQL)" (http://searchdatamanagement.techtarget.com/definition/NoSQL-N
ot-Only-SQL). "NoSQL database, also called Not Only SQL"
4. Fowler, Martin. "NosqlDefinition" (http://martinfowler.com/bliki/NosqlDefinition.html). "many
advocates of NoSQL say that it does not mean a "no" to SQL, rather it means Not Only
SQL"
5. Leavitt, Neal (2010). "Will NoSQL Databases Live Up to Their Promise?" (http://www.leavco
m.com/pdf/NoSQL.pdf) (PDF). IEEE Computer. 43 (2): 12–14. doi:10.1109/MC.2010.58 (htt
ps://doi.org/10.1109%2FMC.2010.58). S2CID 26876882 (https://api.semanticscholar.org/Co
rpusID:26876882).
6. Mohan, C. (2013). History Repeats Itself: Sensible and NonsenSQL Aspects of the NoSQL
Hoopla (http://openproceedings.eu/2013/conf/edbt/Mohan13.pdf) (PDF). Proc. 16th Int'l
Conf. on Extending Database Technology.
7. "Amazon Goes Back to the Future With 'NoSQL' Database" (https://www.wired.com/2012/0
1/amazon-dynamodb/). WIRED. 19 January 2012. Retrieved 6 March 2017.
8. "RDBMS dominate the database market, but NoSQL systems are catching up" (http://db-en
gines.com/en/blog_post/23). DB-Engines.com. 21 November 2013. Retrieved 24 November
2013.
9. NoSQL Distilled: A Brief Guide to the Emerging World of Polyglot Persistence. Addison-
Wesley Educational Publishers Inc, 2009, ISBN 978-0321826626.
10. Vogels, Werner (18 January 2012). "Amazon DynamoDB – a Fast and Scalable NoSQL
Database Service Designed for Internet Scale Applications" (http://www.allthingsdistributed.c
om/2012/01/amazon-dynamodb.html). All Things Distributed. Retrieved 6 March 2017.
11. Grolinger, K.; Higashino, W. A.; Tiwari, A.; Capretz, M. A. M. (2013). "Data management in
cloud environments: NoSQL and NewSQL data stores" (http://www.journalofcloudcomputin
g.com/content/pdf/2192-113X-2-22.pdf) (PDF). Aira, Springer. Retrieved 8 January 2014.
12. "MongoDB ACID Transactions" (https://www.geeksforgeeks.org/acid-transactions-in-mongo
db/). GeeksforGeeks. 12 March 2024. Retrieved 25 October 2024.
13. "Jepsen: MongoDB stale reads" (https://aphyr.com/posts/322-call-me-maybe-mongodb-stale
-reads). Aphyr.com. 20 April 2015. Retrieved 6 March 2017.
14. "Large volume data analysis on the Typesafe Reactive Platform" (https://www.slideshare.ne
t/MartinZapletal/zapletal-martinlargevolumedataanalytics). Slideshare.net. 11 June 2015.
Retrieved 6 March 2017.
15. Fowler, Adam. "10 NoSQL Misconceptions" (http://www.dummies.com/how-to/content/10-no
sql-misconceptions.html). Dummies.com. Retrieved 6 March 2017.
16. "No! to SQL and No! to NoSQL | So Many Oracle Manuals, So Little Time" (https://iggyferna
ndez.wordpress.com/2013/07/28/no-to-sql-and-no-to-nosql/).
Iggyfernandez.wordpress.com. 29 July 2013. Retrieved 6 March 2017.
17. Chapple, Mike. "The ACID Model" (https://web.archive.org/web/20161229001436/http://data
bases.about.com/od/specificproducts/a/acid.htm). about.com. Archived from the original (htt
p://databases.about.com/od/specificproducts/a/acid.htm) on 29 December 2016. Retrieved
26 September 2012.
18. Fiore, S. (2011). Grid and cloud database management. Springer Science & Business
Media. p. 210.
19. Lawrence, Integration and virtualization of relational SQL and NoSQL systems including
MySQL and MongoDB (2014). "Integration and virtualization of relational SQL and NoSQL
systems including MySQL and MongoDB". International Conference on Computational
Science and Computational Intelligence 1.
20. Lith, Adam; Mattson, Jakob (2010). "Investigating storage solutions for large data: A
comparison of well performing and scalable data storage solutions for real time extraction
and batch insertion of data" (http://publications.lib.chalmers.se/records/fulltext/123839.pdf)
(PDF). Göteborg: Department of Computer Science and Engineering, Chalmers University
of Technology. p. 70. Retrieved 12 May 2011. "Carlo Strozzi first used the term NoSQL in
1998 as a name for his open source relational database that did not offer a SQL
interface[...]"
21. "NoSQL Relational Database Management System: Home Page" (http://www.strozzi.it/cgi-bi
n/CSA/tw7/I/en_US/nosql/Home%20Page). Strozzi.it. 2 October 2007. Retrieved 29 March
2010.
22. "NoSQL 2009" (https://web.archive.org/web/20110716174012/http://blog.sym-link.com/200
9/05/12/nosql_2009.html). Blog.sym-link.com. 12 May 2009. Archived from the original (htt
p://blog.sym-link.com/2009/05/12/nosql_2009.html) on 16 July 2011. Retrieved 29 March
2010.
23. Strauch, Christof. "NoSQL Databases" (http://www.christof-strauch.de/nosqldbs.pdf) (PDF).
pp. 23–24. Retrieved 27 August 2017.
24. https://apacheignite.readme.io/docs Ignite Documentation
25. https://www.infoworld.com/article/3135070/data-center/fire-up-big-data-processing-with-
apache-ignite.html fire-up-big-data-processing-with-apache-ignite
26. Sandy (14 January 2011). "Key Value stores and the NoSQL movement" (http://dba.stackex
change.com/a/619). Stackexchange. Retrieved 1 January 2012. "Key–value stores allow the
application developer to store schema-less data. This data usually consists of a string that
represents the key, and the actual data that is considered the value in the "key–value"
relationship. The data itself is usually some kind of primitive of the programming language (a
string, an integer, or an array) or an object that is being marshaled by the programming
language's bindings to the key-value store. This structure replaces the need for a fixed data
model and allows proper formatting."
27. Seeger, Marc (21 September 2009). "Key-Value Stores: a practical overview" (http://blog.ma
rc-seeger.de/assets/papers/Ultra_Large_Sites_SS09-Seeger_Key_Value_Stores.pdf)
(PDF). Marc Seeger. Retrieved 1 January 2012. "Key–value stores provide a high-
performance alternative to relational database systems with respect to storing and
accessing data. This paper provides a short overview of some of the currently available
key–value stores and their interface to the Ruby programming language."
28. Katsov, Ilya (1 March 2012). "NoSQL Data Modeling Techniques" (http://highlyscalable.word
press.com/2012/03/01/nosql-data-modeling-techniques/). Ilya Katsov. Retrieved 8 May
2014.
29. "TerminusDB an open-source in-memory document graph database" (https://terminusdb.co
m/products/terminusdb/). terminusdb.com. Retrieved 16 December 2021.
30. Scofield, Ben (14 January 2010). "NoSQL - Death to Relational Databases(?)" (https://www.
slideshare.net/bscofield/nosql-codemash-2010). Retrieved 26 June 2014.
31. "Moving From Relational to NoSQL: How to Get Started" (https://resources.couchbase.com/
c/relational-no-sql-wp?x=3-FqHm). Couchbase.com. Retrieved 11 November 2019.
32. "Can't do joins with MarkLogic? It's just a matter of Semantics! - General Networks" (https://
web.archive.org/web/20170303200231/http://gennet.com/big-data/cant-joins-marklogic-just-
matter-semantics/). Gennet.com. Archived from the original (https://www.gennet.com/big-dat
a/cant-joins-marklogic-just-matter-semantics/) on 3 March 2017. Retrieved 6 March 2017.
33. "Sharded Collection Restrictions" (https://docs.mongodb.com/manual/reference/operator/ag
gregation/lookup/#sharded-collection-restrictions). docs.mongodb.com. Retrieved
24 January 2020.
34. "SQL Reference · OrientDB Manual" (http://orientdb.com/docs/2.2.x/SQL.html#joins).
OrientDB.com. Retrieved 24 January 2020.
Further reading
Sadalage, Pramod; Fowler, Martin (2012). NoSQL Distilled: A Brief Guide to the Emerging
World of Polyglot Persistence. Addison-Wesley. ISBN 978-0-321-82662-6.
McCreary, Dan; Kelly, Ann (2013). Making Sense of NoSQL: A guide for managers and the
rest of us. Manning. ISBN 9781617291074.
Wiese, Lena (2015). Advanced Data Management for SQL, NoSQL, Cloud and Distributed
Databases. DeGruyter/Oldenbourg. ISBN 978-3-11-044140-6.
Strauch, Christof (2012). "NoSQL Databases" (http://www.christof-strauch.de/nosqldbs.pdf)
(PDF).
Moniruzzaman, A. B.; Hossain, S. A. (2013). "NoSQL Database: New Era of Databases for
Big data Analytics - Classification, Characteristics and Comparison". arXiv:1307.0191 (http
s://arxiv.org/abs/1307.0191) [cs.DB (https://arxiv.org/archive/cs.DB)].
Orend, Kai (2013). "Analysis and Classification of NoSQL Databases and Evaluation of their
Ability to Replace an Object-relational Persistence Layer". CiteSeerX 10.1.1.184.483 (http
s://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.184.483).
Krishnan, Ganesh; Kulkarni, Sarang; Dadbhawala, Dharmesh Kirit. "Method and system for
versioned sharing, consolidating and reporting information" (https://patents.google.com/pate
nt/US7383272?oq=ganesh+krishnan).

External links
Strauch, Christof. "NoSQL whitepaper" (http://www.christof-strauch.de/nosqldbs.pdf) (PDF).
Stuttgart: Hochschule der Medien.
Edlich, Stefan. "NoSQL database List" (http://nosql-database.org/).
Neubauer, Peter (2010). "Graph Databases, NOSQL and Neo4j" (http://www.infoq.com/articl
es/graph-nosql-neo4j).
Bushik, Sergey (2012). "A vendor-independent comparison of NoSQL databases:
Cassandra, HBase, MongoDB, Riak" (https://www.networkworld.com/article/665327/tech-pri
mers-a-vendor-independent-comparison-of-nosql-databases-cassandra-hbase-mongodb-ria
k.html). NetworkWorld.
Zicari, Roberto V. (2014). "NoSQL Data Stores – Articles, Papers, Presentations" (http://ww
w.odbms.org/category/downloads/nosql-data-stores/nosql-data-stores-articles/). odbms.org.

Retrieved from "https://en.wikipedia.org/w/index.php?title=NoSQL&oldid=1253374628"