Indexes
Index Concepts in MongoDB
In MongoDB, indexes are crucial for optimizing query performance by efficiently retrieving data from
collections. Here are the key concepts related to indexes in MongoDB:
1. Index: Indexes are special data structures that store a small portion of the collection's data set in an
easy-to-traverse form. MongoDB indexes use a B-tree data structure.
The index stores the value of a specific field or set of fields, ordered by the value of the field. The
ordering of the index entries supports efficient equality matches and range-based query operations. In
addition, MongoDB can return sorted results using the ordering in the index.
Default Index
MongoDB creates a unique index on the _id field during the creation of a collection. The _id index
prevents clients from inserting two documents with the same value for the _id field. You cannot drop
this index
.
2. Types of Indexes:
o Single Field Index: Indexes created on a single field of a document.
o Compound Index: Indexes created on multiple fields of a document.
o Multikey Index: Indexes created on arrays, indexing each element of the array.
3. Index Creation:
o Indexes can be created using the createIndex() method in MongoDB.
o Example:
db.collection.createIndex({ field: 1 }); // ascending index on 'field'
4. Index Properties:
o Unique Index: Ensures that the indexed fields do not store duplicate values.
o Sparse Index: Indexes only documents that have the indexed fields.
5. Index Usage:
o MongoDB query optimizer automatically selects the most efficient index for a query.
o Indexes can significantly improve query performance, especially for large collections.
6. Index Management:
o Indexes can be managed (created, dropped, listed) using commands like createIndex,
dropIndex, getIndexes, etc.
7. Index Strategies:
o MongoDB uses several strategies for indexing, including B-tree indexes for most types and
geospatial indexes for location-based data.
8. Indexing Best Practices:
o Indexes should be chosen based on the types of queries your application performs most
frequently.
o Consider the trade-offs between query performance and storage/write overhead when creating
indexes.
9. Monitoring and Maintenance:
o MongoDB provides tools to monitor index usage and performance (e.g., db.collection.stas()).
o Regularly review and optimize indexes based on query patterns and collection usage.
Types of indexes
Indexes play a crucial role in optimizing query performance by improving the speed of data retrieval
operations. Here are the main types of indexes available in MongoDB:
1. Single Field Index: This is the most basic type of index and involves indexing on a single field of a
document. It speeds up queries that filter on that particular field.
db.collection.createIndex({ fieldName: 1 }); // 1 for ascending, -1 for descending
2. Compound Index: This type of index involves indexing on multiple fields of a document. It can
speed up queries that filter on the indexed fields and support queries that filter on a prefix (subset) of
the indexed fields.
db.collection.createIndex({ field1: 1, field2: -1 });
3. Multikey Index: MongoDB can index arrays, and this type of index is used when indexing on fields
that contain arrays. It indexes each element of the array separately.
db.collection.createIndex({ "arrayField": 1 });
4. Text Index: This index is specifically designed for text search within string content. It supports
language-specific stemming, stop words, and other text-specific features.
db.collection.createIndex({ content: "text" });
5. Geospatial Index: MongoDB supports indexing on geospatial data. This type of index is used for
queries that calculate geometries and distances between points on a sphere.
db.collection.createIndex({ location: "2dsphere" });
6. Hashed Index: This index type hashes the value of the indexed field and can be useful for equality
matches but not for range-based queries.
db.collection.createIndex({ fieldName: "hashed" });
7. Wildcard Index: This is an internal index used by MongoDB for queries on fields within nested
documents.
db.collection.createIndex({ "nested.field": 1 });
Indexes and Its Use Cases
Indexes play a crucial role in optimizing query performance by facilitating efficient data retrieval. Here are
the key points about indexes and their use cases in MongoDB:
What is an Index?
An index is a data structure that stores a small portion of the collection’s data set in an easy-to-traverse form.
This improves the efficiency of queries. Indexes are similar in concept to indexes in books—they provide
quick access to specific information without having to scan every page (or document in MongoDB).
Use Cases of Indexes:
1. Improving Query Performance:
o Equality Queries: Indexes can accelerate queries that filter documents based on equality
conditions ({field: value}).
o Range Queries: Queries that use range operators ($gt, $lt, etc.) can benefit from indexes.
o Sorting: Indexes can speed up sorting operations if the sort key is indexed.
o Covered Queries: When all the fields in a query are covered by an index, MongoDB can
fulfill the query using the index alone without accessing the actual documents.
2. Enforcing Uniqueness:
o Indexes can enforce uniqueness constraints on fields, ensuring that no two documents in a
collection can have the same value for a specific field or combination of fields.
3. Supporting Text Search:
o MongoDB provides text indexes that allow for fast searching of textual content within
documents.
4. Geospatial Queries:
o MongoDB supports geospatial indexes to optimize queries that perform geometric
calculations on spatial data (e.g., finding nearby locations).
5. Aggregation Framework:
o Indexes can improve the performance of aggregation queries, particularly when $match
stages can utilize indexes.
Creating Indexes and Managing Indexes
Creating and managing indexes in MongoDB is essential for optimizing query performance and ensuring
efficient data access. Here's a detailed guide on how to create indexes and manage them effectively:
Creating Indexes:
In MongoDB, indexes can be created on one or more fields of a collection. Indexes are created using the
createIndex() method, which is available both in the MongoDB shell and through various MongoDB drivers
(like pymongo for Python, MongoDB Node.js driver, etc.).
Syntax:
db.collection.createIndex(keys, options)
keys: Specifies the field(s) to index. It can be a single field or a compound index (multiple fields).
options: Optional parameters to configure the index, such as uniqueness, index type, partial indexes,
etc.
Examples:
1. Creating a Single Field Index:
db.users.createIndex({ username: 1 });
This creates an ascending index on the username field of the users collection.
2. Creating a Compound Index:
db.products.createIndex({ category: 1, price: -1 });
This creates a compound index on category (ascending) and price (descending) fields of the products
collection.
3. Creating a Unique Index:
db.customers.createIndex({ email: 1 }, { unique: true });
This creates a unique index on the email field of the customers collection, ensuring no two documents can
have the same email.
4. Creating a Text Index:
db.articles.createIndex({ content: "text" });
This creates a text index on the content field of the articles collection, enabling full-text search capabilities.
Managing Indexes:
Once indexes are created, they need to be managed to ensure they are effective and efficient:
Viewing Existing Indexes:
You can view existing indexes on a collection using the getIndexes() method or by querying the
system.indexes collection (or db.collection.getIndexes() in the shell).
db.collection.getIndexes();
Dropping Indexes:
To drop (delete) an index, use the dropIndex() method:
db.collection.dropIndex(indexName);
indexName: The name or the specification of the index to drop.
Index strategies
When developing your indexing strategy, you should have a deep understanding of your application's
queries. Before you build indexes, map out the types of queries you will run so that you can build indexes
that reference those fields
Generally, MongoDB only uses one index to fulfill most queries. However, each clause of an $orquery may
use a different index.
The MongoDB Use the ESR (Equality, Sort, Range) Rule
An index that references multiple fields is a compound index. Compound indexes can dramatically improve
query response times.
Index keys correspond to document fields. In most cases, applying the ESR (Equality, Sort, Range) Rule to
arrange the index keys helps to create a more efficient compound index.
Equality
"Equality" refers to an exact match on a single value. The following exact match queries scan the cars
collection for documents whose model field exactly matches Cordoba.
db.cars.find( { model: "Cordoba" } )
db.cars.find( { model: { $eq: "Cordoba" } } )
Sort
"Sort" determines the order for results. Sort follows equality matches because the equality matches reduce
the number of documents that need to be sorted. Sorting after the equality matches also allows MongoDB to
do a non-blocking sort.
db.cars.find( { manufacturer: "GM" } ).sort( { model: 1 } )
Range
"Range" filters scan fields. The scan doesn't require an exact match, which means range filters are loosely
bound to index keys. To improve query efficiency, limit the range bounds and use equality matches to reduce
the number of documents to scan.
Range filters resemble the following:
db.cars.find( { price: { $gte: 15000} } )
db.cars.find( { age: { $lt: 10 } } )
db.cars.find( { priorAccidents: { $ne: null } } )
