For over four decades now, Relational Database Management Systems (RDMS) have dominated the enterprise market. However, the trend seems to change with the introduction of NoSQL databases. In this article, we are going to highlight practical examples where NoSQL systems have been deployed. We will also go further and point out other applications where implementation of such systems might be necessary.

NoSQL stands for “Not Only Sql.”  Some people think this term opposes Sql, but that is not the case. NoSQL systems are non-relational and can coexist with relational databases. They are suitable in applications where a large amount of data is involved. Data in this case is either structured, unstructured or semi-structured.

There are different types of NoSQL databases. Some of these include Apache Cassandra, Mongo DB, Coach DB, Redis, Infinite Graph, and HBase among others. All of them differ in terms of structure and usage. Depending on these factors, such databases have been further classified into various categories.

Since NoSQL databases cannot be used interchangeably, we will look at the practical usages of them in this article as per these categories. They are not compatible like relational databases. In situations where you need a certain category of NoSQL you can not use a different one. Each of them is specialized in a certain environment.

There are four NoSQL database categories we will look at:

  • Key-Valued Stores
  • Column Family Stores
  • Document Databases
  • Graph Databases.

Key-Valued Stores

Key-value stores allow application developers to store data in an unstructured manner. The stored data contains a key and the actual data. Therefore, in simple terms, Key-Value Stores keep data by keys:

key-value database example

Such databases are the simplest to implement. They are mostly preferred when one is working with complex data that is difficult to model. Also, they are the best in situations where the write performance (rapid recording of data) is prioritized. The third environment where these databases prevail is when data is accessed by key.

Notable examples of NoSQL databases in this category include Voldemort, Tokyo Cabinet, Redis, and Amazon Dynamo.

Key-value stores are used in such projects like:

  • Amazon’s Shopping Cart (Amazon Dynamo is used)
  • Mozilla Test Pilot
  • Rhino DHT

Column Family Stores

Column Family Stores are also referred to as distributed peer stores. They are designed to handle huge amount of data distributed over many servers. Like Key-Value Stores, they use keys. However, the key points to multiple columns of the database. Columns here are organized by the column family:

column family database example

Examples of databases in this category include Cassandra, HBase and Riak. Google’s Big Data also falls into this category, though it is not distributed outside the Google platform.

Typical applications that have implemented Column Family Stores databases include:

  • Google Earth, Maps- Google’s Big Data
  • Ebay
  • The New York Times
  • Comcast
  • Hulu

Databases in this category are suitable for applications with distributed file systems. The key strengths for these tools in distributed applications lie in their distributed storage nature and retrieval capacity.

Document Databases

These categories of database manage document-oriented data (semi-structured data). Here, data may be represented in formats similar to JSON. Each document has an arbitrary set of properties that may differ from other documents in the same collection:

document database example

Examples of databases under this category include: MongoDB and CouchDB.

The following applications are practical examples where the above document databases have been used:

  • Linked-In
  • Dropbox Mailbox

Document databases are suitable for use in applications that need to keep data in a complicated multi-level format without a fixed schema for each record. They are especially good for straightforward mapping of business models to database entities.

Graph Databases

These databases keep data in the forms of nodes, properties and edges. Nodes stand for objects whose data we want to store, properties represent the features of those objects, and edges show the relationships between those objects (nodes). In this representation, adjacent nodes point to each other directly (the edges may be directed or indirected):

graph database example

Examples of databases falling under this category include Neo4j, Infinite Graph and InfoGrid.

Typical applications where graph databases have been implemented include:

  • Polymap
  • Neoclipse
  • Neosocial which connects Facebook

Graph databases may fit any application that requires managing relationships among many objects, like social networks.