Querying is the process of retrieving specific documents from a MongoDB collection using a query filter — a JSON-like object that describes the conditions a document must satisfy. MongoDB's query language is expressive and supports everything from simple equality checks to complex logical, array, and regular-expression matching. This tutorial covers the full range of query capabilities, from fundamentals to performance optimization.

📖 1. Introduction

Every read operation in MongoDB revolves around a query document — an object whose keys represent fields to match and whose values describe the matching criteria. Queries can range from a simple exact match to deeply nested combinations of operators.

// Simple equality query
const results = await collection.find({ category: "electronics" }).toArray();

🧱 2. Query Fundamentals

A query filter is passed as the first argument to find() or findOne(). An empty filter {} matches every document in the collection.

// Implicit equality
{ status: "active" }

// Explicit equality using $eq
{ status: { $eq: "active" } }

⚖️ 3. Comparison Operators

Comparison operators let you match values that are greater than, less than, or otherwise numerically or lexically related to a given value.

// Products priced between 20 and 100
const results = await collection.find({
  price: { $gte: 20, $lte: 100 }
}).toArray();

// Products in a specific set of categories
const inCategories = await collection.find({
  category: { $in: ["electronics", "accessories"] }
}).toArray();

🔗 4. Logical Operators

Logical operators combine multiple query conditions using AND, OR, NOT, and NOR semantics.

// Implicit AND (multiple fields)
{ inStock: true, price: { $lt: 50 } }

// Explicit $or
{
  $or: [
    { inStock: true },
    { price: { $lt: 10 } }
  ]
}

// $and with repeated field conditions
{
  $and: [
    { price: { $gt: 10 } },
    { price: { $lt: 100 } }
  ]
}

🧬 5. Element Operators

Element operators check for the existence or type of a field, rather than its value.

// Documents where "discount" field exists
{ discount: { $exists: true } }

// Documents where "price" is a number
{ price: { $type: "number" } }

🧠 6. Evaluation Operators

Evaluation operators perform higher-level logic such as regular expression matching, modulo arithmetic, or evaluating a $expr aggregation expression within a query.

// Regex match (case-insensitive)
{ name: { $regex: "^mouse", $options: "i" } }

// Modulo: even stock counts
{ stockCount: { $mod: [2, 0] } }

// Compare two fields using $expr
{ $expr: { $gt: ["$sold", "$stockCount"] } }

📚 7. Array Operators

Array operators query fields containing arrays, matching based on element presence, size, or structure.

// Array contains both "sale" and "featured"
{ tags: { $all: ["sale", "featured"] } }

// At least one review has rating >= 4 and verified: true
{
  reviews: {
    $elemMatch: { rating: { $gte: 4 }, verified: true }
  }
}

// Array with exactly 3 elements
{ tags: { $size: 3 } }

🧮 8. Bitwise Operators

Bitwise operators test integer field values at the bit level, useful for flags packed into a single numeric field.

// Bits at positions [0, 2] are set to 1
{ permissions: { $bitsAllSet: [0, 2] } }

// All specified bits are clear (0)
{ permissions: { $bitsAllClear: [1, 3] } }

🔤 9. Regular Expressions

MongoDB supports PCRE-compatible regular expressions for pattern matching on string fields, either via $regex or native regex literals in the driver.

// Names starting with "wireless" (case-insensitive)
const results = await collection.find({
  name: /^wireless/i
}).toArray();

🆔 10. Query by _id

Every document has a unique _id field, typically an ObjectId. Querying by _id is the fastest possible lookup since it's always indexed.

const { ObjectId } = require("mongodb");

const product = await collection.findOne({
  _id: new ObjectId("64f1a2b3c4d5e6f7890a1b2c")
});

🗃️ 11. Nested Document Queries

When a field contains an embedded document, you can query it either as a whole object or by targeting a specific nested field.

// Exact match on the entire embedded document
{ address: { city: "Chennai", zip: "600001" } }

// Match a single nested field (order-independent, preferred)
{ "address.city": "Chennai" }

📦 12. Array Queries

Querying array fields can target the whole array, a single element, or elements at a specific index.

// Matches if the array contains "sale" anywhere
{ tags: "sale" }

// Matches if the element at index 0 is "sale"
{ "tags.0": "sale" }

🎯 13. Dot Notation

Dot notation is the standard way to reach into nested documents and arrays using a string path like "field.subfield".

// Nested field inside an array of embedded documents
{ "reviews.author": "Alice" }

// Deeply nested path
{ "shipping.address.country": "India" }

🗂️ 14. Projection

Projection controls which fields are returned, reducing payload size and improving performance.

// Include only name and price
const results = await collection
  .find({ inStock: true }, { projection: { name: 1, price: 1, _id: 0 } })
  .toArray();

↕️ 15. Sorting

Use sort() to order query results. 1 sorts ascending, -1 sorts descending.

const results = await collection
  .find({ category: "electronics" })
  .sort({ price: -1, name: 1 })
  .toArray();

🔢 16. Limiting Results

limit() caps the number of documents returned by a query.

const topFive = await collection
  .find({})
  .sort({ price: -1 })
  .limit(5)
  .toArray();

⏭️ 17. Skipping Results

skip() bypasses a number of documents, often combined with limit() for pagination.

const page3 = await collection
  .find({})
  .sort({ _id: 1 })
  .skip(20)
  .limit(10)
  .toArray();

🖱️ 18. Cursor Methods

find() returns a cursor — a pointer to the result set that can be iterated lazily instead of loading everything into memory at once.

const docs = await collection.find({}).toArray();

await collection.find({}).forEach(doc => {
  console.log(doc.name);
});

const cursor = collection.find({});
for await (const doc of cursor) {
  console.log(doc.name);
}

🧾 19. Distinct Values

The distinct() method returns all unique values for a given field across matching documents.

const categories = await collection.distinct("category");
console.log(categories);
// [ "electronics", "accessories", "furniture" ]

⚡ 20. Query Optimization

Efficient queries rely on indexes. Without an index, MongoDB must perform a collection scan, examining every document to find matches.

// Create an index on the "price" field
await collection.createIndex({ price: 1 });

// Compound index for common query patterns
await collection.createIndex({ category: 1, price: -1 });

💡 21. Query Hints

hint() forces MongoDB to use a specific index, overriding the query planner's default choice — useful when you know a better index exists.

const results = await collection
  .find({ category: "electronics", price: { $gt: 50 } })
  .hint({ category: 1, price: -1 })
  .toArray();

🧭 22. Explain Plans

The explain() method reveals how MongoDB executes a query — including whether it used an index (IXSCAN) or scanned the whole collection (COLLSCAN).

const plan = await collection
  .find({ category: "electronics" })
  .explain("executionStats");

console.log(plan.executionStats.executionTimeMillis);
console.log(plan.queryPlanner.winningPlan.stage);

🚀 23. Performance Considerations

🌟 24. Best Practices

⚠️ 25. Common Mistakes

❓ 26. Frequently Asked Questions

📌 27. Summary