Creating Indexes in MongoDB: Supercharge Your Queries

1. Single-Field Indexes

The simplest and most common form of index, a single-field index, is created on just one field of a document. It’s perfect for queries that frequently filter or sort by a specific field.

// Create an ascending index on the 'name' field in the 'users' collection
db.users.createIndex({ name: 1 });

// Create a descending index on the 'price' field in the 'products' collection
db.products.createIndex({ price: -1 });

Use Case: Speed up common queries like db.users.find({ name: "Alice" }) or db.products.find().sort({ price: -1 }). It’s your go-to for basic filtering and sorting.

2. Compound Indexes

When your queries involve filtering or sorting by multiple fields simultaneously, a compound index is your best friend. It includes multiple fields in a single index structure.

Important: The order of fields in a compound index matters significantly! MongoDB uses the index from left to right. A compound index on { firstName: 1, lastName: -1 } can efficiently support queries on firstName, or on firstName and lastName together. However, it generally won’t efficiently support queries solely on lastName unless firstName is also part of the query or sort, because firstName is the leading key.

// Create a compound index on 'firstName' (ascending) and 'lastName' (descending)
db.users.createIndex({ firstName: 1, lastName: -1 });

Use Case: Optimize queries such as db.users.find({ firstName: "John", lastName: "Doe" }) or db.users.find({ firstName: "John" }).sort({ lastName: -1 }). Think about the common query patterns in your application and design compound indexes accordingly.

3. Multikey Indexes

If a field in your documents holds an array of values, a multikey index is automatically created when you index that field. MongoDB creates an index entry for each element in the array, allowing efficient querying of array contents.

// Example document: { "title": "My Post", "tags": ["mongodb", "nosql", "database"] }
// Create a multikey index on the 'tags' array field
db.posts.createIndex({ tags: 1 });

Use Case: Speed up queries that search for specific elements within an array, like finding all posts tagged “mongodb”: db.posts.find({ tags: "mongodb" }).

4. Text Indexes

Need to perform full-text search capabilities on string content? Text indexes are designed for this. They support features like stemming (e.g., “running” matches “run”), tokenization, and case-insensitive searches, making your search functionality robust.

// Create a text index on the 'description' field
db.products.createIndex({ description: "text" });

// You can also index multiple fields for text search; MongoDB will search across all of them
db.articles.createIndex({ title: "text", content: "text" });

Use Case: Enable powerful text searches using the $text operator: db.products.find({ $text: { $search: "powerful laptop" } }). This is essential for features like blog search or product descriptions.

5. Hashed Indexes

Hashed indexes compute a hash of the field’s value and index that hash. They are primarily used for sharding (distributing data across multiple servers) to ensure an even distribution of data, which helps prevent “hot spots” on single servers. They can also be useful for equality queries.

// Create a hashed index on the 'userId' field
db.users.createIndex({ userId: "hashed" });

Use Case: Ideal for shard keys in sharded clusters, offering efficient data distribution and equality-based lookups. For general purpose querying, B-tree (single-field/compound) indexes are usually preferred.

6. Geospatial Indexes (2dsphere)

For applications dealing with location-based data, geospatial indexes are indispensable. MongoDB supports queries on geographical data, such as finding points within a certain radius or polygon, critical for maps and location-aware services.

The 2dsphere index is recommended for spherical geometries (like Earth coordinates) and supports GeoJSON objects, providing accurate calculations for real-world locations.

// Example document: { "name": "Eiffel Tower", "location": { type: "Point", coordinates: [ 2.2945, 48.8584 ] } }
// Create a 2dsphere index on the 'location' field
db.places.createIndex({ location: "2dsphere" });

Use Case: Find places near a specific point: db.places.find({ location: { $nearSphere: { $geometry: { type: "Point", coordinates: [ -73.9667, 40.78 ] }, $maxDistance: 1000 } } }). Think “restaurants near me” features.

7. TTL (Time-To-Live) Indexes

TTL indexes provide an automatic mechanism to remove documents from a collection after a specified period. This is incredibly useful for managing data that should expire, like session logs, cache data, or temporary messages, without needing to write custom cleanup scripts.

// Create a TTL index on 'createdAt' to expire documents after 1 hour (3600 seconds)
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 });

Important: The indexed field must be a BSON Date type or an array of BSON Date types for the TTL functionality to work correctly. The TTL monitor runs periodically (typically every 60 seconds) to remove expired documents.

Use Case: Automatically clean up old user sessions, log entries, or temporary verification tokens, ensuring your database doesn’t grow indefinitely with stale data.

8. Wildcard Indexes

When your document structure is highly dynamic, with fields being frequently added or removed, a wildcard index can be a lifesaver. It allows you to index all fields within a document or specific sub-paths without explicitly naming them.

// Indexes all fields and sub-fields in the document (use with extreme caution!)
db.users.createIndex({ "$**": 1 });

// Indexes all fields under the 'address' sub-document
db.users.createIndex({ "address.$**": 1 });

Use Case: Useful for collections where the schema is fluid, and you need to query across various, unpredictable fields. Use with caution as they can be resource-intensive, consume significant disk space, and potentially be less efficient than targeted indexes. They are best reserved for specific, well-understood scenarios.

Listing Indexes

To see all indexes defined on a collection, use the getIndexes() method. This is crucial for understanding your current indexing strategy.

db.myCollection.getIndexes();

This command returns an array of documents, each describing an index on the collection, including its name, key, and options. The _id_ index is created by default on every collection.

Dropping Indexes

If an index is no longer needed or is underperforming, you can remove it using dropIndex(). You can drop by index name (which you can get from getIndexes()) or by the index key specification.

// Drop by index name (e.g., "name_1" for an index on { name: 1 })
db.myCollection.dropIndex("name_1");

// Drop by index key specification (useful if you didn't provide a custom name)
db.myCollection.dropIndex({ fieldName: 1 });

To drop all custom indexes on a collection (except the default _id index), use dropIndexes():

db.myCollection.dropIndexes();

Always be careful when dropping indexes in production, as it can severely impact query performance until a new index is built.

1. Insert Sample Data:

Insert at least 10-15 product documents into the products collection. Each product should have fields like name (string), category (string), price (number), tags (array of strings), description (string), and lastUpdated (Date type). Make sure to include diverse data for categories, prices, and tags.

db.products.insertMany([
  { name: "Laptop Pro", category: "Electronics", price: 1200, tags: ["tech", "laptop"], description: "Powerful laptop for professionals.", lastUpdated: new Date() },
  { name: "Novel: The Lost City", category: "Books", price: 25, tags: ["fiction", "adventure"], description: "An exciting adventure novel.", lastUpdated: new Date() },
  { name: "Wireless Mouse", category: "Electronics", price: 30, tags: ["accessory", "tech"], description: "Ergonomic wireless mouse.", lastUpdated: new Date() },
  { name: "Coffee Maker", category: "Home Goods", price: 75, tags: ["kitchen", "appliance"], description: "Brew perfect coffee every morning.", lastUpdated: new Date() },
  { name: "MongoDB Guide", category: "Books", price: 45, tags: ["database", "nosql", "tech"], description: "Comprehensive guide to MongoDB.", lastUpdated: new Date() },
  { name: "Smartwatch X", category: "Electronics", price: 250, tags: ["wearable", "tech"], description: "Track your fitness and notifications.", lastUpdated: new Date() },
  { name: "Ergonomic Keyboard", category: "Electronics", price: 150, tags: ["tech", "accessory"], description: "Comfortable typing experience.", lastUpdated: new Date() },
  { name: "Fantasy Epic Volume 1", category: "Books", price: 35, tags: ["fiction", "fantasy"], description: "First book in a thrilling series.", lastUpdated: new Date() },
  { name: "Blender Deluxe", category: "Home Goods", price: 110, tags: ["kitchen", "appliance"], description: "High-power blender for smoothies.", lastUpdated: new Date() },
  { name: "JavaScript Definitive Guide", category: "Books", price: 60, tags: ["programming", "webdev", "tech"], description: "The ultimate guide for JavaScript.", lastUpdated: new Date() },
  { name: "VR Headset", category: "Electronics", price: 499, tags: ["gaming", "tech", "vr"], description: "Immersive virtual reality experience.", lastUpdated: new Date() },
  { name: "Yoga Mat", category: "Sports & Outdoors", price: 20, tags: ["fitness", "wellness"], description: "Non-slip yoga mat for all levels.", lastUpdated: new Date() }
]);

2. Create a Single-Field Index:

Create an ascending index on the category field. Then, run a query like db.products.find({ category: "Electronics" }) and use explain("executionStats") to verify index usage (look for IXSCAN).

db.products.createIndex({ category: 1 });
db.products.find({ category: "Electronics" }).explain("executionStats");

3. Create a Compound Index:

Create a compound index on category (ascending) and price (descending). Test with a query like db.products.find({ category: "Books", price: { $lt: 50 } }).sort({ price: -1 }) and verify index usage with explain("executionStats").

db.products.createIndex({ category: 1, price: -1 });
db.products.find({ category: "Books", price: { $lt: 50 } }).sort({ price: -1 }).explain("executionStats");

4. Create a Multikey Index:

Create a multikey index on the tags array field. Query for products with a specific tag, e.g., db.products.find({ tags: "tech" }), and check explain("executionStats").

db.products.createIndex({ tags: 1 });
db.products.find({ tags: "tech" }).explain("executionStats");

5. Implement a TTL Index:

Create a TTL index on the lastUpdated field to expire documents after a short period (e.g., 120 seconds for quicker observation). After creating, wait for a few minutes and then query to see if older documents have been removed. You might need to adjust the expireAfterSeconds to a smaller value like 60 or 120 for quicker observation during practice.

// To make observation quicker for practice, use a smaller value like 120 seconds (2 minutes)
db.products.createIndex({ lastUpdated: 1 }, { expireAfterSeconds: 120 });

// Wait 2-3 minutes, then run:
db.products.find({}); // You should see some older documents disappear

6. List and Drop Indexes:

List all indexes on your products collection using getIndexes(). Then, drop one of the custom indexes you created (e.g., the single-field category index). Verify by listing indexes again.

db.products.getIndexes();
db.products.dropIndex("category_1"); // Or whatever name MongoDB assigned
db.products.getIndexes(); // Verify it's gone