kushagra's Blog

Indexing in MongoDB: Boosting Query Performance

kushagra's photo
kushagra
·

4 min read

Table of contents

Introduction

MongoDB is a NoSQL database that provides flexibility and scalability. However, as datasets grow, querying large collections can become inefficient. Indexing in MongoDB is a powerful feature that optimizes query performance by allowing the database to quickly locate data without scanning every document.

What is an Index?

An index is a special data structure that stores a small portion of the collection’s data in a way that makes queries faster. Instead of performing a full collection scan, MongoDB uses indexes to locate the required documents efficiently.

How MongoDB Indexing Works

MongoDB indexes use B-trees, a data structure optimized for quick lookups, inserts, and deletions. When a query is executed, MongoDB checks the index to determine the location of relevant documents, avoiding a full collection scan.

Steps of Index Utilization:

  1. Query Execution: When a query is issued, MongoDB first checks if an index exists for the specified field.

  2. Index Lookup: If an index is found, MongoDB uses it to fetch document references quickly.

  3. Document Retrieval: The database retrieves only the necessary documents based on the indexed references.

  4. Sorting & Filtering: If sorting or additional filtering is needed, MongoDB applies it to the indexed result set.

  5. Returning Results: The final, optimized set of documents is returned to the client.

Using explain() on a query helps analyze how MongoDB utilizes indexes and whether optimizations are needed.

Example:

// Create an index on the "name" field
db.users.createIndex({ name: 1 });

When querying with:

db.users.find({ name: "Alice" });

MongoDB will use the B-tree index to quickly locate and return the relevant document without scanning the entire collection.

CollScan vs IxScan

MongoDB query execution uses two main strategies: Collection Scan (CollScan) and Index Scan (IxScan).

1. Collection Scan (CollScan)

A collection scan occurs when there is no suitable index available, forcing MongoDB to scan every document in the collection to find matching records.

Disadvantages:

  • Slow for large collections

  • High resource consumption (CPU and memory)

Example:

db.users.find({ age: 30 }).explain("executionStats");

If no index exists on age, the explain() output will show "stage": "COLLSCAN", meaning a full collection scan was performed.

2. Index Scan (IxScan)

An index scan occurs when a query can leverage an existing index, allowing MongoDB to locate documents efficiently without scanning the entire collection.

Advantages:

  • Faster query execution

  • Lower resource usage

Example:

// Create an index on the "age" field
db.users.createIndex({ age: 1 });

// Query using the index
db.users.find({ age: 30 }).explain("executionStats");

If an index exists on age, the explain() output will show "stage": "IXSCAN", indicating that MongoDB used an index scan instead of a full collection scan.

Types of Indexes in MongoDB

1. Single Field Index

A single field index is created on a single field of a document.

Example:

// Create an index on the "name" field
db.users.createIndex({ name: 1 });

The 1 signifies ascending order, while -1 would create a descending index.

2. Compound Index

A compound index includes multiple fields in a single index.

Example:

// Create an index on "name" and "age"
db.users.createIndex({ name: 1, age: -1 });

This helps optimize queries that filter or sort by both fields.

3. Multikey Index

Multikey indexes are used for fields that contain arrays.

Example:

// Indexing an array field
db.products.createIndex({ tags: 1 });

MongoDB automatically creates a multikey index if the indexed field contains an array.

4. Text Index

Text indexes are used for text-based searches.

Example:

// Creating a text index on the "description" field
db.articles.createIndex({ description: "text" });

You can then perform text searches using $text queries.

5. Hashed Index

Hashed indexes are used for sharded clusters and distribute data evenly.

Example:

// Create a hashed index on "user_id"
db.users.createIndex({ user_id: "hashed" });

6. TTL Index (Time-To-Live)

A TTL index automatically deletes documents after a specified period.

Example:

// Create a TTL index to delete documents after 3600 seconds
db.logs.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 });

How to View Existing Indexes

To check the indexes on a collection, use:

db.users.getIndexes();

When to Use Indexes?

  • When queries frequently search specific fields

  • When sorting or filtering is common

  • When working with large collections to avoid performance bottlenecks

When Not to Use Indexes?

  • When the collection is small

  • When there are frequent writes, as indexes can slow down inserts/updates

  • When unnecessary indexes are created, leading to storage overhead

Conclusion

Indexing is an essential technique in MongoDB that improves query efficiency and performance. Choosing the right index type can significantly impact your application’s responsiveness. Regularly analyze query performance using explain() to determine whether indexing is needed.

By strategically implementing indexes, you can ensure your MongoDB queries run faster and more efficiently, making your application scalable and responsive.

Want to Learn More?

Stay tuned for advanced MongoDB optimizations, including indexed aggregation, sharding strategies, and query tuning techniques!

MongoDB