NoSQL Database

 

Introduction

• NoSQL is a type of database management system (DBMS) that is designed to handle and store large volumes of unstructured and semi-structured data.
• Unlike traditional relational databases that use tables with pre-defined schemas to store data, NoSQL databases use flexible data models that can adapt to changes in data structures and are capable of scaling horizontally to handle growing amounts of data.
• The term NoSQL originally referred to “non-SQL” or “non-relational” databases, but the term has since evolved to mean “not only SQL,” as NoSQL databases have expanded to include a wide range of different database architectures and data models

History

• NoSQL databases came about in the late 2000s when storing data became much cheaper.
• The term "NoSQL" was first used by Carlo Strozzi in 1998 to name his lightweight, open-source relational database that did not expose a SQL interface
• Unlike older databases, they could easily handle many types of information without needing a strict structure.
• As time went on, these databases got better at handling huge amounts of data across many computers.
• Now, NoSQL databases help companies quickly make sense of their data and use it to make smart decisions.
• The main idea is that NoSQL databases changed how we store and use data, making it easier to work with the massive amount of information we create in today's digital world.

NoSQL Database Features

• Distributed computing
• Scaling
• Flexible schemas
• High availability

Distributed Database System

distributed database is a database that stores data in multiple locations instead of one location. This means that rather than putting all data on one server or on one computer, data is placed on multiple servers or in a cluster of computers consisting of individual nodes. These nodes are oftentimes geographically separate and may be physical computers or virtual machines

MongoDB Distributed Database

Distributed database types

• Homogeneous distributed databases

The servers store the same data, use the same data model, work with the same operating system, and share the same distributed database management system (DDBMS) or occasionally multiple types of DDBMS from the same vendor

• Heterogeneous distributed databases

Different machines may house different data sets, use different operating systems, contain different data schemas, and require software to facilitate communication between machines

Database Scalability

Database scalability is the ability to expand or contract the capacity of system resources in order to support the changing usage of your application. This can refer both to increasing and decreasing usage of the application

There are two types of scaling database vertically or horizontally

• Vertical scaling

Vertical scaling refers to increasing the processing power of a single server or cluster. Both relational and non-relational databases can scale up

• Horizontal scaling

Horizontal scaling, also known as scale-out, refers to bringing on additional nodes to share the load

Flexible Schemas

• No predefined structure required
• Easily adapts to changing data needs
• Stores diverse data types together
• Supports semi-structured and unstructured data
• Enables faster development and iteration
• Reduces need for schema migrations
• Allows easy addition of new fields
• Facilitates handling of evolving data
• Simplifies integration of varied data sources

High availability

• NoSQL databases are built to be highly available and distributed, which means they spread data across many servers or locations.
• This design helps them keep working even if some parts of the system fail.
• The database automatically makes copies of data to keep it safe and available.
• This approach allows the database to handle many users at once and grow easily by just adding more servers.
• The main goal is to make sure data is always there when needed, no matter what happens

Types of NoSQL Databases

NoSQL provides other options for organizing data in many ways. By offering diverse data structures, NoSQL can be applied to data analytics, managing big data, social networks, and mobile app development.

A NoSQL database manages information using any of these primary data models:

• Key-value store
• Document store
• Wide-column store
• Graph store

Key-value store

• Key-value stores are most basic types of NoSQL databases.
• Designed to handle huge amounts of data.
• Key value stores allow developer to store schema-less data.
• In the key-value storage, database stores data as hash table where each key is unique and the value can be string, JSON, BLOB (Binary Large Object) etc.
• A key may be strings, hashes, lists, sets, sorted sets and values are stored against these keys.
• For example a key-value pair might consist of a key like "Name" that is associated with a value like "Robin".
• Key-Value stores can be used as collections, dictionaries, associative arrays etc.
• Key-Values stores would work well for shopping cart contents, or individual values like colour schemes, a landing page URI, or a default account number.
• Example of Key-value store Database : Redis, Dynamo, Memcached. etc

Document store

• Document databases store data in flexible, JSON-like documents.
• Designed to handle semi-structured and unstructured data efficiently.
• Document databases allow developers to store and query data without a predefined schema.
• In document storage, each record is a self-contained document that can have a different structure from other documents in the same collection.
• Documents can contain various data types including strings, numbers, booleans, arrays, and nested objects.
• For example, a document might represent a user profile with fields like "name", "email", "age", and a nested object for "address".
• Document databases can be used for content management systems, user profiles, game states, and product catalogs.
• Document databases typically offer high performance for read and write operations
• They support horizontal scaling, allowing databases to grow by adding more servers to a cluster.
• Examples of document databases include MongoDB, Couchbase, and Apache CouchDB.

Wide-column store

• Wide-column stores organize data into tables with rows and flexible, dynamic columns.
• Designed for handling massive amounts of structured and semi-structured data efficiently.
• Excel at managing time-series data, IoT sensor data, and scenarios with high write volumes.
• Provide high scalability, distributing data across many commodity servers.
• Offer fast write performance and efficient data compression.
• Support flexible schema, allowing columns to be added on the fly without altering the entire table.
• Typically queried using SQL-like languages or custom APIs provided by the database.
• Commonly used in fraud detection, recommendation engines, and financial services applications.
• Examples include Apache Cassandra, HBase, and Google BigTable.

Graph store

• Graph databases store data in the form of nodes and edges.
• Designed to efficiently represent and query highly interconnected data.
• Based on graph theory and network analysis concepts.
• Nodes typically represent entities like people, places, or things (similar to nouns).
• Edges represent relationships or connections between nodes.
• Graph databases excel at finding patterns and relationships within complex data structures.
• They are particularly useful for social networks, recommendation engines, and fraud detection systems.
• They offer high performance for relationship-based queries that would be complex and slow in traditional databases.
• Examples of graph databases include Neo4j, Amazon Neptune, and JanusGraph.

Comparison of SQL vs NoSQL

SQL	NoSQL
Stands for Structured Query Language	Stands for Not Only SQL
Relational database management system (RDBMS)	Non-relational database management system
Suitable for structured data with predefined schema	Suitable for unstructured and semi-structured data
Data is stored in tables with columns and rows	Data is stored in collections or documents
Supports JOIN and complex queries	Does not support JOIN and complex queries
Uses normalized data structure	Uses denormalized data structure
Requires vertical scaling to handle large volumes of data	Horizontal scaling is possible to handle large volumes of data
Examples: MySQL, PostgreSQL, Oracle, SQL Server, Microsoft SQL Server	Examples: MongoDB, Cassandra, Couchbase, Amazon DynamoDB, Redis

Strengths and Weaknesses

NoSQL Databases

Strengths:

• Highly scalable and distributed
• Flexible schema for evolving data structures
• Better performance for certain use cases (e.g., high write loads)
• Efficient for handling large volumes of unstructured data

Weaknesses:

• Potential for data inconsistency
• Limited support for complex queries and joins
• Lack of standardization across different NoSQL databases
• May require specialized skills for development and maintenance

Relational Databases

Strengths:

• Strong consistency and ACID compliance
• Complex queries and joins
• Mature technology with widespread support
• Standardized query language (SQL)

Weaknesses:

• Less flexible for unstructured data
• Can be challenging to scale horizontally
• May have performance issues with very large datasets
• Schema changes can be complex and time-consuming

Use Cases and Applications of NoSQL Database 

• Real-Time Analytics: Handling and analysing streaming data from various sources.
• Big Data: Managing and processing large datasets in distributed environments.
• Content Management Systems (CMS): Storing and retrieving content for websites and applications.
• IoT and Mobile Apps: Managing sensor data and user-generated content in mobile and IoT applications

Popular NoSQL Databases

MongoDB

• Type: Document Store
• Key Features: Flexible data model, high scalability, rich query language, replication, and high availability.
• Use Cases: Content management systems, e-commerce applications, real-time analytics.

Cassandra

• Type: Column-Family Store
• Key Features: High availability, fault tolerance, scalability.
• Use Cases: Time-series data, real-time big data applications, event logging.

Redis

• Type: Key-Value Store
• Key Features: In-memory data structure, data persistence options, rich data types, pub/sub messaging.
• Use Cases: Caching, session management, real-time analytics.

Neo4j

• Type: Graph Database
• Key Features: Efficient relationship querying, Cypher query language, ACID transactions, scalability.
• Use Cases: Social networks, fraud detection, recommendation engines