MongoDB and Redis in practice

MongoDB: documents and collections

In MongoDB, a document is one record written like JSON (stored as BSON, a binary form). Documents live in a collection, which is like a table without fixed columns. Each document has a unique _id. One document can hold nested objects and arrays, so an order can carry its items inside it. You talk to MongoDB from the mongosh shell or from a driver in your language.

db.food_orders.insertOne({
  customer: "Asha", city: "Pune", amount: 640,
  items: [ { name: "Paneer Tikka", qty: 1 }, { name: "Butter Roti", qty: 4 } ]
})
// { acknowledged: true, insertedId: ObjectId('...') }

find: filters and projection

find takes a filter (which documents) and an optional projection (which fields). Operators start with $: $gt (greater than), $lt, $in, $ne and so on. A field listed with 1 is kept; _id: 0 hides the id.

db.food_orders.find(
  { city: "Pune", amount: { $gt: 500 } },
  { _id: 0, customer: 1, amount: 1 }
)
// [ { customer: 'Asha', amount: 640 }, { customer: 'Asha', amount: 760 } ]

// The same question in SQL:
// SELECT customer, amount FROM food_orders WHERE city = 'Pune' AND amount > 500;

updateOne with $set and $inc

db.food_orders.updateOne(
  { _id: ObjectId("...") },
  { $set: { status: "Delivered" }, $inc: { points: 10 } }
)
// { acknowledged: true, matchedCount: 1, modifiedCount: 1, ... }

The aggregation pipeline

An aggregation pipeline is a list of stages; each stage passes its output to the next, like an assembly line. $match is WHERE, $group is GROUP BY, $sort is ORDER BY.

db.food_orders.aggregate([
  { $match: { amount: { $gte: 400 } } },
  { $group: { _id: "$city", total: { $sum: "$amount" }, orders: { $sum: 1 } } },
  { $sort: { total: -1 } }
])
// [ { _id: 'Pune', total: 1850, orders: 3 }, { _id: 'Mumbai', total: 920, orders: 1 } ]

// SQL: SELECT city, SUM(amount) AS total, COUNT(*) AS orders
//      FROM food_orders WHERE amount >= 400 GROUP BY city ORDER BY total DESC;

Embedding vs referencing

Embedding means putting related data inside the document (the order's items). Referencing means storing an id that points to another document (the customer_id), like a foreign key. Embed what is read together and stays small; reference what is shared, many-to-many, or grows without limit. A single document can be at most 16 MB, so an ever-growing array of reviews belongs in its own collection.

Redis: a fast key-value store

Redis keeps data in memory, so reads and writes take well under a millisecond. Values have types: strings, hashes, lists, sets and sorted sets. Here are the everyday commands, typed in redis-cli:

SET session:abc123 "user:42" EX 1800    # cache for 30 minutes
GET session:abc123                       # "user:42"
TTL session:abc123                       # (integer) 1800, counting down

INCR views:home                          # (integer) 1, then 2, 3...
INCR rate:user42:1230                    # requests this minute
EXPIRE rate:user42:1230 60               # forget the counter after 60 s

HSET user:42 name "Asha" city "Pune"     # (integer) 2
HGET user:42 city                        # "Pune"

LPUSH jobs "send-invoice-101"            # a simple queue
RPOP jobs                                # "send-invoice-101"

ZADD leaderboard 980 asha 1200 ravi 1100 imran
ZRANGE leaderboard 0 2 REV WITHSCORES    # ravi 1200, imran 1100, asha 980

Two more features in one line each. Pub/sub: PUBLISH sends a message to every client that ran SUBSCRIBE on that channel, with no storage. Persistence: Redis can save snapshots (RDB) and/or an append-only log of writes (AOF), but it is usually used as a cache in front of a main database, not as the only copy. Valkey is an open-source fork of Redis that accepts the same commands.

A bridge you can run: JSON in SQLite

Relational engines can store documents too. In SQLite, json_extract(doc, '$.city') reads a field from JSON text, and the table-valued function json_each(doc, '$.items') turns an array into rows. PostgreSQL's JSONB and MySQL's JSON type do the same with their own operators.

SELECT f.id, json_extract(item.value, '$.name') AS item, json_extract(item.value, '$.qty') AS qty
FROM food_orders AS f, json_each(f.doc, '$.items') AS item
WHERE f.id = 1;
-- 1 | Paneer Tikka | 1
-- 1 | Butter Roti  | 4

Common mistakes

• In MongoDB, calling updateOne with a plain object instead of $set, which replaces the whole document. Use update operators.
• Forgetting EX on cache keys in Redis, so memory fills with stale data. Give every cache key an expiry.
• Treating Redis as the only copy of important data without understanding its persistence settings.
• In SQLite, forgetting the $ in paths: json_extract(doc, 'city') is an error; write '$.city'.
• Embedding data that is shared by many documents (a customer's address in every order) and then updating it in only one place.