NoSQL Databases: MongoDB and Redis Complete Guide

NoSQL databases have become essential tools in modern application development, offering flexibility, scalability, and performance advantages over traditional relational databases. MongoDB and Redis are two of the most popular NoSQL databases, each serving different use cases.

This comprehensive guide covers NoSQL databases, focusing on MongoDB (document database) and Redis (key-value store). You'll learn when to use NoSQL, how to work with MongoDB and Redis, caching strategies, and best practices for NoSQL database design.

NoSQL (Not Only SQL) refers to non-relational databases that provide flexible data models:

NoSQL Database Types:

• Document Databases: MongoDB, CouchDB

• Key-Value Stores: Redis, DynamoDB

• Column Stores: Cassandra, HBase

• Graph Databases: Neo4j, ArangoDB

When to Use NoSQL:

• Flexible Schema: Rapidly changing data structures

• Horizontal Scaling: Need to scale across multiple servers

• High Performance: Fast read/write operations

• Large Data Volumes: Handling big data

• Real-time Applications: Low latency requirements

NoSQL vs SQL:

• NoSQL: Flexible schema, horizontal scaling, fast writes

• SQL: Structured data, ACID transactions, complex queries

// Using Mongoose
const mongoose = require('mongoose');

// Connect to MongoDB
mongoose.connect('mongodb://localhost:27017/myapp', {
    useNewUrlParser: true,
    useUnifiedTopology: true
});

// Define Schema
const userSchema = new mongoose.Schema({
    name: { type: String, required: true },
    email: { type: String, required: true, unique: true },
    age: { type: Number, min: 0 },
    createdAt: { type: Date, default: Date.now }
});

// Create Model
const User = mongoose.model('User', userSchema);

// Create User
const user = new User({
    name: 'John Doe',
    email: 'john@example.com',
    age: 30
});
await user.save();

// Find Users
const users = await User.find({ age: { $gte: 18 } });

// Update User
await User.updateOne(
    { email: 'john@example.com' },
    { $set: { age: 31 } }
);

// Delete User
await User.deleteOne({ email: 'john@example.com' });

# Using PyMongo
from pymongo import MongoClient

# Connect to MongoDB
client = MongoClient('mongodb://localhost:27017/')
db = client['myapp']
users = db['users']

# Create User
user = {
    'name': 'John Doe',
    'email': 'john@example.com',
    'age': 30
}
user_id = users.insert_one(user).inserted_id

# Find Users
users_list = list(users.find({'age': {'$gte': 18}}))

# Update User
users.update_one(
    {'email': 'john@example.com'},
    {'$set': {'age': 31}}
)

# Delete User
users.delete_one({'email': 'john@example.com'})

// Using redis
const redis = require('redis');
const client = redis.createClient({
    host: 'localhost',
    port: 6379
});

await client.connect();

// String operations
await client.set('key', 'value');
const value = await client.get('key');

// Hash operations
await client.hSet('user:1', {
    name: 'John',
    email: 'john@example.com'
});
const user = await client.hGetAll('user:1');

// List operations
await client.lPush('tasks', 'task1');
await client.lPush('tasks', 'task2');
const tasks = await client.lRange('tasks', 0, -1);

// Set operations
await client.sAdd('tags', 'javascript', 'nodejs');
const tags = await client.sMembers('tags');

// Expiration
await client.setEx('session:123', 3600, 'session-data');

# Using redis-py
import redis

# Connect to Redis
r = redis.Redis(host='localhost', port=6379, db=0)

# String operations
r.set('key', 'value')
value = r.get('key')

# Hash operations
r.hset('user:1', mapping={
    'name': 'John',
    'email': 'john@example.com'
})
user = r.hgetall('user:1')

# List operations
r.lpush('tasks', 'task1', 'task2')
tasks = r.lrange('tasks', 0, -1)

# Set operations
r.sadd('tags', 'python', 'django')
tags = r.smembers('tags')

# Expiration
r.setex('session:123', 3600, 'session-data')

Redis is commonly used for caching to improve application performance:

// Cache-aside pattern
async function getUser(userId) {
    // Try cache first
    const cached = await client.get(`user:${userId}`);
    if (cached) {
        return JSON.parse(cached);
    }
    
    // Cache miss - fetch from database
    const user = await User.findById(userId);
    
    // Store in cache
    await client.setEx(
        `user:${userId}`,
        3600, // 1 hour
        JSON.stringify(user)
    );
    
    return user;
}

// Write-through pattern
async function updateUser(userId, data) {
    // Update database
    const user = await User.updateOne({ _id: userId }, data);
    
    // Update cache
    await client.setEx(
        `user:${userId}`,
        3600,
        JSON.stringify(user)
    );
    
    return user;
}

// Invalidate cache on update
async function deleteUser(userId) {
    // Delete from database
    await User.deleteOne({ _id: userId });
    
    // Invalidate cache
    await client.del(`user:${userId}`);
}

// Create indexes
userSchema.index({ email: 1 });
userSchema.index({ createdAt: -1 });
userSchema.index({ name: 'text' }); // Text search

// Compound indexes
userSchema.index({ status: 1, createdAt: -1 });

// Aggregation example
const result = await User.aggregate([
    { $match: { age: { $gte: 18 } } },
    { $group: { _id: '$status', count: { $sum: 1 } } },
    { $sort: { count: -1 } }
]);

Follow these best practices for Redis:

1. Key Naming:

• Use consistent naming convention

• Include namespace (e.g., `user:123`)

• Keep keys short but descriptive

2. Memory Management:

• Set appropriate expiration times

• Use eviction policies

• Monitor memory usage

3. Data Structures:

• Choose appropriate data structure

• Use hashes for objects

• Use sets for unique collections

• Use sorted sets for rankings

4. Persistence:

• Configure RDB snapshots

• Use AOF for durability

• Balance performance vs persistence

Choose the right database for your use case:

Use NoSQL When:

• Need flexible schema

• High write throughput

• Horizontal scaling required

• Document/JSON data

• Real-time applications

• Caching needs

Use SQL When:

• Complex queries and joins

• ACID transactions required

• Structured data

• Existing SQL expertise

• Reporting and analytics

Hybrid Approach:

• Use SQL for transactional data

• Use NoSQL for caching and analytics

• Use both in the same application