MongoDB: CRUD, Aggregation and Indexes Reference Guide

# macOS — Homebrew tap
brew tap mongodb/brew
brew install mongodb-community@7.0
brew services start mongodb/brew/mongodb-community

# Linux — official repo (Debian/Ubuntu)
# See https://www.mongodb.com/docs/manual/installation/ for the apt key block
sudo systemctl enable --now mongod

# Docker — disposable dev instance
docker run --name mongo -p 27017:27017 -d mongo:7

# Modern shell — mongosh (the legacy "mongo" binary is gone in 6+)
mongosh                                              # default localhost
mongosh "mongodb://user:pw@host:27017/shop"
mongosh "mongodb+srv://cluster.example/shop?retryWrites=true&w=majority"

# Python driver
pip install "pymongo>=4" "motor>=3"   # sync + async

# Ping
mongosh --eval 'db.runCommand({ ping: 1 })'

// Top 5 customers by spend in the last 30 days
db.orders.aggregate([
  { $match: {                                   // narrow early — uses indexes
      placedAt: { $gte: new Date(Date.now() - 30*24*3600*1000) },
      status:   "paid"
  }},
  { $group: {
      _id:   "$customerId",
      spend: { $sum: "$total" },
      n:     { $sum: 1 }
  }},
  { $sort:  { spend: -1 } },
  { $limit: 5 },
  { $lookup: {                                  // join-ish
      from: "customers",
      localField:   "_id",
      foreignField: "_id",
      as: "customer"
  }},
  { $project: {
      _id: 0,
      customerId: "$_id",
      email: { $arrayElemAt: ["$customer.email", 0] },
      spend: 1,
      n: 1
  }}
]);

// Bucketize order sizes
db.orders.aggregate([
  { $bucket: {
      groupBy: "$total",
      boundaries: [0, 50, 200, 1000, 10000],
      default: "10k+",
      output: { count: { $sum: 1 } }
  }}
]);

// Single field, ascending
db.users.createIndex({ email: 1 }, { unique: true });

// Compound — leftmost-prefix rule. Order matters:
// can serve queries on {customerId}, {customerId, placedAt}, but not {placedAt} alone.
db.orders.createIndex({ customerId: 1, placedAt: -1 });

// Partial — index only the rows that match the filter
db.users.createIndex(
  { lastLoginAt: -1 },
  { partialFilterExpression: { active: true } }
);

// TTL — expire docs N seconds after the field
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 });

// Wildcard — index every field under a path
db.events.createIndex({ "metadata.$**": 1 });

// Text — full-text search
db.posts.createIndex({ title: "text", body: "text" });
db.posts.find({ $text: { $search: "redis cache" } });

// 2dsphere — geo
db.places.createIndex({ location: "2dsphere" });

// Find queries that aren't using an index
db.orders.find({ customerId: 7 }).explain("executionStats");

// Hide an index without dropping (test impact)
db.orders.hideIndex("customerId_1_placedAt_-1");

from pymongo import MongoClient, ASCENDING, ReturnDocument
from pymongo.errors import DuplicateKeyError

client = MongoClient("mongodb://localhost:27017", uuidRepresentation="standard")
db = client.shop

# Insert with retry on duplicate-key (e.g. unique email)
try:
    db.users.insert_one({"email": "a@x.com", "name": "Ana"})
except DuplicateKeyError:
    pass

# Upsert + return the new value in one round-trip
doc = db.users.find_one_and_update(
    {"email": "a@x.com"},
    {"$inc": {"loginCount": 1},
     "$setOnInsert": {"createdAt": datetime.utcnow()}},
    upsert=True,
    return_document=ReturnDocument.AFTER,
)

# Bulk write — mix of operations, one network call
from pymongo import InsertOne, UpdateOne
res = db.events.bulk_write([
    InsertOne({"type": "login", "user": 42}),
    UpdateOne({"user": 42}, {"$inc": {"hits": 1}}, upsert=True),
], ordered=False)

# Transactions — require a replica set / sharded cluster
with client.start_session() as session:
    with session.start_transaction():
        db.accounts.update_one({"_id": "A"}, {"$inc": {"bal": -50}}, session=session)
        db.accounts.update_one({"_id": "B"}, {"$inc": {"bal":  50}}, session=session)

# Async with motor
# from motor.motor_asyncio import AsyncIOMotorClient
# m = AsyncIOMotorClient(...); await m.shop.users.find_one(...)

// One-pass: validate a shop collection, add an index, run analytics.

// 1. Schema validation — reject malformed inserts
db.runCommand({
  collMod: "orders",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["customerId", "total", "placedAt"],
      properties: {
        customerId: { bsonType: "objectId" },
        total:      { bsonType: "decimal", minimum: 0 },
        placedAt:   { bsonType: "date" },
        status:     { enum: ["pending", "paid", "refunded"] }
      }
    }
  },
  validationLevel:  "strict",
  validationAction: "error"
});

// 2. Composite index for the hot read path
db.orders.createIndex({ customerId: 1, placedAt: -1 });

// 3. Insert sample data
db.orders.insertMany([
  { customerId: ObjectId(), total: NumberDecimal("99.50"),
    placedAt: new Date(), status: "paid" },
  { customerId: ObjectId(), total: NumberDecimal("12.00"),
    placedAt: new Date(), status: "paid" }
]);

// 4. Daily revenue for the last 7 days
db.orders.aggregate([
  { $match: { placedAt: { $gte: new Date(Date.now() - 7*24*3600*1000) },
              status:   "paid" } },
  { $group: {
      _id:     { $dateTrunc: { date: "$placedAt", unit: "day" } },
      revenue: { $sum: "$total" }
  }},
  { $sort: { _id: 1 } }
]);