MongoDB Cheat Sheet 2025

MongoDB is a NoSQL document database that stores data in JSON-like documents with flexible schemas. It's designed for scalability, performance, and developer productivity.

Key Features:

• Document-Oriented: Data stored as BSON (Binary JSON) documents
• Schema-Less: Flexible schema allows evolving data structures
• Distributed: Built-in sharding and replication
• Aggregation Pipeline: Powerful data processing framework
• ACID Transactions: Multi-document ACID transactions (v4.0+)
• Full-Text Search: Native text search capabilities

Essential commands to get started with MongoDB shell:

// Start MongoDB Shell mongosh // Check current database db // List all databases show dbs // Show current user db.getUser()

MongoSh:

// Connect to local MongoDB mongosh // Connect to remote server mongosh "mongodb://username:password@host:port/database" // Connect to MongoDB Atlas mongosh "mongodb+srv://username:password@cluster.mongodb.net/database"

Compass:

// MongoDB Compass Connection String mongodb://localhost:27017 // Connection with Authentication mongodb://username:password@localhost:27017/database // Atlas Connection mongodb+srv://username:password@cluster.mongodb.net/database

Node.js

// Using MongoDB Native Driver const { MongoClient } = require('mongodb'); const client = new MongoClient('mongodb://localhost:27017'); await client.connect(); const db = client.db('myapp'); const collection = db.collection('users');

// Use or create a database use myapp // Get current database db // Drop database db.dropDatabase() // Get database statistics db.stats() // List collections show collections // Get collection statistics db.collection_name.stats()

 Tip: Databases are created automatically when you first write data to them. Use use database_name to switch or create a database.

// Create collection db.createCollection('users') // Create collection with validation db.createCollection('users', { validator: { $jsonSchema: { bsonType: 'object', required: ['name', 'email'], properties: { name: { bsonType: 'string' }, email: { bsonType: 'string' } } } } }) // Drop collection db.users.drop() // Rename collection db.users.renameCollection('customers') // Check if collection exists db.getCollectionNames().includes('users')

insertOne() - Insert Single Document

db.users.insertOne({ _id: ObjectId(), name: "John Doe", email: "john@example.com", age: 30, active: true }) 
// Returns: { acknowledged: true, insertedId: ObjectId(...) }

insertMany() - Insert Multiple Documents

db.users.insertMany([ { name: "Alice", email: "alice@example.com" }, { name: "Bob", email: "bob@example.com" }, { name: "Charlie", email: "charlie@example.com" } ], { ordered: false }) // ordered: true (default) - stop on error // ordered: false - continue on error

find() - Find Multiple Documents

// Find all documents db.users.find() // Find with filter db.users.find({ age: { $gt: 25 } }) // Convert to array db.users.find({ active: true }).toArray() // Count matches db.users.countDocuments({ age: { $gt: 25 } })

findOne() - Find Single Document

// Find first match db.users.findOne({ email: "john@example.com" }) // Returns: { _id: ObjectId(...), name: "John", email: "..." } // Returns null if not found db.users.findOne({ email: "nonexistent@example.com" })

updateOne() - Update Single Document

db.users.updateOne( { _id: ObjectId("...") }, { $set: { name: "John Smith", updatedAt: new Date() } } ) // Returns: { matched: 1, modified: 1 }

updateMany() - Update Multiple Documents

// Update all inactive users db.users.updateMany( { active: false }, { $set: { status: "inactive" }, $inc: { inactiveCount: 1 } } ) // Returns: { matched: n, modified: n }

Update Operators

// $set - Set field value { $set: { status: "active" } } // $unset - Remove field { $unset: { tempField: "" } } // $inc - Increment numeric field { $inc: { age: 1, score: 10 } } // $push - Add to array { $push: { tags: "new-tag" } } // $addToSet - Add to array (no duplicates) { $addToSet: { hobbies: "reading" } } // $pull - Remove from array { $pull: { tags: "old-tag" } } // $pop - Remove first/last from array { $pop: { items: 1 } } // Remove last { $pop: { items: -1 } } // Remove first // $rename - Rename field { $rename: { oldName: "newName" } }

deleteOne() - Delete Single Document

db.users.deleteOne({ _id: ObjectId("...") }) // Returns: { deletedCount: 1 }

deleteMany() - Delete Multiple Documents

// Delete all inactive users db.users.deleteMany({ active: false }) // Delete all documents db.users.deleteMany({}) // Returns: { deletedCount: n }

// $eq - Equal db.users.find({ age: { $eq: 25 } }) // $ne - Not equal db.users.find({ status: { $ne: "inactive" } }) // $gt - Greater than db.users.find({ age: { $gt: 18 } }) // $gte - Greater than or equal db.users.find({ score: { $gte: 80 } }) // $lt - Less than db.users.find({ age: { $lt: 65 } }) // $lte - Less than or equal db.users.find({ price: { $lte: 100 } }) // $in - Match any value in array db.users.find({ status: { $in: ["active", "pending"] } }) // $nin - Not in array db.users.find({ country: { $nin: ["US", "CA"] } })

// $and - All conditions must match (implicit by default) db.users.find({ age: { $gt: 18 }, status: "active" }) // OR explicitly: db.users.find({ $and: [ { age: { $gt: 18 } }, { status: "active" } ] }) // $or - At least one condition matches db.users.find({ $or: [ { age: { $lt: 18 } }, { age: { $gt: 65 } } ] }) // $not - Negate condition db.users.find({ age: { $not: { $lt: 18 } } }) // $nor - None of conditions match db.users.find({ $nor: [ { status: "deleted" }, { banned: true } ] })

// $exists - Field exists or not db.users.find({ phone: { $exists: true } }) db.users.find({ nickname: { $exists: false } }) // $type - Match by data type db.users.find({ age: { $type: "int" } }) db.users.find({ createdAt: { $type: "date" } }) // Type codes: "double", "string", "object", "array", "binData", // "objectId", "bool", "date", "null", "int", "long", "decimal"

// $regex - Regular expression matching db.users.find({ email: { $regex: "@example\\.com$" } }) // Case insensitive db.users.find({ email: { $regex: "^john", $options: "i" } }) // $text - Text search db.articles.find({ $text: { $search: "mongodb tutorial" } }) // $where - JavaScript expression (slower, avoid in production) db.users.find({ $where: "this.age > 25" })

// $all - Array contains all elements db.posts.find({ tags: { $all: ["mongodb", "database"] } }) // $elemMatch - Array element matches condition db.users.find({ scores: { $elemMatch: { $gte: 80, $lt: 90 } } }) // $size - Array has specific length db.posts.find({ tags: { $size: 5 } }) // Direct array match db.users.find({ hobbies: "reading" }) // Check if value is in any array element db.users.find({ tags: { $in: ["important", "urgent"] } })

Include Specific Fields

// Include fields (1 = include, 0 = exclude) db.users.find( { age: { $gt: 25 } }, { name: 1, email: 1, _id: 0 } ) // Always includes _id unless explicitly excluded // Result: { name: "John", email: "john@example.com" }

Exclude Fields

// Exclude sensitive fields db.users.find( { active: true }, { password: 0, ssn: 0, apiKey: 0 } ) // Returns all fields except specified ones

Advanced Projections

// Array slicing - get first 5 items db.posts.find( {}, { comments: { $slice: 5 } } ) // Array slicing - skip first 10, get next 20 db.posts.find( {}, { comments: { $slice: [10, 20] } } ) // Computed field db.users.find( {}, { name: 1, fullName: { $concat: ["$firstName", " ", "$lastName"] } } )

sort() - Sort Results

// Sort ascending (1) db.users.find().sort({ name: 1 }) // Sort descending (-1) db.posts.find().sort({ createdAt: -1 }) // Multiple field sort db.users.find().sort({ country: 1, name: 1 }) // Case-insensitive sort db.users.find().collation({ locale: "en", strength: 2 }).sort({ name: 1 })

Pagination Pattern

const pageSize = 10; const pageNumber = 2; // Page 2 const results = db.users .find({ active: true }) .sort({ createdAt: -1 }) .skip((pageNumber - 1) * pageSize) .limit(pageSize) .toArray() // Get total count for pagination info const total = db.users.countDocuments({ active: true }) const totalPages = Math.ceil(total / pageSize)

limit() & skip()

// limit() - Get first 5 results db.users.find().limit(5) // skip() - Skip first 10, get next 5 db.users.find().skip(10).limit(5) // Always use skip().limit() for pagination, not offset() // Order matters: sort() -> skip() -> limit()

Indexes improve query performance by creating efficient data structures for lookups. Every collection has a default _id index.

Benefits of Indexes:

• Faster query execution
• Reduced CPU usage
• Efficient sorting
• Enable unique constraints
• Support TTL (Time-To-Live) features

Simple Index

// Create single field index db.users.createIndex({ email: 1 }) // Ascending (1) or Descending (-1) db.posts.createIndex({ createdAt: -1 }) // Unique index db.users.createIndex({ email: 1 }, { unique: true }) // Sparse index (ignore documents without field) db.users.createIndex({ phone: 1 }, { sparse: true })

Compound Index

// Multi-field index db.users.createIndex({ country: 1, city: 1, name: 1 }) // Indexes support queries like: // { country: "USA", city: "NY" } // { country: "USA" } // But NOT: { city: "NY" } alone (uses index prefix rule)

Special Index Types

// Text index (full-text search) db.articles.createIndex({ title: "text", content: "text" }) db.articles.find({ $text: { $search: "mongodb" } }) // Geospatial index (location-based queries) db.places.createIndex({ location: "2dsphere" }) db.places.find({ location: { $near: { type: "Point", coordinates: [-73.99, 40.71] } } }) // TTL index (auto-delete after expiration) db.sessions.createIndex( { createdAt: 1 }, { expireAfterSeconds: 3600 } )

// List all indexes db.users.getIndexes() // Get index info db.users.getIndexSpecs() // Drop specific index db.users.dropIndex('email_1') db.users.dropIndex({ email: 1 }) // Drop all indexes except _id db.users.dropIndexes() // Rename index db.users.dropIndex('old_name') db.users.createIndex({ field: 1 }, { name: 'new_name' })

Analyze Query Performance

// explain() with executionStats db.users.find({ email: "john@example.com" }).explain("executionStats") // Look for: // executionStages.stage: "COLLSCAN" (bad - full collection scan) // executionStages.stage: "IXSCAN" (good - index scan) // executionStats.executionStages.executionStages (nested plans)

The aggregation pipeline processes documents through stages, transforming and combining data. Think of it as a series of filters and transformations.

Basic Structure:

db.collection.aggregate([ { $stage1: { /* stage parameters */ } }, { $stage2: { /* stage parameters */ } }, { $stage3: { /* stage parameters */ } } ]) // Returns a cursor for iterating results // Results are returned as array of documents

$match - Filter documents (like find())

// Filter orders for 2024 db.orders.aggregate([ { $match: { year: 2024, status: "completed" } } ]) // $match should be early in pipeline for performance

$project - Select/transform fields

db.users.aggregate([ { $project: { _id: 0, name: 1, email: 1, displayName: { $concat: ["$firstName", " ", "$lastName"] }, ageGroup: { $cond: { if: { $gte: ["$age", 18] }, then: "Adult", else: "Minor" } } } } ])

$group - Group and aggregate

// Group by category and calculate totals db.sales.aggregate([ { $group: { _id: "$category", totalSales: { $sum: "$amount" }, avgPrice: { $avg: "$price" }, count: { $sum: 1 }, maxPrice: { $max: "$price" }, minPrice: { $min: "$price" } } } ]) // $group operators: $sum, $avg, $min, $max, $first, $last, // $push, $addToSet, $count

$sort - Sort results

db.products.aggregate([ { $match: { active: true } }, { $sort: { price: -1 } }, // Descending price { $limit: 10 } ])

$limit & $skip - Pagination

db.users.aggregate([ { $match: { status: "active" } }, { $sort: { createdAt: -1 } }, { $skip: 20 }, // Skip first 20 { $limit: 10 } // Get next 10 (page 3) ])

$lookup - JOIN collections (LEFT OUTER JOIN)

db.orders.aggregate([ { $lookup: { from: "users", // Join with users collection localField: "userId", // Field in orders foreignField: "_id", // Field in users as: "user" // Result array name } }, { $unwind: "$user" }, // Convert array to object { $project: { orderId: 1, amount: 1, "user.name": 1, "user.email": 1 } } ])

$unwind - Flatten arrays

Copy // Input: { _id: 1, tags: ["a", "b", "c"] } db.posts.aggregate([ { $unwind: "$tags" } ]) // Output: // { _id: 1, tags: "a" } // { _id: 1, tags: "b" } // { _id: 1, tags: "c" } // Unwind with empty handling db.posts.aggregate([ { $unwind: { path: "$tags", preserveNullAndEmptyArrays: true } } ])

Real-world: Sales Report by Month

Copy db.sales.aggregate([ { $match: { year: 2024 } }, { $group: { _id: { $dateToString: { format: "%Y-%m", date: "$date" } }, totalSales: { $sum: "$amount" }, totalOrders: { $sum: 1 }, avgOrderValue: { $avg: "$amount" } } }, { $sort: { _id: 1 } }, { $project: { _id: 0, month: "$_id", totalSales: 1, totalOrders: 1, avgOrderValue: { $round: ["$avgOrderValue", 2] } } } ])

Embedding - Denormalization (Nested Data)

Referencing - Normalization (Using IDs)

One-to-One Relationship

One-to-Many Relationship

Many-to-Many Relationship

MongoDB 4.0+ supports multi-document ACID transactions. Transactions ensure atomicity (all-or-nothing) across multiple documents.

Optimization Tips:

• Create indexes on frequently queried fields - Dramatically improves performance
• Use compound indexes wisely - Order matters (ESR: Equality, Sort, Range)
• Filter early in aggregation pipelines - Use $match early to reduce documents
• Avoid regex patterns that don't start with ^ - Cannot use index efficiently
• Use projection to limit fields - Reduces network transfer
• Batch large operations - Use insertMany, updateMany for bulk ops
• Use appropriate data types - Improves storage and query performance

ESR Rule - Index Design Pattern

Avoid Index Bloat

Create Users

Role-Based Access Control (RBAC)

• Enable Authentication: Always require login credentials
• Use Strong Passwords: Enforce complexity requirements
• Enable Encryption: Use TLS/SSL for connections, encryption at rest
• Limit Network Access: Use IP whitelisting, VPC restrictions
• Audit Logging: Enable audit logs for compliance
• Regular Backups: Implement backup and restore procedures
• Updates: Keep MongoDB updated with security patches
• Data Validation: Validate all inputs to prevent injection attacks
• Principle of Least Privilege: Grant minimum necessary permissions

Full Database Backup

Restore Backup

MongoDB Atlas provides automated backups and point-in-time recovery.

• Continuous Backup: Automatic hourly snapshots
• Point-in-Time Recovery: Restore to any moment within retention window
• Snapshot Export: Export to S3, export to new Atlas cluster
• Retention Policies: Configurable retention windows

Connection & Setup

CRUD with Native Driver

Setup & Schema

Mongoose CRUD Operations

Mongoose Validation & Middleware

Change streams allow you to monitor real-time changes to MongoDB data.

Sharding distributes data across multiple MongoDB instances for horizontal scalability.

• Multi-Cloud Deployment: Deploy on AWS, GCP, or Azure
• Automated Backups: Continuous backups with point-in-time recovery
• Live Replication: Data mirroring across multiple regions
• Charts & Dashboards: Visual data analytics
• Realm: Backend-as-a-Service with MongoDB
• Search: Full-text search capabilities
• Mobile SDKs: Sync data to mobile apps

Optimized for storing time-stamped data like metrics and analytics.

1. What is MongoDB and how is it different from SQL databases?

Answer: MongoDB is a NoSQL document database that stores data as JSON-like BSON documents with flexible schemas, unlike SQL databases with fixed table structures.