MongoDB Query Guide: CRUD, Aggregation & Indexes (2026)

CRUD Operations

CRUD stands for Create, Read, Update, Delete — the four fundamental database operations. MongoDB uses JSON-like documents instead of rows and tables, which makes these operations feel natural for JavaScript and Node.js developers.

Create (Insert)

// Insert a single document
db.users.insertOne({
  name: "Sarah Chen",
  email: "sarah@example.com",
  role: "developer",
  skills: ["JavaScript", "Python", "MongoDB"],
  address: {
    city: "San Francisco",
    state: "CA",
    country: "US"
  },
  createdAt: new Date()
})

// Insert multiple documents
db.users.insertMany([
  {
    name: "Alex Rivera",
    email: "alex@example.com",
    role: "designer",
    skills: ["Figma", "CSS", "React"],
    createdAt: new Date()
  },
  {
    name: "Jordan Park",
    email: "jordan@example.com",
    role: "developer",
    skills: ["Go", "Kubernetes", "PostgreSQL"],
    createdAt: new Date()
  }
])

// Insert with write concern (wait for majority replication)
db.orders.insertOne(
  { product: "QTool", amount: 29, currency: "USD" },
  { writeConcern: { w: "majority", j: true } }
)

Read (Find)

// Find all documents in a collection
db.users.find()

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

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

// Find with nested field (dot notation)
db.users.find({ "address.city": "San Francisco" })

// Find documents where array contains a value
db.users.find({ skills: "MongoDB" })

// Find with multiple conditions (implicit AND)
db.users.find({
  role: "developer",
  "address.country": "US"
})

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

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

Update

// Update a single document
db.users.updateOne(
  { email: "sarah@example.com" },
  {
    $set: { role: "senior-developer", updatedAt: new Date() },
    $push: { skills: "TypeScript" }
  }
)

// Update multiple documents
db.users.updateMany(
  { role: "developer" },
  { $set: { department: "Engineering" } }
)

// Upsert (insert if not found, update if found)
db.users.updateOne(
  { email: "new@example.com" },
  {
    $set: { name: "New User", role: "member" },
    $setOnInsert: { createdAt: new Date() }
  },
  { upsert: true }
)

// Replace entire document (keep _id)
db.users.replaceOne(
  { email: "sarah@example.com" },
  {
    name: "Sarah Chen",
    email: "sarah@example.com",
    role: "engineering-lead",
    skills: ["JavaScript", "Python", "MongoDB", "TypeScript"],
    updatedAt: new Date()
  }
)

// Find and update atomically (returns the document)
db.users.findOneAndUpdate(
  { email: "sarah@example.com" },
  { $inc: { loginCount: 1 }, $set: { lastLogin: new Date() } },
  { returnDocument: "after" }
)

Delete

// Delete a single document
db.users.deleteOne({ email: "old@example.com" })

// Delete multiple documents
db.users.deleteMany({ role: "inactive" })

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

// Find and delete atomically (returns the deleted document)
db.queue.findOneAndDelete(
  { status: "pending" },
  { sort: { priority: -1, createdAt: 1 } }
)

// Drop entire collection (faster than deleteMany for large collections)
db.tempData.drop()

Query Operators

MongoDB query operators let you express complex conditions beyond simple equality. They start with $ and cover comparison, logical, element, array, and regex matching.

Comparison Operators

// Greater than / less than
db.products.find({ price: { $gt: 10 } })        // price > 10
db.products.find({ price: { $gte: 10 } })       // price >= 10
db.products.find({ price: { $lt: 50 } })        // price < 50
db.products.find({ price: { $lte: 50 } })       // price <= 50

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

// Range (combine operators)
db.products.find({ price: { $gte: 10, $lte: 50 } })

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

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

Logical Operators

// OR: match any condition
db.users.find({
  $or: [
    { role: "admin" },
    { "permissions.canDelete": true }
  ]
})

// AND: match all conditions (explicit, for same field)
db.products.find({
  $and: [
    { price: { $gt: 10 } },
    { price: { $lt: 100 } }
  ]
})

// NOT: invert a condition
db.users.find({
  age: { $not: { $lt: 18 } }
})

// NOR: match none of the conditions
db.users.find({
  $nor: [
    { status: "banned" },
    { status: "suspended" }
  ]
})

Element and Array Operators

// Field exists
db.users.find({ phone: { $exists: true } })

// Field type check
db.data.find({ value: { $type: "string" } })

// Array contains all specified values
db.users.find({ skills: { $all: ["JavaScript", "React"] } })

// Array has exact size
db.users.find({ skills: { $size: 3 } })

// Match array element conditions
db.orders.find({
  items: {
    $elemMatch: {
      product: "QTool",
      quantity: { $gte: 2 }
    }
  }
})

// Regex pattern matching
db.users.find({ name: { $regex: /^sarah/i } })

// Regex with options
db.articles.find({
  title: { $regex: "mongodb", $options: "i" }
})

When building and testing complex regex patterns for MongoDB queries, the Regex Playground lets you write, test, and debug regular expressions in real time before using them in your queries.

Projection and Sorting

Projection controls which fields are returned. Sorting controls the order. Both are essential for query performance and reducing data transfer.

// Include only specific fields (1 = include)
db.users.find(
  { role: "developer" },
  { name: 1, email: 1, skills: 1 }
)
// Returns: { _id, name, email, skills }

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

// Exclude _id
db.users.find(
  { role: "developer" },
  { name: 1, email: 1, _id: 0 }
)

// Sort ascending (1) and descending (-1)
db.users.find().sort({ createdAt: -1 })            // newest first
db.products.find().sort({ price: 1, name: 1 })     // cheapest first, then by name

// Limit results
db.users.find().sort({ createdAt: -1 }).limit(10)

// Skip + limit (pagination)
const page = 3
const pageSize = 20
db.users.find()
  .sort({ createdAt: -1 })
  .skip((page - 1) * pageSize)
  .limit(pageSize)

// Distinct values
db.users.distinct("role")
// ["developer", "designer", "admin", "manager"]

Aggregation Pipeline

The aggregation pipeline processes documents through a sequence of stages. Each stage transforms the data and passes results to the next. It is MongoDB's most powerful feature for analytics, reporting, and complex data transformation.

Core Pipeline Stages

Stage	Purpose	SQL Equivalent
$match	Filter documents	WHERE
$group	Aggregate by key	GROUP BY
$project	Reshape documents, compute fields	SELECT
$sort	Order results	ORDER BY
$limit	Restrict result count	LIMIT
$lookup	Join with another collection	LEFT JOIN
$unwind	Flatten arrays into documents	UNNEST
$addFields	Add computed fields	Computed column

Pipeline Examples

// Total revenue per product category this month
db.orders.aggregate([
  // Stage 1: Filter to current month
  {
    $match: {
      createdAt: {
        $gte: new Date("2026-02-01"),
        $lt: new Date("2026-03-01")
      },
      status: "completed"
    }
  },
  // Stage 2: Flatten the items array
  { $unwind: "$items" },
  // Stage 3: Group by category, sum revenue
  {
    $group: {
      _id: "$items.category",
      totalRevenue: { $sum: { $multiply: ["$items.price", "$items.quantity"] } },
      orderCount: { $sum: 1 },
      avgOrderValue: { $avg: { $multiply: ["$items.price", "$items.quantity"] } }
    }
  },
  // Stage 4: Sort by revenue descending
  { $sort: { totalRevenue: -1 } },
  // Stage 5: Reshape the output
  {
    $project: {
      category: "$_id",
      totalRevenue: { $round: ["$totalRevenue", 2] },
      orderCount: 1,
      avgOrderValue: { $round: ["$avgOrderValue", 2] },
      _id: 0
    }
  }
])

// Top 10 most active users with their latest activity
db.activities.aggregate([
  {
    $match: {
      timestamp: { $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) }
    }
  },
  {
    $group: {
      _id: "$userId",
      activityCount: { $sum: 1 },
      lastActivity: { $max: "$timestamp" },
      actions: { $addToSet: "$action" }
    }
  },
  { $sort: { activityCount: -1 } },
  { $limit: 10 },
  // Join with users collection
  {
    $lookup: {
      from: "users",
      localField: "_id",
      foreignField: "_id",
      as: "user"
    }
  },
  { $unwind: "$user" },
  {
    $project: {
      name: "$user.name",
      email: "$user.email",
      activityCount: 1,
      lastActivity: 1,
      uniqueActions: { $size: "$actions" },
      _id: 0
    }
  }
])

Advanced Aggregation Stages

$lookup: Collection Joins

// Join orders with products (advanced pipeline syntax)
db.orders.aggregate([
  {
    $lookup: {
      from: "products",
      let: { productIds: "$items.productId" },
      pipeline: [
        {
          $match: {
            $expr: { $in: ["$_id", "$$productIds"] }
          }
        },
        {
          $project: { name: 1, price: 1, category: 1 }
        }
      ],
      as: "productDetails"
    }
  }
])

$bucket: Histogram Grouping

// Group users by age ranges
db.users.aggregate([
  {
    $bucket: {
      groupBy: "$age",
      boundaries: [0, 18, 25, 35, 50, 65, 120],
      default: "Unknown",
      output: {
        count: { $sum: 1 },
        avgIncome: { $avg: "$income" },
        users: { $push: "$name" }
      }
    }
  }
])

$facet: Multiple Pipelines in Parallel

// Get multiple aggregations in a single query
db.products.aggregate([
  {
    $facet: {
      priceStats: [
        {
          $group: {
            _id: null,
            avgPrice: { $avg: "$price" },
            minPrice: { $min: "$price" },
            maxPrice: { $max: "$price" },
            totalProducts: { $sum: 1 }
          }
        }
      ],
      byCategory: [
        { $group: { _id: "$category", count: { $sum: 1 } } },
        { $sort: { count: -1 } }
      ],
      topRated: [
        { $sort: { rating: -1 } },
        { $limit: 5 },
        { $project: { name: 1, rating: 1, price: 1 } }
      ]
    }
  }
])

When you need to format and inspect the JSON output from aggregation queries, the JSON Formatter handles deeply nested MongoDB results with syntax highlighting and a collapsible tree view.

Indexes and Performance

Indexes are the single most important factor in MongoDB query performance. Without an index on a queried field, MongoDB performs a collection scan — reading every document to find matches. With a proper index, the same query uses a B-tree lookup that is orders of magnitude faster.

Creating Indexes

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

// Unique index (enforces uniqueness)
db.users.createIndex({ email: 1 }, { unique: true })

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

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

// TTL index (auto-delete after expiry)
db.sessions.createIndex(
  { expiresAt: 1 },
  { expireAfterSeconds: 0 }
)

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

// Wildcard index (index all fields in a sub-document)
db.logs.createIndex({ "metadata.$**": 1 })

Index Management

// List all indexes on a collection
db.users.getIndexes()

// Get index sizes
db.users.stats().indexSizes

// Drop a specific index
db.users.dropIndex("email_1")

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

// Rebuild indexes (use during maintenance)
db.users.reIndex()

The ESR Rule for Compound Indexes

When designing compound indexes, order fields by Equality, Sort, Range:

1. Equality fields first — fields matched with exact values (status: "active")
2. Sort fields second — fields used in .sort()
3. Range fields last — fields with $gt, $lt, $in

// Query pattern:
db.orders.find({
  status: "shipped",           // Equality
  amount: { $gte: 100 }        // Range
}).sort({ createdAt: -1 })      // Sort

// Optimal compound index (ESR order):
db.orders.createIndex({
  status: 1,       // E: Equality
  createdAt: -1,   // S: Sort
  amount: 1        // R: Range
})

Using explain() to Analyze Queries

// Check if a query uses an index
db.users.find({ email: "sarah@example.com" }).explain("executionStats")

// Key fields in explain output:
// - queryPlanner.winningPlan.stage: "IXSCAN" (good) vs "COLLSCAN" (bad)
// - executionStats.nReturned: documents returned
// - executionStats.totalDocsExamined: documents scanned
// - executionStats.executionTimeMillis: query duration

// Ideal: nReturned === totalDocsExamined (no wasted reads)
// Problem: totalDocsExamined >> nReturned (missing or wrong index)

Schema Design Patterns

MongoDB is schema-flexible, but that does not mean schemaless. Good schema design is the difference between a fast application and one that requires expensive queries and workarounds. The key decision is embedding vs referencing.

Embedding: One-to-Few

// Embed addresses inside the user document
// Good when: always accessed together, limited size
{
  _id: ObjectId("..."),
  name: "Sarah Chen",
  email: "sarah@example.com",
  addresses: [
    {
      type: "home",
      street: "123 Main St",
      city: "San Francisco",
      state: "CA",
      zip: "94105"
    },
    {
      type: "work",
      street: "456 Market St",
      city: "San Francisco",
      state: "CA",
      zip: "94102"
    }
  ]
}

Referencing: One-to-Many

// User document (parent)
{
  _id: ObjectId("user123"),
  name: "Sarah Chen",
  email: "sarah@example.com"
}

// Order documents (children reference parent)
{
  _id: ObjectId("order456"),
  userId: ObjectId("user123"),
  items: [
    { productId: ObjectId("prod789"), quantity: 1, price: 29 }
  ],
  total: 29,
  status: "completed",
  createdAt: ISODate("2026-02-14T10:00:00Z")
}

// Query with $lookup join
db.users.aggregate([
  { $match: { _id: ObjectId("user123") } },
  {
    $lookup: {
      from: "orders",
      localField: "_id",
      foreignField: "userId",
      as: "orders"
    }
  }
])

Hybrid: Subset Pattern

// Product document with embedded review summary
{
  _id: ObjectId("prod789"),
  name: "QTool",
  price: 29,
  // Embed the 3 most recent reviews (subset)
  recentReviews: [
    { author: "Alex", rating: 5, text: "Essential toolkit", date: ISODate("2026-02-10") },
    { author: "Jordan", rating: 5, text: "Saves hours every week", date: ISODate("2026-02-08") },
    { author: "Taylor", rating: 4, text: "Great value", date: ISODate("2026-02-05") }
  ],
  // Summary stats (denormalized)
  reviewStats: {
    count: 142,
    avgRating: 4.8
  }
}

// Full reviews live in a separate collection
// reviews: { productId, author, rating, text, date }

If you are migrating from SQL and need to convert queries, the SQL to MongoDB Converter translates SELECT, INSERT, UPDATE, and DELETE statements into MongoDB query syntax.

Transactions

MongoDB supports multi-document ACID transactions for operations that must succeed or fail together. Single-document operations are always atomic, but when you need to update multiple documents or collections atomically, use a transaction.

const { MongoClient } = require('mongodb')

async function transferFunds(fromId, toId, amount) {
  const client = new MongoClient(process.env.MONGODB_URI)
  const session = client.startSession()

  try {
    await session.withTransaction(async () => {
      const accounts = client.db('banking').collection('accounts')

      // Debit sender
      const sender = await accounts.findOneAndUpdate(
        { _id: fromId, balance: { $gte: amount } },
        { $inc: { balance: -amount } },
        { session, returnDocument: 'after' }
      )

      if (!sender) {
        throw new Error('Insufficient funds or account not found')
      }

      // Credit receiver
      await accounts.updateOne(
        { _id: toId },
        { $inc: { balance: amount } },
        { session }
      )

      // Record the transfer
      await client.db('banking').collection('transfers').insertOne(
        {
          from: fromId,
          to: toId,
          amount,
          timestamp: new Date()
        },
        { session }
      )
    })

    console.log('Transfer completed')
  } catch (error) {
    console.error('Transfer failed:', error.message)
  } finally {
    await session.endSession()
    await client.close()
  }
}

Query Optimization

Slow MongoDB queries are almost always caused by missing indexes, inefficient query patterns, or poor schema design. Here is a systematic approach to finding and fixing performance problems.

Profiling Slow Queries

// Enable profiler for queries slower than 100ms
db.setProfilingLevel(1, { slowms: 100 })

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

// Key fields in profiler output:
// - millis: execution time
// - nscanned: documents examined
// - nreturned: documents returned
// - planSummary: "COLLSCAN" (bad) or "IXSCAN" (good)

// Disable profiler when done
db.setProfilingLevel(0)

// View current operations (find long-running queries)
db.currentOp({ secs_running: { $gt: 5 } })

Optimization Techniques

// 1. Use projection to return only needed fields
// BAD: returns entire documents
db.users.find({ role: "developer" })

// GOOD: returns only what you need
db.users.find(
  { role: "developer" },
  { name: 1, email: 1, _id: 0 }
)

// 2. Covered query (index contains all requested fields)
db.users.createIndex({ role: 1, name: 1, email: 1 })
db.users.find(
  { role: "developer" },
  { name: 1, email: 1, _id: 0 }
)
// MongoDB reads ONLY the index, never touches documents

// 3. Use $match early in aggregation pipelines
// BAD: process everything, then filter
db.orders.aggregate([
  { $lookup: { from: "products", ... } },
  { $match: { status: "active" } }          // filter too late
])

// GOOD: filter first, then process
db.orders.aggregate([
  { $match: { status: "active" } },          // filter early
  { $lookup: { from: "products", ... } }
])

// 4. Range-based pagination (fast at any offset)
// Instead of skip/limit:
db.posts.find({ _id: { $lt: ObjectId("lastSeenId") } })
  .sort({ _id: -1 })
  .limit(20)

// 5. Use bulkWrite for batch operations
db.users.bulkWrite([
  { updateOne: { filter: { _id: id1 }, update: { $set: { active: true } } } },
  { updateOne: { filter: { _id: id2 }, update: { $set: { active: false } } } },
  { insertOne: { document: { name: "New User", active: true } } }
])

When generating TypeScript interfaces from your MongoDB document structure, the JSON to TypeScript Converter creates type-safe interfaces from sample JSON documents.

SQL to MongoDB Mapping

If you are coming from a SQL background, this mapping helps translate concepts.

SQL	MongoDB	Example
Table	Collection	db.users
Row	Document	{ name: "Sarah" }
Column	Field	name, email
SELECT * FROM users WHERE role='dev'	db.users.find({ role: "dev" })
SELECT name, email FROM users	db.users.find({}, { name:1, email:1 })
INSERT INTO users VALUES (...)	db.users.insertOne({...})
UPDATE users SET role='admin' WHERE ...	db.users.updateOne({...}, { $set: {...} })
DELETE FROM users WHERE ...	db.users.deleteOne({...})
JOIN	$lookup (aggregation)
GROUP BY	$group (aggregation)
CREATE INDEX	db.collection.createIndex()

For automated SQL-to-MongoDB query conversion, use the SQL to MongoDB Converter to translate your existing SQL queries into MongoDB syntax.

---

Related Developer Tools

---