Querying Data with MongoDB

Everyone run this now

use bdma
db.rides.countDocuments()                          // must say 15000
db.rides.countDocuments({ status: "Completed" })   // must say 9343

If either number is wrong, re-run the mongoimport from Lecture 12 before we go any further. Every query today assumes these 15,000 Delhi NCR bookings.

CRUD comes in pairs — and that is a safety feature

Two distinctions that cost data

db.rides.updateOne(
  { booking_id: "CNR3000142" },
  { $set: { "ratings.customer": 5.0 } }      // surgical
)

db.rides.insertMany([ /* ... */ ], { ordered: false })

Comparison

// A fare band — both bounds in one operator document
db.rides.find({ booking_value: { $gte: 200, $lte: 400 } })

// Comma-separated conditions are an implicit AND
db.rides.find({ vehicle_type: "Auto", payment_method: "Cash" })

$ne matches documents that lack the field

db.rides.find({ payment_method: { $ne: "Cash" } })

This returns every non-cash payment plus all 4,756 bookings that never completed — they have no payment_method at all, and a missing field is not equal to anything, which makes it "not equal" to everything.

{ status: "Completed",
  payment_method:
    { $ne: "Cash" } }

Logical — and when you actually need them

// Any failed booking
db.rides.find({ $or: [ { status: "Cancelled by Driver" },
                       { status: "Cancelled by Customer" },
                       { status: "No Driver Found" } ] })

// Cleaner, and it uses an index better
db.rides.find({ status: { $in: ["Cancelled by Driver",
                                "Cancelled by Customer",
                                "No Driver Found"] } })

// $nor — neither cancelled nor incomplete
db.rides.find({ $nor: [ { status: "Cancelled by Driver" },
                        { status: "Cancelled by Customer" },
                        { status: "Incomplete" } ] })

$exists — because absence is data

db.rides.countDocuments({ booking_value: { $exists: false } })  // 4756
db.rides.countDocuments({ ratings:       { $exists: true  } })  // 9343
db.rides.countDocuments({ avg_vtat:      { $exists: false } })  // 1036
db.rides.countDocuments({ booking_value: { $type: "string" } }) //    0

Evaluation and array

// $regex — anchored can use an index, unanchored cannot
db.rides.find({ "route.drop": { $regex: "^Gurgaon" } })   // indexable
db.rides.find({ "route.pickup": /Noida/i })               // full scan

// $all / $size / $elemMatch
db.rides.find({ tags: { $all: ["airport", "premium"] } })
db.rides.find({ tags: { $size: 2 } })
db.rides.find({ fare_breakdown:
  { $elemMatch: { component: "surge", amount: { $gt: 50 } } } })

Dot notation — and why the quotes matter

db.rides.find({ "route.pickup": "Indira Gandhi International Airport" })
db.rides.find({ "ratings.driver": { $lt: 3 } })
db.rides.find({ "cancellation.by": "driver" })
db.rides.find({ "incomplete.reason": "Vehicle Breakdown" })

{ "route.pickup":
  "Indira Gandhi
   International Airport" }

{ route: { pickup:
  "Indira Gandhi
   International Airport" } }

Projection is cost control

// 1 = include, 0 = exclude. Never mix — except _id, always suppressible.
db.rides.find(
  { status: "Completed" },
  { _id: 0, booking_id: 1, booking_value: 1, "route.pickup": 1 }
)

// INVALID
// db.rides.find({}, { booking_id: 1, ratings: 0 })

Every field returned is read from disk, serialised, sent across the network, and parsed by the client. Returning 14 fields to a dashboard that renders 3 wastes four-fifths of that work on every single request.

sort runs first. skip does not jump.

// The ten most expensive completed rides. 1 = asc, -1 = desc.
db.rides.find({ status: "Completed" },
              { _id: 0, booking_id: 1, booking_value: 1 })
  .sort({ booking_value: -1 }).limit(10)

// Range pagination — constant work at any depth
db.rides.find({ status: "Completed",
                booked_at: { $lt: ISODate("2024-11-18T09:14:00Z") } })
  .sort({ booked_at: -1 }).limit(20)

Update operators — change it on the server

db.rides.updateOne({ booking_id: "CNR3000142" },
  { $inc: { booking_value: -25 } })

db.rides.updateOne({ booking_id: "CNR3000142" },
  { $addToSet: { tags: "airport" } })      // no-op if already there

upsert — update if present, insert if not

db.daily_summary.updateOne(
  { date: "2024-03-14", vehicle_type: "Go Sedan" },  // identity
  { $inc: { bookings: 1, revenue: 412.50 } },         // the change
  { upsert: true }                                    // create if absent
)
// First call  -> inserts the document
// Every later -> increments it
// upsertedId is set when it inserted, null when it updated

Exact or instant — pick one

db.rides.countDocuments()                                      // 15000
db.rides.countDocuments({ payment_method: "UPI" })             //  4613
db.rides.countDocuments({ "route.pickup": "Noida Sector 62" }) //  1209

An empty filter is a valid filter

db.rides.deleteMany({})
// { acknowledged: true, deletedCount: 15000 }

db.rides.updateMany({}, { $set: { status: "Completed" } })
// every booking in the collection, rewritten

No confirmation prompt. No ROLLBACK. No undo. MongoDB has transactions — an autocommitted updateMany is not inside one.

{ acknowledged: true,
  matchedCount: 1183,
  modifiedCount: 1183,
  upsertedId: null }

Eight business questions

Six things to carry forward

1. CRUD comes in singular/plural pairs, and find() hands back a lazy cursor, not a list.
2. Five operator families — comparison, logical, element, evaluation, array. The business question tells you which.
3. A missing field is "not equal" to everything. $ne sweeps in 4,756 phantom bookings; $exists asks what you meant.
4. Dot notation reaches in; whole-object matching does not — and fails silently with zero results.
5. Projection is cost control; deep skip is a trap. Page with a range filter on the sort key.
6. An empty filter is a valid filter. Prove it with find first; read matchedCount after.