MongoDB 101: The Document Model

From "why" to "how"

Lecture 11 argued that document databases exist because applications think in nested objects and tables do not. Today we stop arguing and start typing.

This is a document

{
  _id: ObjectId("65f1a2c4e8b9d4a1c2f30142"),
  booking_id: "CNR3000142",
  booked_at: ISODate("2024-03-14T18:22:07Z"),
  status: "Completed",
  customer_id: "CID482910",
  vehicle_type: "Go Sedan",
  route:   { pickup: "Connaught Place", drop: "Aerocity" },
  booking_value: 412.50,
  ride_distance: 18.4,
  ratings: { driver: 4.6, customer: 4.8 },
  payment_method: "UPI"
}

The hierarchy, mapped to what you know

Same collection, different shapes

{ status: "Completed",
  avg_vtat: 7.4,
  avg_ctat: 31.2,
  booking_value: 412.50,
  ride_distance: 18.4,
  ratings: {driver:4.6,
            customer:4.8},
  payment_method: "UPI" }

{ status:
    "Cancelled by Driver",
  avg_vtat: 2.84,
  cancellation: {
    by: "driver",
    reason: "Personal & Car
             related issues" } }

You write JSON. Mongo stores BSON.

Every document has an _id

ObjectId("65f1a2c4  e8b9d4a1c2  f30142")
          --------  ----------  ------
          4 bytes   5 bytes     3 bytes
          timestamp random      counter
          (seconds) per process per process

"Schemaless" is the most damaging word in NoSQL

The schema does not disappear. It moves from the database into your application code, your analysts' queries, and your dashboards.

$jsonSchema — strictness you opt into

db.createCollection("rides", {
  validator: { $jsonSchema: {
    bsonType: "object",
    required: ["booking_id", "booked_at", "status", "route"],
    properties: {
      booking_id: { bsonType: "string", pattern: "^CNR[0-9]{7}$" },
      status: { enum: ["Completed", "Cancelled by Driver",
                       "Cancelled by Customer", "No Driver Found",
                       "Incomplete"] },
      booking_value: { bsonType: ["double","int"], minimum: 0 }
    } } },
  validationLevel: "moderate",
  validationAction: "error"
})

Embed or reference?

{ booking_id: "CNR3000142",
  route: { pickup: "CP",
           drop: "Aerocity" },
  ratings: { driver: 4.6,
             customer: 4.8 } }

// rides
{ booking_id: "CNR3000142",
  customer_id: "CID482910" }

// customers
{ _id: "CID482910",
  name: "Priya Sharma" }

Five tests, one decision

Our dataset, decided

16 MB per document — and the trap it catches

// ANTI-PATTERN
{ _id: "CID482910",
  name: "Priya Sharma",
  bookings: [
    { booking_id: "CNR3000142", value: 412.50 },
    { booking_id: "CNR3000288", value: 180.00 },
    // ...one more every day, forever
  ] }

Three doors to the same cluster

mongosh "mongodb+srv://bdma_student:<password>@cluster0.xxxxx.mongodb.net/"

# safer — prompt for the password instead of typing it
mongosh "mongodb+srv://cluster0.xxxxx.mongodb.net/" --username bdma_student

First document, by hand

use bdma
db                                // -> bdma
show collections                  // -> (empty)

db.rides.insertOne({
  booking_id: "CNR9999001",
  booked_at: new Date("2024-03-14T18:22:07Z"),
  status: "Completed",
  customer_id: "CID482910",
  vehicle_type: "Go Sedan",
  route: { pickup: "Connaught Place", drop: "Aerocity" },
  booking_value: 412.50,
  ride_distance: 18.4,
  ratings: { driver: 4.6, customer: 4.8 },
  payment_method: "UPI"
})

db.rides.find()
show collections                  // -> rides

Import 15,000 real bookings

# in mongosh — clear your test docs first
db.rides.deleteMany({})

# in your terminal, from the repo root
mongoimport --uri "mongodb+srv://bdma_student:<password>@cluster0.xxxxx.mongodb.net/bdma" \
  --collection rides --file data/uber_bookings.json --jsonArray

db.rides.countDocuments()                          // 15000
db.rides.countDocuments({ status: "Completed" })   // 9343

// turn booked_at from string into a real BSON Date
db.rides.updateMany(
  { booked_at: { $type: "string" } },
  [ { $set: { booked_at: { $toDate: "$booked_at" } } } ]
)

Six things to carry forward

1. A document is the unit of storage, and it nests. Collections have no fixed columns; fields can hold whole structures.
2. You write JSON, Mongo stores BSON. Real types, preserved order, fast traversal. Money gets Decimal128.
3. _id is mandatory; ObjectId is 12 bytes — timestamp + random + counter, so it is time-sortable and needs no coordination.
4. Flexible schema defers the strictness decision — it does not delete it. $jsonSchema is how you take it back.
5. Embed what is read together, bounded, and changes together. Reference what is large, unbounded, shared, or independent.
6. 16 MB is a smoke alarm. The unbounded array is the fire it is listening for.