Creating and Using Indexes in MongoDB

Table of Contents

1. Introduction to Indexes in MongoDB
2. Why Indexes Matter
3. Types of Indexes in MongoDB
   • Single Field Indexes
   • Compound Indexes
   • Multikey Indexes
   • Text Indexes
   • Geospatial Indexes
   • Hashed Indexes
4. Creating Indexes in MongoDB
5. Viewing Existing Indexes
6. Index Use Case Scenarios
7. Indexes and Performance
8. Indexing Best Practices
9. When Not to Use Indexes
10. Conclusion

1. Introduction to Indexes in MongoDB

Indexes are a crucial aspect of MongoDB that significantly enhance query performance. By default, MongoDB performs a collection scan, which means it examines every document in the collection to match the query. Indexes act like shortcuts that help MongoDB locate the relevant documents much faster, akin to the index of a book.

Without proper indexing, even the most powerful servers can experience sluggish query performance as the data volume grows. Therefore, understanding and using indexes correctly is fundamental when building scalable MongoDB applications.

2. Why Indexes Matter

Imagine running a query on a collection of millions of documents. Without an index, MongoDB has to scan through each document to find matches, which is computationally expensive. Indexes provide an efficient way to locate and retrieve only those documents that match the query criteria.

Key benefits of indexing include:

• Faster data retrieval
• Improved query efficiency
• Better scalability for large datasets
• Support for unique constraints and data validation

3. Types of Indexes in MongoDB

MongoDB supports a wide variety of index types tailored for different use cases. Here’s a breakdown of the most important ones:

Single Field Indexes

The most basic type. Created on a single field, it supports quick lookup and sorting.

jsCopyEditdb.users.createIndex({ "email": 1 })

Compound Indexes

Indexes on multiple fields, often used to support more complex queries.

jsCopyEditdb.orders.createIndex({ "userId": 1, "createdAt": -1 })

The order of fields in a compound index matters and affects its usability for different queries.

Multikey Indexes

Automatically created when you index a field that contains an array. MongoDB indexes each element of the array.

jsCopyEditdb.products.createIndex({ "tags": 1 })

Text Indexes

Used for full-text search in string content fields.

jsCopyEditdb.articles.createIndex({ content: "text" })

Text indexes support searching via $text queries.

Geospatial Indexes

Ideal for location-based queries like finding nearby places. Two types are supported:

• 2d
• 2dsphere

jsCopyEditdb.places.createIndex({ location: "2dsphere" })

Hashed Indexes

Used for sharding and distributing data evenly across shards. Not optimal for range queries.

jsCopyEditdb.customers.createIndex({ userId: "hashed" })

4. Creating Indexes in MongoDB

Indexes can be created with createIndex() or ensureIndex() (deprecated). Here’s a basic example:

jsCopyEditdb.customers.createIndex({ "email": 1 })

Options include:

• unique: Ensures values in the indexed field are unique.
• background: Builds the index in the background without locking writes.
• sparse: Only indexes documents where the field exists.
• expireAfterSeconds: Used for TTL indexes.

Example with options:

jsCopyEditdb.sessions.createIndex({ "lastAccessed": 1 }, { expireAfterSeconds: 3600 })

5. Viewing Existing Indexes

To list all indexes on a collection:

jsCopyEditdb.customers.getIndexes()

You can also drop an index:

jsCopyEditdb.customers.dropIndex("email_1")

Or drop all indexes:

jsCopyEditdb.customers.dropIndexes()

6. Index Use Case Scenarios

Use Case 1: Unique Email Addresses

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

Ensures no duplicate email IDs are stored.

Use Case 2: Blog Search

jsCopyEditdb.blogs.createIndex({ content: "text", title: "text" })

Enables full-text search across articles.

Use Case 3: Location-Based Services

jsCopyEditdb.stores.createIndex({ location: "2dsphere" })

Find nearest stores within a certain radius.

7. Indexes and Performance

You can use explain() to understand how MongoDB is using indexes:

jsCopyEditdb.users.find({ email: "[email protected]" }).explain("executionStats")

Look for IXSCAN instead of COLLSCAN to ensure indexes are being used.

Be mindful of the index size, as it grows with data. Too many indexes can degrade write performance and increase memory usage.

8. Indexing Best Practices

• Index fields used in queries: Especially for frequent filters, sorts, and joins.
• Avoid over-indexing: Indexes improve reads but slow down writes (due to index maintenance).
• Use compound indexes wisely: Combine fields often queried together.
• Use hint() to force index usage when necessary.
• Monitor slow queries: Use MongoDB Atlas profiler or logs to detect unindexed queries.

9. When Not to Use Indexes

There are scenarios where indexes can backfire:

• Fields with high write frequency and low query use
• Low cardinality fields (e.g., gender: male/female)
• Very small datasets where collection scans are faster

Every index consumes disk space and adds overhead to insert/update operations, so be judicious in index design.

10. Conclusion

Indexes in MongoDB are indispensable tools for optimizing read operations and enabling scalable, performant applications. With several index types like compound, multikey, text, and geospatial, MongoDB provides a flexible indexing system to suit various needs.

Understanding when and how to use indexes, along with regular profiling of queries, is key to keeping your application fast and efficient as it grows in complexity and size.