$devvkit resources --cheatsheet mongodb-cheatsheet

MongoDB Cheatsheet

[databases]

Every essential MongoDB command: database operations, CRUD, query operators, aggregation stages, and indexes, with syntax and real use cases.76 commands · 5 sections

MongoDB is the most popular document database. This cheatsheet covers the operations you write daily: database and collection management, CRUD with find and insert, query operators, the aggregation pipeline, and indexes for performance.

Examples use the mongo/mongosh shell syntax: the same operators work in every driver.

Database & Collection Ops11

$use mydb

Use case: Switch to (or create) a database.Example: use devvkit

$show dbs

Use case: List all databases.Example: show dbs

$show collections

Use case: List collections in the current database.Example: show collections

$db.createCollection("users")

Use case: Create an empty collection.Example: db.createCollection("audit_logs")

$db.dropDatabase()

Use case: Delete the current database: and everything in it.Example: db.dropDatabase()

$db.getCollectionNames()

Use case: Array of collection names: script-friendly.Example: db.getCollectionNames()

$db.stats()

Use case: Database statistics: size, collections, objects.Example: db.stats()

$db.users.renameCollection("accounts")

Use case: Rename a collection.Example: db.users.renameCollection("accounts")

$db.users.drop()

Use case: Delete a collection and ALL its documents.Example: db.users.drop()

$db.runCommand({ ping: 1 })

Use case: Check server connectivity: the mongo health check.Example: db.runCommand({ ping: 1 })

$db.version()

Use case: Server version: for docs and compatibility.Example: db.version()

CRUD Operations22

$db.users.insertOne({ name: "Jane", plan: "pro" })

Use case: Insert a single document.Example: db.users.insertOne({ name: "Jane", email: "jane@x.com" })

$db.users.insertMany([{...}, {...}])

Use case: Insert many documents in one call.Example: db.users.insertMany([{ name: "A" }, { name: "B" }])

$db.users.find()

Use case: Return ALL documents in a collection.Example: db.users.find()

$db.users.findOne({ _id: ObjectId("...") })

Use case: Find a single document by id: the lookup pattern.Example: db.users.findOne({ _id: ObjectId("665f1c2b...") })

$db.users.find({ plan: "pro" })

Use case: Find all documents matching a filter.Example: db.users.find({ plan: "pro" })

$db.users.find().limit(10)

Use case: Limit results: pagination.Example: db.users.find().limit(10)

$db.users.find().skip(20)

Use case: Skip N documents: page 3.Example: db.users.find().skip(20).limit(10)

$db.users.find().sort({ created_at: -1 })

Use case: Sort results: newest first.Example: db.users.find().sort({ created_at: -1 }).limit(5)

$db.users.find({}, { name: 1, _id: 0 })

Use case: Projection: return only specific fields.Example: db.users.find({}, { name: 1, email: 1, _id: 0 })

$db.users.countDocuments({ plan: "pro" })

Use case: Count matching documents.Example: db.users.countDocuments({ plan: "pro" })

$db.users.updateOne({ _id }, { $set: { plan: "pro" } })

Use case: Update ONE document's fields: never overwrite whole docs.Example: db.users.updateOne({ _id }, { $set: { plan: "pro" } })

$db.users.updateMany({ plan: "free" }, { $set: { status: "active" } })

Use case: Bulk update all matching documents.Example: db.users.updateMany({ plan: "free" }, { $set: { status: "active" } })

$db.users.updateOne({ _id }, { $inc: { loginCount: 1 } })

Use case: Increment a counter atomically: login stats.Example: db.users.updateOne({ _id }, { $inc: { logins: 1 } })

$db.users.updateOne({ _id }, { $push: { tags: "new" } })

Use case: Append to an array field.Example: db.users.updateOne({ _id }, { $push: { interests: "rust" } })

$db.users.updateOne({ _id }, { $pull: { tags: "old" } })

Use case: Remove a value from an array.Example: db.users.updateOne({ _id }, { $pull: { tags: "legacy" } })

$db.users.updateOne({ _id }, { $unset: { tempField: "" } })

Use case: Remove a field from a document.Example: db.users.updateOne({ _id }, { $unset: { deprecated: "" } })

$db.users.updateOne({ _id }, { $set: { plan: "pro" } }, { upsert: true })

Use case: Update or INSERT if missing: idempotent syncs.Example: db.users.updateOne({ email }, { $set: { plan: "pro" } }, { upsert: true })

$db.users.replaceOne({ _id }, newDoc)

Use case: Replace a whole document: new shape, same _id.Example: db.users.replaceOne({ _id }, { name: "Jane", age: 30 })

$db.users.deleteOne({ _id })

Use case: Delete ONE matching document.Example: db.users.deleteOne({ _id: ObjectId("...") })

$db.users.deleteMany({ status: "banned" })

Use case: Delete all matching documents.Example: db.users.deleteMany({ status: "banned" })

$db.users.deleteMany({})

Use case: Delete EVERYTHING: collection stays, documents gone.Example: db.users.deleteMany({})

$db.users.bulkWrite([...])

Use case: Mix inserts/updates/deletes in one batch: fast syncs.Example: db.users.bulkWrite([ { insertOne: { document: { name: "X" } } }, { updateOne: { filter: { _id }, update: { $set: { ok: true } } } } ])

Query Operators17

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

Use case: Greater than: $gte, $lt, $lte for ranges.Example: db.users.find({ age: { $gt: 30 } })

$db.users.find({ age: { $gte: 18, $lte: 65 } })

Use case: Range filter: between two values.Example: db.users.find({ age: { $gte: 18, $lte: 65 } })

$db.users.find({ plan: { $in: ["pro", "team"] } })

Use case: Match any value in a list.Example: db.users.find({ plan: { $in: ["pro", "team"] } })

$db.users.find({ plan: { $nin: ["banned"] } })

Use case: Exclude values.Example: db.users.find({ plan: { $nin: ["banned"] } })

$db.users.find({ email: { $exists: true } })

Use case: Field exists: find docs missing a field.Example: db.users.find({ email: { $exists: false } })

$db.users.find({ email: { $ne: null } })

Use case: Not null: the mongo null check.Example: db.users.find({ email: { $ne: null } })

$db.users.find({ name: /^ja/i })

Use case: Regex match: case-insensitive prefix search.Example: db.users.find({ name: /^ja/i })

$db.users.find({ $and: [{ plan: "pro" }, { age: { $gt: 18 } }] })

Use case: AND: implicit when fields are separate; explicit for the same field.Example: db.users.find({ $and: [{ plan: "pro" }, { age: { $gt: 18 } }] })

$db.users.find({ $or: [{ plan: "pro" }, { plan: "team" }] })

Use case: OR: match either condition.Example: db.users.find({ $or: [{ plan: "pro" }, { plan: "team" }] })

$db.users.find({ tags: "dev" })

Use case: Array contains: match documents whose array includes the value.Example: db.users.find({ tags: "dev" })

$db.users.find({ tags: { $all: ["dev", "api"] } })

Use case: Array contains ALL values.Example: db.users.find({ tags: { $all: ["dev", "api"] } })

$db.users.find({ tags: { $size: 3 } })

Use case: Match arrays with exactly N elements.Example: db.users.find({ tags: { $size: 3 } })

$db.users.find({ "address.city": "Berlin" })

Use case: Nested field query: dot notation.Example: db.users.find({ "address.city": "Berlin" })

$db.users.find({ $text: { $search: "devvkit" } })

Use case: Full-text search: needs a text index.Example: db.users.find({ $text: { $search: "developer" } })

$db.users.find({ $where: "this.a > this.b" })

Use case: Compare two fields in the same doc: slow, avoid on big collections.Example: db.users.find({ $where: "this.spent > this.budget" })

$db.users.find({}, { name: 1 }).toArray().length

Use case: Count without loading fields: projection + count.Example: db.users.find({}, { name: 1 }).toArray().length

$db.users.findOne({ _id }, { _id: 0, name: 1 })

Use case: Fetch just one field of one doc.Example: db.users.findOne({ _id }, { _id: 0, name: 1 })

Aggregation Pipeline12

$db.orders.aggregate([{ $match: { status: "paid" } }])

Use case: Filter first: always start pipelines with $match.Example: db.orders.aggregate([{ $match: { status: "paid" } }])

$db.orders.aggregate([{ $group: { _id: "$customer_id", total: { $sum: "$total" } } }])

Use case: Group and sum: revenue per customer.Example: db.orders.aggregate([{ $group: { _id: "$customer_id", total: { $sum: "$total" } } }])

$db.orders.aggregate([{ $group: { _id: null, avg: { $avg: "$total" } } }])

Use case: Aggregate over ALL documents: _id: null groups everything.Example: db.orders.aggregate([{ $group: { _id: null, avg: { $avg: "$total" } } }])

$db.orders.aggregate([{ $sort: { total: -1 } }, { $limit: 5 }])

Use case: Top 5 orders: sort then limit.Example: db.orders.aggregate([{ $sort: { total: -1 } }, { $limit: 5 }])

$db.orders.aggregate([{ $project: { customer_id: 1, tax: { $multiply: ["$total", 0.1] } } }])

Use case: Shape output and compute new fields.Example: db.orders.aggregate([{ $project: { customer_id: 1, tax: { $multiply: ["$total", 0.1] } } }])

$db.users.aggregate([{ $unwind: "$tags" }])

Use case: Flatten arrays into separate documents: per-tag stats.Example: db.users.aggregate([ { $unwind: "$tags" }, { $group: { _id: "$tags", count: { $sum: 1 } } }, { $sort: { count: -1 } } ])

db.orders.aggregate([{ $lookup: { from: "customers", localField: "customer_id", foreignField: "_id", as: "customer" } }])

Use case: JOIN: pull related documents from another collection.Example: db.orders.aggregate([{ $lookup: { from: "customers", localField: "customer_id", foreignField: "_id", as: "customer" } }])

db.orders.aggregate([{ $group: { _id: "$customer_id", total: { $sum: "$total" } } }, { $match: { total: { $gt: 1000 } } }])

Use case: Filter AFTER grouping: $match works at any stage.Example: db.orders.aggregate([ { $group: { _id: "$customer_id", total: { $sum: "$total" } } }, { $match: { total: { $gt: 1000 } } } ])

db.orders.aggregate([{ $facet: { byStatus: [{ $group: { _id: "$status", n: { $sum: 1 } } }], revenue: [{ $group: { _id: null, sum: { $sum: "$total" } } }] } }])

Use case: Multiple pipelines in one pass: dashboard queries.Example: db.orders.aggregate([{ $facet: { byStatus: [...], revenue: [...] } }])

$db.events.aggregate([{ $match: { ts: { $gte: start } } }, { $sortByCount: "$event_type" }])

Use case: Count by value: the group+sort shorthand.Example: db.events.aggregate([{ $sortByCount: "$event_type" }])

db.orders.aggregate([{ $group: { _id: { $dateToString: { format: "%Y-%m", date: "$created_at" } }, total: { $sum: "$total" } } }])

Use case: Group by month: time-series revenue.Example: db.orders.aggregate([{ $group: { _id: { $dateToString: { format: "%Y-%m", date: "$created_at" } }, total: { $sum: "$total" } } }])

db.orders.aggregate([{ $group: { _id: null, total: { $sum: "$total" }, first: { $first: "$_id" }, last: { $last: "$_id" } } }])

Use case: First/last accumulators: oldest and newest docs.Example: db.orders.aggregate([{ $group: { _id: null, first: { $first: "$_id" } } }])

Indexes & Performance14

$db.users.createIndex({ email: 1 })

Use case: Single-field index: speed up email lookups.Example: db.users.createIndex({ email: 1 })

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

Use case: Unique index: enforce no duplicate emails.Example: db.users.createIndex({ email: 1 }, { unique: true })

$db.orders.createIndex({ customer_id: 1, created_at: -1 })

Use case: Compound index: filter by customer, sort by date.Example: db.orders.createIndex({ customer_id: 1, created_at: -1 })

$db.users.createIndex({ name: "text" })

Use case: Text index: enables $text search.Example: db.users.createIndex({ name: "text", bio: "text" })

$db.sessions.createIndex({ last_seen: 1 }, { expireAfterSeconds: 3600 })

Use case: TTL index: auto-delete documents after N seconds. Session expiry.Example: db.sessions.createIndex({ last_seen: 1 }, { expireAfterSeconds: 86400 })

$db.getCollectionInfos()

Use case: List collections with their indexes.Example: db.getCollectionInfos()

$db.users.getIndexes()

Use case: Show all indexes on a collection.Example: db.users.getIndexes()

$db.users.dropIndex("email_1")

Use case: Drop an index by name.Example: db.users.dropIndex("email_1")

$db.users.explain("executionStats").find({ email: "x@y.com" })

Use case: Explain: is the query using the index or COLLSCAN?Example: db.users.explain("executionStats").find({ email: "x@y.com" })

$db.users.find({ email: "x" }).hint({ email: 1 })

Use case: Force a specific index: temporary query tuning.Example: db.users.find({ email: "x" }).hint({ email: 1 })

$db.currentOp()

Use case: Show running operations: find the slow/hung query.Example: db.currentOp()

$db.killOp(<opid>)

Use case: Kill a running operation by id.Example: db.killOp(123456)

$db.setProfilingLevel(1, { slowms: 100 })

Use case: Log slow queries: find what to optimize.Example: db.setProfilingLevel(1, { slowms: 100 })

$db.system.profile.find().sort({ ts: -1 }).limit(10)

Use case: Recent slow queries: the profiler output.Example: db.system.profile.find().sort({ ts: -1 }).limit(10)

MongoDB Cheatsheet

Every essential MongoDB command: database operations, CRUD, query operators, aggregation stages, and indexes, with syntax and real use cases.

Examples use the mongo/mongosh shell syntax: the same operators work in every driver.

Database & Collection Ops

use mydb: Switch to (or create) a database.

Example: use devvkit

show dbs: List all databases.

Example: show dbs

show collections: List collections in the current database.

Example: show collections

db.createCollection("users"): Create an empty collection.

Example: db.createCollection("audit_logs")

db.dropDatabase(): Delete the current database: and everything in it.

Example: db.dropDatabase()

db.getCollectionNames(): Array of collection names: script-friendly.

Example: db.getCollectionNames()

db.stats(): Database statistics: size, collections, objects.

Example: db.stats()

db.users.renameCollection("accounts"): Rename a collection.

Example: db.users.renameCollection("accounts")

db.users.drop(): Delete a collection and ALL its documents.

Example: db.users.drop()

db.runCommand({ ping: 1 }): Check server connectivity: the mongo health check.

Example: db.runCommand({ ping: 1 })

db.version(): Server version: for docs and compatibility.

Example: db.version()

CRUD Operations

db.users.insertOne({ name: "Jane", plan: "pro" }): Insert a single document.

Example: db.users.insertOne({ name: "Jane", email: "jane@x.com" })

db.users.insertMany([{...}, {...}]): Insert many documents in one call.

Example: db.users.insertMany([{ name: "A" }, { name: "B" }])

db.users.find(): Return ALL documents in a collection.

Example: db.users.find()

db.users.findOne({ _id: ObjectId("...") }): Find a single document by id: the lookup pattern.

Example: db.users.findOne({ _id: ObjectId("665f1c2b...") })

db.users.find({ plan: "pro" }): Find all documents matching a filter.

Example: db.users.find({ plan: "pro" })

db.users.find().limit(10): Limit results: pagination.

Example: db.users.find().limit(10)

db.users.find().skip(20): Skip N documents: page 3.

Example: db.users.find().skip(20).limit(10)

db.users.find().sort({ created_at: -1 }): Sort results: newest first.

Example: db.users.find().sort({ created_at: -1 }).limit(5)

db.users.find({}, { name: 1, _id: 0 }): Projection: return only specific fields.

Example: db.users.find({}, { name: 1, email: 1, _id: 0 })

db.users.countDocuments({ plan: "pro" }): Count matching documents.

Example: db.users.countDocuments({ plan: "pro" })

db.users.updateOne({ _id }, { $set: { plan: "pro" } }): Update ONE document's fields: never overwrite whole docs.

Example: db.users.updateOne({ _id }, { $set: { plan: "pro" } })

db.users.updateMany({ plan: "free" }, { $set: { status: "active" } }): Bulk update all matching documents.

Example: db.users.updateMany({ plan: "free" }, { $set: { status: "active" } })

db.users.updateOne({ _id }, { $inc: { loginCount: 1 } }): Increment a counter atomically: login stats.

Example: db.users.updateOne({ _id }, { $inc: { logins: 1 } })

db.users.updateOne({ _id }, { $push: { tags: "new" } }): Append to an array field.

Example: db.users.updateOne({ _id }, { $push: { interests: "rust" } })

db.users.updateOne({ _id }, { $pull: { tags: "old" } }): Remove a value from an array.

Example: db.users.updateOne({ _id }, { $pull: { tags: "legacy" } })

db.users.updateOne({ _id }, { $unset: { tempField: "" } }): Remove a field from a document.

Example: db.users.updateOne({ _id }, { $unset: { deprecated: "" } })

db.users.updateOne({ _id }, { $set: { plan: "pro" } }, { upsert: true }): Update or INSERT if missing: idempotent syncs.

Example: db.users.updateOne({ email }, { $set: { plan: "pro" } }, { upsert: true })

db.users.replaceOne({ _id }, newDoc): Replace a whole document: new shape, same _id.

Example: db.users.replaceOne({ _id }, { name: "Jane", age: 30 })

db.users.deleteOne({ _id }): Delete ONE matching document.

Example: db.users.deleteOne({ _id: ObjectId("...") })

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

Example: db.users.deleteMany({ status: "banned" })

db.users.deleteMany({}): Delete EVERYTHING: collection stays, documents gone.

Example: db.users.deleteMany({})

db.users.bulkWrite([...]): Mix inserts/updates/deletes in one batch: fast syncs.

Example: db.users.bulkWrite([ { insertOne: { document: { name: "X" } } }, { updateOne: { filter: { _id }, update: { $set: { ok: true } } } } ])

Query Operators

db.users.find({ age: { $gt: 30 } }): Greater than: $gte, $lt, $lte for ranges.

Example: db.users.find({ age: { $gt: 30 } })

db.users.find({ age: { $gte: 18, $lte: 65 } }): Range filter: between two values.

Example: db.users.find({ age: { $gte: 18, $lte: 65 } })

db.users.find({ plan: { $in: ["pro", "team"] } }): Match any value in a list.

Example: db.users.find({ plan: { $in: ["pro", "team"] } })

db.users.find({ plan: { $nin: ["banned"] } }): Exclude values.

Example: db.users.find({ plan: { $nin: ["banned"] } })

db.users.find({ email: { $exists: true } }): Field exists: find docs missing a field.

Example: db.users.find({ email: { $exists: false } })

db.users.find({ email: { $ne: null } }): Not null: the mongo null check.

Example: db.users.find({ email: { $ne: null } })

db.users.find({ name: /^ja/i }): Regex match: case-insensitive prefix search.

Example: db.users.find({ name: /^ja/i })

db.users.find({ $and: [{ plan: "pro" }, { age: { $gt: 18 } }] }): AND: implicit when fields are separate; explicit for the same field.

Example: db.users.find({ $and: [{ plan: "pro" }, { age: { $gt: 18 } }] })

db.users.find({ $or: [{ plan: "pro" }, { plan: "team" }] }): OR: match either condition.

Example: db.users.find({ $or: [{ plan: "pro" }, { plan: "team" }] })

db.users.find({ tags: "dev" }): Array contains: match documents whose array includes the value.

Example: db.users.find({ tags: "dev" })

db.users.find({ tags: { $all: ["dev", "api"] } }): Array contains ALL values.

Example: db.users.find({ tags: { $all: ["dev", "api"] } })

db.users.find({ tags: { $size: 3 } }): Match arrays with exactly N elements.

Example: db.users.find({ tags: { $size: 3 } })

db.users.find({ "address.city": "Berlin" }): Nested field query: dot notation.

Example: db.users.find({ "address.city": "Berlin" })

db.users.find({ $text: { $search: "devvkit" } }): Full-text search: needs a text index.

Example: db.users.find({ $text: { $search: "developer" } })

db.users.find({ $where: "this.a > this.b" }): Compare two fields in the same doc: slow, avoid on big collections.

Example: db.users.find({ $where: "this.spent > this.budget" })

db.users.find({}, { name: 1 }).toArray().length: Count without loading fields: projection + count.

Example: db.users.find({}, { name: 1 }).toArray().length

db.users.findOne({ _id }, { _id: 0, name: 1 }): Fetch just one field of one doc.

Example: db.users.findOne({ _id }, { _id: 0, name: 1 })

Aggregation Pipeline

db.orders.aggregate([{ $match: { status: "paid" } }]): Filter first: always start pipelines with $match.

Example: db.orders.aggregate([{ $match: { status: "paid" } }])

db.orders.aggregate([{ $group: { _id: "$customer_id", total: { $sum: "$total" } } }]): Group and sum: revenue per customer.

Example: db.orders.aggregate([{ $group: { _id: "$customer_id", total: { $sum: "$total" } } }])

db.orders.aggregate([{ $group: { _id: null, avg: { $avg: "$total" } } }]): Aggregate over ALL documents: _id: null groups everything.

Example: db.orders.aggregate([{ $group: { _id: null, avg: { $avg: "$total" } } }])

db.orders.aggregate([{ $sort: { total: -1 } }, { $limit: 5 }]): Top 5 orders: sort then limit.

Example: db.orders.aggregate([{ $sort: { total: -1 } }, { $limit: 5 }])

db.orders.aggregate([{ $project: { customer_id: 1, tax: { $multiply: ["$total", 0.1] } } }]): Shape output and compute new fields.

Example: db.orders.aggregate([{ $project: { customer_id: 1, tax: { $multiply: ["$total", 0.1] } } }])

db.users.aggregate([{ $unwind: "$tags" }]): Flatten arrays into separate documents: per-tag stats.

Example: db.users.aggregate([ { $unwind: "$tags" }, { $group: { _id: "$tags", count: { $sum: 1 } } }, { $sort: { count: -1 } } ])

db.orders.aggregate([{ $lookup: { from: "customers", localField: "customer_id", foreignField: "_id", as: "customer" } }])

: JOIN: pull related documents from another collection.

Example: db.orders.aggregate([{ $lookup: { from: "customers", localField: "customer_id", foreignField: "_id", as: "customer" } }])

db.orders.aggregate([{ $group: { _id: "$customer_id", total: { $sum: "$total" } } }, { $match: { total: { $gt: 1000 } } }])

: Filter AFTER grouping: $match works at any stage.

Example: db.orders.aggregate([ { $group: { _id: "$customer_id", total: { $sum: "$total" } } }, { $match: { total: { $gt: 1000 } } } ])

db.orders.aggregate([{ $facet: { byStatus: [{ $group: { _id: "$status", n: { $sum: 1 } } }], revenue: [{ $group: { _id: null, sum: { $sum: "$total" } } }] } }])

: Multiple pipelines in one pass: dashboard queries.

Example: db.orders.aggregate([{ $facet: { byStatus: [...], revenue: [...] } }])

db.events.aggregate([{ $match: { ts: { $gte: start } } }, { $sortByCount: "$event_type" }]): Count by value: the group+sort shorthand.

Example: db.events.aggregate([{ $sortByCount: "$event_type" }])

db.orders.aggregate([{ $group: { _id: { $dateToString: { format: "%Y-%m", date: "$created_at" } }, total: { $sum: "$total" } } }])

: Group by month: time-series revenue.

Example: db.orders.aggregate([{ $group: { _id: { $dateToString: { format: "%Y-%m", date: "$created_at" } }, total: { $sum: "$total" } } }])

db.orders.aggregate([{ $group: { _id: null, total: { $sum: "$total" }, first: { $first: "$_id" }, last: { $last: "$_id" } } }])

: First/last accumulators: oldest and newest docs.

Example: db.orders.aggregate([{ $group: { _id: null, first: { $first: "$_id" } } }])

Indexes & Performance

db.users.createIndex({ email: 1 }): Single-field index: speed up email lookups.

Example: db.users.createIndex({ email: 1 })

db.users.createIndex({ email: 1 }, { unique: true }): Unique index: enforce no duplicate emails.

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

db.orders.createIndex({ customer_id: 1, created_at: -1 }): Compound index: filter by customer, sort by date.

Example: db.orders.createIndex({ customer_id: 1, created_at: -1 })

db.users.createIndex({ name: "text" }): Text index: enables $text search.

Example: db.users.createIndex({ name: "text", bio: "text" })

db.sessions.createIndex({ last_seen: 1 }, { expireAfterSeconds: 3600 }): TTL index: auto-delete documents after N seconds. Session expiry.

Example: db.sessions.createIndex({ last_seen: 1 }, { expireAfterSeconds: 86400 })

db.getCollectionInfos(): List collections with their indexes.

Example: db.getCollectionInfos()

db.users.getIndexes(): Show all indexes on a collection.

Example: db.users.getIndexes()

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

Example: db.users.dropIndex("email_1")

db.users.explain("executionStats").find({ email: "x@y.com" }): Explain: is the query using the index or COLLSCAN?

Example: db.users.explain("executionStats").find({ email: "x@y.com" })

db.users.find({ email: "x" }).hint({ email: 1 }): Force a specific index: temporary query tuning.

Example: db.users.find({ email: "x" }).hint({ email: 1 })

db.currentOp(): Show running operations: find the slow/hung query.

Example: db.currentOp()

db.killOp(<opid>): Kill a running operation by id.

Example: db.killOp(123456)

db.setProfilingLevel(1, { slowms: 100 }): Log slow queries: find what to optimize.

Example: db.setProfilingLevel(1, { slowms: 100 })

db.system.profile.find().sort({ ts: -1 }).limit(10): Recent slow queries: the profiler output.

Example: db.system.profile.find().sort({ ts: -1 }).limit(10)

Frequently asked questions

What is the difference between find and findOne?

find returns a cursor over all matching documents: you iterate or convert it with .toArray(). findOne returns the first matching document directly, which is convenient for lookups by _id.

How do I update documents?

Use updateOne for a single document, updateMany for all matches, and replaceOne to swap an entire document. Always use update operators like $set, $inc, and $push instead of rewriting whole documents.

What are indexes and when do I need them?

Indexes speed up queries by sorting fields into a searchable structure. Create them on fields used in filters, sorts, and joins (lookups). Use compound indexes for multi-field queries and TTL indexes for expiring data.

What is the aggregation pipeline?

A pipeline processes documents through stages: $match filters, $group aggregates, $project shapes output, $sort orders, and $lookup joins collections. It replaces most multi-step map-reduce logic.