MongoDB Cheatsheet

1. When to Use $fieldName

The short rule is: use $fieldName when you mean “the value from this field” inside an expression. Do not use $ when you are simply naming a field in a normal document shape or filter key.

Examples

// Filter key: no $ on field name
{ city: "Mumbai" }

// Operator: $ on the operator name
{ amount: { $gte: 500 } }

// Aggregation expression: $ means 'read from this field'
{ $project: { revenueWithTax: { $multiply: ["$revenue", 1.18] } } }

2. JSON vs BSON

You usually write JSON-like documents in mongosh or application code. MongoDB converts them to BSON internally.

3. Numeric Types

4. Transactions

• Single-document writes are already atomic.
• Use transactions when one business action spans multiple documents or collections.
• Keep them short.
• Pass the same session to every operation inside the transaction.

const session = client.startSession();

await session.withTransaction(async () => {
  await orders.insertOne({ orderId: 1, customerId: 101 }, { session });
  await inventory.updateOne(
    { productId: 22, available: { $gte: 1 } },
    { $inc: { available: -1 } },
    { session }
  );
});

5. Backup and Restore

Backups are only trustworthy if you have tested restore.

// Logical backup
mongodump --uri "mongodb://user:pass@host:27017/appdb" --out ./backup

// Restore full dump
mongorestore --uri "mongodb://user:pass@host:27017/appdb_restore" ./backup

// Restore a specific namespace
mongorestore --uri "mongodb://user:pass@host:27017/appdb_restore" --nsInclude="appdb.orders" ./backup

• RPO: how much data loss is acceptable
• RTO: how quickly you must recover

6. Users, Roles, and Least Privilege

Create separate users for app access, backup, and admin work. Do not give applications admin roles unless there is a very specific reason.

// App user
use appdb
db.createUser({
  user: "appUser",
  pwd: passwordPrompt(),
  roles: [{ role: "readWrite", db: "appdb" }]
})

// Backup operator
use admin
db.createUser({
  user: "backupOperator",
  pwd: passwordPrompt(),
  roles: [
    { role: "backup", db: "admin" },
    { role: "restore", db: "admin" }
  ]
})

// Custom least-privilege role
use appdb
db.createRole({
  role: "orderStatusEditor",
  privileges: [
    {
      resource: { db: "appdb", collection: "orders" },
      actions: ["find", "update"]
    }
  ],
  roles: []
})

7. Aggregation Default Order

• $match early when the filter uses base collection fields
• $unwind only when you need array element-level work
• $lookup after reduction when possible
• $group after the stream has the correct grain
• $sort, $limit, and final $project near the end

db.orders.aggregate([
  { $match: { status: "paid" } },
  { $unwind: "$items" },
  {
    $lookup: {
      from: "products",
      localField: "items.productId",
      foreignField: "_id",
      as: "product"
    }
  },
  { $unwind: "$product" },
  {
    $group: {
      _id: "$product.category",
      revenue: { $sum: { $multiply: ["$items.qty", "$items.unitPrice"] } }
    }
  },
  { $sort: { revenue: -1 } },
  { $project: { _id: 0, category: "$_id", revenue: 1 } }
])

8. Complex Pipeline Patterns

• Start from the output contract: what should one output row represent?
• Track grain changes: order level, item level, grouped summary level
• Use $facet when several summaries share the same prepared input

db.orders.aggregate([
  { $match: { status: "paid" } },
  {
    $facet: {
      byCity: [
        { $group: { _id: "$city", revenue: { $sum: "$totalAmount" } } }
      ],
      byCategory: [
        { $unwind: "$items" },
        { $group: { _id: "$items.category", qty: { $sum: "$items.qty" } } }
      ]
    }
  }
])

9. Geospatial Basics

Use GeoJSON and a 2dsphere index.

{
  name: "Cafe A",
  location: {
    type: "Point",
    coordinates: [77.5946, 12.9716] // longitude, latitude
  }
}

db.places.createIndex({ location: "2dsphere" })

db.places.find({
  location: {
    $near: {
      $geometry: { type: "Point", coordinates: [77.5946, 12.9716] },
      $maxDistance: 2000
    }
  }
})

10. Quick Integrity Rules

• Use $jsonSchema for shape and type validation
• Use unique indexes for uniqueness
• Use application logic for cross-document business rules

// Validation
db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["email", "name"],
      properties: {
        email: { bsonType: "string" },
        name: { bsonType: "string" }
      }
    }
  }
})

// Uniqueness
db.users.createIndex({ email: 1 }, { unique: true })