MongoDB Cheat Sheet: 100+ Commands with Real Examples

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Show all databases (only shows databases with data)
show dbs

// Switch to a database (creates it on first write if it does not exist)
use mydb

// Show current database
db

// Drop the current database (careful, this is permanent)
db.dropDatabase()

// Get database stats
db.stats()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Show all collections in current database
show collections

// Create a collection explicitly
db.createCollection("users")

// Create a collection with options
db.createCollection("logs", {
  capped: true,
  size: 104857600,  // 100 MB max size
  max: 100000       // 100k documents max
})

// Get collection stats
db.users.stats()

// Rename a collection
db.users.renameCollection("customers")

// Drop a collection
db.users.drop()

// List collections with details
db.getCollectionInfos()

1
2
3
4
5
6
7
8
9
10
11
// Insert a single document
db.users.insertOne({
  name: "Ajit Singh",
  email: "ajit@example.com",
  age: 30,
  role: "developer",
  createdAt: new Date()
})

// The response includes the generated _id
// { acknowledged: true, insertedId: ObjectId("...") }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Insert multiple documents at once
db.users.insertMany([
  { name: "Alice", email: "alice@example.com", age: 28, role: "designer" },
  { name: "Bob", email: "bob@example.com", age: 35, role: "developer" },
  { name: "Charlie", email: "charlie@example.com", age: 42, role: "manager" }
])

// With ordered: false, MongoDB continues inserting even if one fails
db.users.insertMany(
  [
    { _id: 1, name: "Alice" },
    { _id: 1, name: "Duplicate" },  // This will fail
    { _id: 2, name: "Bob" }          // This still gets inserted
  ],
  { ordered: false }
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Find all documents
db.users.find()

// Find with a condition (WHERE equivalent)
db.users.find({ role: "developer" })

// Find one document
db.users.findOne({ email: "ajit@example.com" })

// Find by _id
db.users.findOne({ _id: ObjectId("507f1f77bcf86cd799439011") })

// Count documents
db.users.countDocuments({ role: "developer" })

// Count all documents (faster, uses metadata)
db.users.estimatedDocumentCount()

// Check if any document matches
db.users.findOne({ email: "ajit@example.com" }) !== null

// Get distinct values
db.users.distinct("role")
// Returns: ["developer", "designer", "manager"]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Format output for readability
db.users.find().pretty()

// Limit output
db.users.find().limit(5)

// Skip documents (pagination)
db.users.find().skip(10).limit(5)

// Sort results (1 = ascending, -1 = descending)
db.users.find().sort({ createdAt: -1 })

// Chain them together for pagination
db.users.find({ role: "developer" })
  .sort({ name: 1 })
  .skip(20)
  .limit(10)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Greater than
db.users.find({ age: { $gt: 30 } })

// Greater than or equal
db.users.find({ age: { $gte: 30 } })

// Less than
db.users.find({ age: { $lt: 30 } })

// Less than or equal
db.users.find({ age: { $lte: 30 } })

// Not equal
db.users.find({ role: { $ne: "admin" } })

// In a set of values
db.users.find({ role: { $in: ["developer", "designer"] } })

// Not in a set
db.users.find({ role: { $nin: ["admin", "banned"] } })

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// AND (implicit, just add fields)
db.users.find({ role: "developer", age: { $gt: 25 } })

// AND (explicit)
db.users.find({
  $and: [
    { role: "developer" },
    { age: { $gt: 25 } }
  ]
})

// OR
db.users.find({
  $or: [
    { role: "admin" },
    { role: "moderator" }
  ]
})

// NOT
db.users.find({ age: { $not: { $gt: 30 } } })

// NOR (none of the conditions match)
db.users.find({
  $nor: [
    { role: "banned" },
    { age: { $lt: 18 } }
  ]
})

1
2
3
4
5
6
7
8
// Field exists
db.users.find({ phone: { $exists: true } })

// Field does not exist
db.users.find({ phone: { $exists: false } })

// Field is a specific BSON type
db.users.find({ age: { $type: "int" } })

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Regex match
db.users.find({ email: { $regex: /@gmail\.com$/ } })

// Case-insensitive regex
db.users.find({ name: { $regex: /^ajit/i } })

// Text search (requires text index)
db.articles.find({ $text: { $search: "mongodb tutorial" } })

// Text search with score
db.articles.find(
  { $text: { $search: "mongodb aggregation" } },
  { score: { $meta: "textScore" } }
).sort({ score: { $meta: "textScore" } })

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Return only name and email (1 = include)
db.users.find({}, { name: 1, email: 1 })

// Exclude specific fields (0 = exclude)
db.users.find({}, { password: 0, internalNotes: 0 })

// You cannot mix include and exclude (except for _id)
// This is valid: include fields but exclude _id
db.users.find({}, { name: 1, email: 1, _id: 0 })

// Sort ascending by name
db.users.find().sort({ name: 1 })

// Sort descending by creation date
db.users.find().sort({ createdAt: -1 })

// Multi-field sort
db.users.find().sort({ role: 1, name: 1 })

// Combine projection, sort, skip, limit
db.users.find(
  { role: "developer" },
  { name: 1, email: 1, _id: 0 }
).sort({ name: 1 }).skip(0).limit(10)

1
2
3
4
5
// Instead of skip-based pagination
db.users.find().sort({ _id: 1 }).skip(100000).limit(10)  // Slow

// Use cursor-based pagination
db.users.find({ _id: { $gt: lastSeenId } }).sort({ _id: 1 }).limit(10)  // Fast

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// Update a single field
db.users.updateOne(
  { email: "ajit@example.com" },
  { $set: { role: "admin" } }
)

// Update multiple fields
db.users.updateOne(
  { email: "ajit@example.com" },
  { $set: { role: "admin", updatedAt: new Date() } }
)

// Update all matching documents
db.users.updateMany(
  { role: "intern" },
  { $set: { role: "junior_developer" } }
)

// Increment a numeric field
db.products.updateOne(
  { _id: productId },
  { $inc: { views: 1 } }
)

// Multiply a field
db.products.updateOne(
  { _id: productId },
  { $mul: { price: 1.10 } }  // 10% price increase
)

// Set field only if the new value is less than current (useful for tracking minimums)
db.scores.updateOne(
  { playerId: 1 },
  { $min: { bestTime: 45.2 } }
)

// Set field only if the new value is greater (useful for tracking maximums)
db.scores.updateOne(
  { playerId: 1 },
  { $max: { highScore: 9500 } }
)

// Remove a field
db.users.updateOne(
  { email: "ajit@example.com" },
  { $unset: { temporaryField: "" } }
)

// Rename a field
db.users.updateMany(
  {},
  { $rename: { "name": "fullName" } }
)

1
2
3
4
5
6
7
8
9
// Upsert: update if exists, insert if not
db.users.updateOne(
  { email: "newuser@example.com" },
  {
    $set: { name: "New User", role: "developer" },
    $setOnInsert: { createdAt: new Date() }
  },
  { upsert: true }
)

1
2
3
4
5
6
7
8
9
10
// Replace entire document (except _id)
db.users.replaceOne(
  { email: "ajit@example.com" },
  {
    name: "Ajit Singh",
    email: "ajit@example.com",
    role: "admin",
    updatedAt: new Date()
  }
)

1
2
3
4
5
6
// Update and return the modified document in one operation
db.users.findOneAndUpdate(
  { email: "ajit@example.com" },
  { $set: { lastLogin: new Date() } },
  { returnDocument: "after" }  // Returns the document AFTER the update
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Delete one document
db.users.deleteOne({ email: "old@example.com" })

// Delete all matching documents
db.users.deleteMany({ role: "banned" })

// Delete all documents in a collection (keeps the collection and indexes)
db.users.deleteMany({})

// Drop the entire collection (faster than deleteMany for clearing everything)
db.users.drop()

// Find and delete in one atomic operation
db.queue.findOneAndDelete(
  { status: "pending" },
  { sort: { createdAt: 1 } }  // Delete the oldest pending item
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Match if array contains a value
db.users.find({ tags: "javascript" })

// Match if array contains ALL of these values
db.users.find({ tags: { $all: ["javascript", "mongodb"] } })

// Match by array size
db.users.find({ tags: { $size: 3 } })

// Match array element by condition
db.users.find({
  scores: { $elemMatch: { $gt: 80, $lt: 100 } }
})

// Query nested documents in arrays
db.orders.find({
  "items.productId": "prod123"
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// Add to array
db.users.updateOne(
  { _id: userId },
  { $push: { tags: "python" } }
)

// Add multiple values
db.users.updateOne(
  { _id: userId },
  { $push: { tags: { $each: ["python", "rust", "go"] } } }
)

// Add to array only if value does not already exist
db.users.updateOne(
  { _id: userId },
  { $addToSet: { tags: "javascript" } }
)

// Remove from array by value
db.users.updateOne(
  { _id: userId },
  { $pull: { tags: "php" } }
)

// Remove from array by condition
db.users.updateOne(
  { _id: userId },
  { $pull: { scores: { $lt: 50 } } }
)

// Remove last element from array
db.users.updateOne(
  { _id: userId },
  { $pop: { tags: 1 } }   // 1 = last, -1 = first
)

// Update a specific array element by position
db.users.updateOne(
  { _id: userId },
  { $set: { "tags.0": "typescript" } }  // Update first element
)

// Update first matching array element
db.users.updateOne(
  { _id: userId, "scores.subject": "math" },
  { $set: { "scores.$.grade": "A" } }
)

1
2
3
4
// Filter orders from 2025
db.orders.aggregate([
  { $match: { createdAt: { $gte: ISODate("2025-01-01") } } }
])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Total revenue by status
db.orders.aggregate([
  {
    $group: {
      _id: "$status",
      totalRevenue: { $sum: "$total" },
      orderCount: { $count: {} },
      avgOrder: { $avg: "$total" },
      maxOrder: { $max: "$total" }
    }
  }
])

// Group by month
db.orders.aggregate([
  {
    $group: {
      _id: {
        year: { $year: "$createdAt" },
        month: { $month: "$createdAt" }
      },
      revenue: { $sum: "$total" },
      orders: { $count: {} }
    }
  },
  { $sort: { "_id.year": -1, "_id.month": -1 } }
])

1
2
3
4
5
6
7
8
9
10
11
// Reshape output with computed fields
db.users.aggregate([
  {
    $project: {
      fullName: { $concat: ["$firstName", " ", "$lastName"] },
      email: 1,
      ageInMonths: { $multiply: ["$age", 12] },
      _id: 0
    }
  }
])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Join orders with user details
db.orders.aggregate([
  {
    $lookup: {
      from: "users",
      localField: "userId",
      foreignField: "_id",
      as: "user"
    }
  },
  { $unwind: "$user" },  // Flatten the array to a single object
  {
    $project: {
      total: 1,
      status: 1,
      "user.name": 1,
      "user.email": 1
    }
  }
])

1
2
3
4
5
6
7
8
9
10
11
12
// Flatten an array field to create one document per array element
db.orders.aggregate([
  { $unwind: "$items" },
  {
    $group: {
      _id: "$items.productId",
      totalSold: { $sum: "$items.quantity" },
      revenue: { $sum: { $multiply: ["$items.price", "$items.quantity"] } }
    }
  },
  { $sort: { revenue: -1 } }
])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Get stats and top items in one query
db.orders.aggregate([
  {
    $facet: {
      summary: [
        {
          $group: {
            _id: null,
            totalOrders: { $count: {} },
            totalRevenue: { $sum: "$total" },
            avgOrder: { $avg: "$total" }
          }
        }
      ],
      byStatus: [
        { $group: { _id: "$status", count: { $count: {} } } },
        { $sort: { count: -1 } }
      ],
      recentOrders: [
        { $sort: { createdAt: -1 } },
        { $limit: 5 },
        { $project: { total: 1, status: 1, createdAt: 1 } }
      ]
    }
  }
])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
db.orders.aggregate([
  // Stage 1: Filter completed orders
  { $match: { status: "completed" } },

  // Stage 2: Group by month
  {
    $group: {
      _id: {
        year: { $year: "$createdAt" },
        month: { $month: "$createdAt" }
      },
      revenue: { $sum: "$total" },
      orders: { $count: {} },
      avgOrderValue: { $avg: "$total" }
    }
  },

  // Stage 3: Sort chronologically
  { $sort: { "_id.year": 1, "_id.month": 1 } },

  // Stage 4: Reshape for readability
  {
    $project: {
      _id: 0,
      year: "$_id.year",
      month: "$_id.month",
      revenue: { $round: ["$revenue", 2] },
      orders: 1,
      avgOrderValue: { $round: ["$avgOrderValue", 2] }
    }
  }
])

1
2
// Allow disk use for large aggregations
db.orders.aggregate([...], { allowDiskUse: true })

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// Single field index (ascending)
db.users.createIndex({ email: 1 })

// Single field index (descending)
db.users.createIndex({ createdAt: -1 })

// Unique index (enforces uniqueness like a SQL UNIQUE constraint)
db.users.createIndex({ email: 1 }, { unique: true })

// Compound index (multi-field)
db.orders.createIndex({ userId: 1, createdAt: -1 })

// Text index (for full-text search)
db.articles.createIndex({ title: "text", body: "text" })

// TTL index (auto-delete documents after a time period)
db.sessions.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 3600 }  // Delete after 1 hour
)

// Partial index (only index documents matching a condition)
db.orders.createIndex(
  { createdAt: -1 },
  { partialFilterExpression: { status: "pending" } }
)

// Sparse index (only index documents that have the field)
db.users.createIndex(
  { phone: 1 },
  { sparse: true }
)

// Hashed index (for hash-based sharding)
db.users.createIndex({ userId: "hashed" })

// Wildcard index (index all fields in a subdocument)
db.products.createIndex({ "attributes.$**": 1 })

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// List all indexes on a collection
db.users.getIndexes()

// Get index usage statistics
db.users.aggregate([{ $indexStats: {} }])

// Drop an index by name
db.users.dropIndex("email_1")

// Drop all indexes except _id
db.users.dropIndexes()

// Hide an index (MongoDB 4.4+, test impact without dropping)
db.users.hideIndex("email_1")

// Unhide it
db.users.unhideIndex("email_1")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// Create a collection with validation
db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email", "role"],
      properties: {
        name: {
          bsonType: "string",
          description: "must be a string and is required"
        },
        email: {
          bsonType: "string",
          pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
          description: "must be a valid email"
        },
        age: {
          bsonType: "int",
          minimum: 0,
          maximum: 150,
          description: "must be an integer between 0 and 150"
        },
        role: {
          bsonType: "string",
          enum: ["developer", "designer", "manager", "admin"],
          description: "must be one of the allowed roles"
        }
      }
    }
  },
  validationLevel: "strict",       // strict or moderate
  validationAction: "error"        // error or warn
})

// Add validation to an existing collection
db.runCommand({
  collMod: "users",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email"],
      properties: {
        name: { bsonType: "string" },
        email: { bsonType: "string" }
      }
    }
  },
  validationLevel: "moderate"  // Only validates new inserts and updates to valid docs
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// Create an admin user
use admin
db.createUser({
  user: "admin",
  pwd: "secure_password",
  roles: [{ role: "userAdminAnyDatabase", db: "admin" }]
})

// Create an application user with specific database access
use mydb
db.createUser({
  user: "appuser",
  pwd: "app_password",
  roles: [{ role: "readWrite", db: "mydb" }]
})

// Create a read-only user
db.createUser({
  user: "analyst",
  pwd: "analyst_password",
  roles: [{ role: "read", db: "mydb" }]
})

// View all users in current database
db.getUsers()

// Change a user's password
db.changeUserPassword("appuser", "new_secure_password")

// Grant additional roles
db.grantRolesToUser("appuser", [{ role: "read", db: "analytics" }])

// Revoke roles
db.revokeRolesFromUser("appuser", [{ role: "read", db: "analytics" }])

// Drop a user
db.dropUser("olduser")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Application user: can read/write data but cannot manage schema
use mydb
db.createUser({
  user: "webapp",
  pwd: "app_password",
  roles: [{ role: "readWrite", db: "mydb" }]
})

// Read-only user for analytics dashboards
db.createUser({
  user: "dashboard",
  pwd: "dashboard_password",
  roles: [{ role: "read", db: "mydb" }]
})

// Admin for database management
use admin
db.createUser({
  user: "dba",
  pwd: "dba_password",
  roles: [
    { role: "dbAdmin", db: "mydb" },
    { role: "userAdmin", db: "mydb" }
  ]
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// Check replica set status
rs.status()

// Check who is primary (MongoDB 5.0+)
db.hello()

// Legacy equivalent (deprecated in 5.0)
// rs.isMaster()

// Initiate a replica set
rs.initiate({
  _id: "myReplicaSet",
  members: [
    { _id: 0, host: "mongo1:27017" },
    { _id: 1, host: "mongo2:27017" },
    { _id: 2, host: "mongo3:27017" }
  ]
})

// Add a new member
rs.add("mongo4:27017")

// Remove a member
rs.remove("mongo4:27017")

// Add an arbiter (votes in elections but holds no data)
rs.addArb("arbiter:27017")

// Get replica set configuration
rs.conf()

// Step down primary (triggers election)
rs.stepDown()

// Set read preference to read from secondaries
db.getMongo().setReadPref("secondaryPreferred")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Enable sharding on a database
sh.enableSharding("mydb")

// Shard a collection with a hashed shard key
sh.shardCollection("mydb.users", { userId: "hashed" })

// Shard a collection with a range-based shard key
sh.shardCollection("mydb.orders", { createdAt: 1 })

// Check sharding status
sh.status()

// Check data distribution
db.users.getShardDistribution()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Basic execution stats
db.users.find({ email: "ajit@example.com" }).explain("executionStats")

// Key things to look for in the output:
// - queryPlanner.winningPlan.stage: "COLLSCAN" = bad (no index), "IXSCAN" = good
// - executionStats.nReturned: how many documents were returned
// - executionStats.totalDocsExamined: how many documents MongoDB read
// - executionStats.executionTimeMillis: how long the query took

// Explain an aggregation pipeline
db.orders.explain("executionStats").aggregate([
  { $match: { status: "pending" } },
  { $group: { _id: "$userId", total: { $sum: "$amount" } } }
])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Enable profiler for queries slower than 100ms
db.setProfilingLevel(1, { slowms: 100 })

// Enable profiler for all queries (careful in production)
db.setProfilingLevel(2)

// Check current profiling level
db.getProfilingStatus()

// View slow queries
db.system.profile.find().sort({ ts: -1 }).limit(5).pretty()

// Find the slowest queries
db.system.profile.find().sort({ millis: -1 }).limit(10)

// Disable profiler
db.setProfilingLevel(0)

1
2
3
4
5
6
7
8
9
10
11
// See all running operations
db.currentOp()

// Find long-running operations
db.currentOp({
  "active": true,
  "secs_running": { $gt: 5 }
})

// Kill a specific operation
db.killOp(opId)

1
2
3
4
5
6
7
8
9
10
11
// Overall server status
db.serverStatus()

// Connection count
db.serverStatus().connections

// Memory usage
db.serverStatus().mem

// Operation counters
db.serverStatus().opcounters

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Collection stats including size and index details
db.users.stats()

// Total data size for a collection (in bytes)
db.users.totalSize()

// Total index size
db.users.totalIndexSize()

// Quick overview of all collections with sizes
db.getCollectionNames().forEach(function(coll) {
  var stats = db[coll].stats();
  print(coll + ": " + (stats.size / 1024 / 1024).toFixed(2) + " MB, " +
        stats.count + " documents, " +
        Object.keys(stats.indexSizes || {}).length + " indexes");
})

1
2
3
4
5
6
7
// Check which indexes are being used and how often
db.users.aggregate([{ $indexStats: {} }])

// Find collections with the most documents
db.getCollectionNames().map(function(coll) {
  return { collection: coll, count: db[coll].estimatedDocumentCount() };
}).sort(function(a, b) { return b.count - a.count; })