Indexes for Performance in Mongoose | Rustcode

Indexes for Performance in Mongoose

Indexes in MongoDB are a critical tool to improve query performance by allowing the database to quickly locate documents without scanning the entire collection. Mongoose provides simple ways to define and manage indexes directly within your schemas, helping you optimize your Node.js applications. This article covers types of indexes, how to create them in Mongoose, compound indexes, and best practices.

Table of Content

Why Use Indexes?

Indexes speed up query execution by providing efficient lookup capabilities.
Without indexes, MongoDB must scan the entire collection to find matching documents, which slows performance on large datasets.
Indexes support faster sorting, filtering, and join-like operations through .populate().

Types of Indexes

Single Field Index: Index on a single field, e.g., username.
Compound Index: Index on multiple fields, e.g., { username: 1, createdAt: -1 }, supports queries using both fields.
Unique Index: Ensures the indexed field’s values are unique in the collection.
Multikey Index: Indexes array fields for efficient queries on array elements.
Text Index: Supports search on string content with text search operators.
Geospatial Index: Supports location-based queries.

Creating Indexes in Mongoose Schemas

You can define indexes directly within your schema fields or use the schema.index() method:

const userSchema = new mongoose.Schema({
  username: { type: String, unique: true }, // Unique index on username
  email: String,
  createdAt: Date,
});

// Create an index on email (ascending order)
userSchema.index({ email: 1 });

// Create a compound index on username and createdAt
userSchema.index({ username: 1, createdAt: -1 });

Compound Indexes

Compound indexes allow MongoDB to optimize queries filtering on multiple fields. The order of fields in the index matters for query efficiency. Follow the ESR rule:

Equality (fields tested for exact matches) come first
Sort (fields queried with sort order) come next
Range (fields queried with range operators) come last

Example:

userSchema.index({ status: 1, createdAt: -1 });

Important Index Options

unique: true — to enforce unique values.
sparse: true — indexes only documents with the indexed field.
expireAfterSeconds — for TTL (Time-to-Live) indexes to auto-remove documents.
background: true — builds the index without blocking database operations.

Best Practices

Always create indexes on fields frequently used in queries, filters, and sorts.
Use compound indexes carefully respecting the field query patterns.
Avoid over-indexing as indexes increase write overhead and disk usage.
Use explain() and profiling in MongoDB to analyze query performance.
Leverage TTL indexes for automatically cleaning up old or expired data.
Build indexes in the background in production to avoid downtime.

Quick Reference Table

Index Type	Purpose	Usage Example
Single Field Index	Speed up queries on one field	`{ email: 1 }`
Compound Index	Optimize queries filtering on multiple fields	`{ username: 1, createdAt: -1 }`
Unique Index	Ensure unique values for a field	`{ username: 1, unique: true }`
TTL Index	Expire documents automatically	`{ createdAt: 1 }, { expireAfterSeconds: 3600 }`

Conclusion

Proper use of indexes is essential for optimizing MongoDB query performance in Mongoose applications. Defining the right indexes reduces query times and resource consumption, improving overall application responsiveness. Following best practices for creating and managing indexes will ensure your app scales efficiently.