10 Best Practices While Using MongoDB Indexes

Shreetesh M — Mon, 14 Aug 2023 15:32:31 +0000

Introduction

Here are some points on optimization and best practices while using MongoDB indexes to ensure good performance of queries in deployment.

ⓘ Note
What are indexes? Check out this page.

The below points will generally work for most applications.

Best Practices

Always index each of your collections, it makes a huge difference in query performance.

Use the ESR (Equality, Sort, Range) rule while building compound indexes. These almost always support index scans for both query predicate and sorting.
Use partial indexes at the first opportunity available in your application. They can reduce the size of your index.
Remove indexes that are already prefixes of a compound index. For example, if a compound index such as:
```
{stock: 1, date: -1, price: 1}
```
is available, then its valid prefixes:
```
{stock: 1, date: -1}
{stock: -1, date: 1}
{stock: 1}
{stock: -1}
```
need not be separately created as indexes. The first compound index can serve the same functionality as these indexes.
Build compound indexes such that most of your queries are covered using a projection. This will prevent the need to fetch documents entirely and will reduce query time.
Avoid using unrooted or right-anchored regex in the query field. This kind of regex will increase query time due to the variability in the beginning of the value, even if an index is present for that field.
Some examples of unrooted expressions:
```
/hello/
/.world/
/.*manufacturer$/
```
Limit to 50 indexes per collection as a thumb rule. Remember that even indexes will reside in the memory, thus reducing the size of your working set. Having a lot of indexes will also degrade the database write performance.
Before deleting an index, hide the index to check the performance impact of deleting the index. Hidden indexes will continue to be updated like normal indexes, but will not be used by MongoDB.
To hide an index:
```
db.collection.hideIndex("my_index_1")
```
Use $indexStats to check how well and how frequently an index is being used by MongoDB.
```
db.collection.indexStats({index: "my_index_1"})
```
Use wildcard indexes when you cannot know the schema in advance. Do not ignore indexing in such cases. In other words, use them when fields in a document can have arbitrary names that are decided at runtime.
Prefer using compound indexes over relying on index intersection.

Note

All the above points are compiled from the documentation and official MongoDB sources.

Cover image credits: EDUCBA.

Partial Indexes in MongoDB: A Brief Overview

Shreetesh M — Wed, 21 Jun 2023 12:16:30 +0000

Cover image credits: Digital Ocean

Introduction

If you have used indexes in MongoDB, then you must be knowing their importance and the huge performance gain they provide. It is part and parcel of almost every project that uses MongoDB and indexes play a vital role in improving the query execution performance.

The Problem

However, indexes don't come without cost. Indexes are generally stored in the memory, but this may not be true all the time. It may happen that your project contains many indexes or a few large indexes, and your computer's available memory may not be sufficient to accommodate all of them.

In such cases, some amount of an index is stored in the memory while the remaining part of it is stored in the storage. Storage accesses can be extremely slow compared to memory accesses. So, this can slow down your query execution.

A Solution

Partial indexes can be used to mitigate this problem to some extent.

A partial index is a space-efficient technique to index only those documents that are most frequently queried. For example, if an online book store has their customers searching for books with a rating of 3⭐ or above most of the times, then indexing only those documents with a rating of 3⭐ or above is sufficient to satisfy low latency queries for most searches. This reduces the size of the index required.

Usage

Here's how to create one, assuming that the collection name is book and genre is a field in the document's schema:

db.books.createIndex(
  { genre: 1 },
  { partialFilterExpression: { rating: { $gte: 3 } } }
)

The partialFilterExpression option can be used in any kind of index, like a single-key index, a multi-key index or even a compound index.

And here's how to make use of the index:

db.books.find({ genre: "Astronomy", rating: { $gt: 3.5 } })

Caveats

There must be a matching filter expression in the query to trigger the usage of any partial index. In the above example, the partial index will be used because the query's filter on rating will definitely result in documents that make up a proper subset of the documents that were indexed using the above createIndex() function.

If the query can result in a few documents outside the indexed ones, then the partial index will not be used, not even for the ones that can be fetched using the partial index. So, your query needs to ensure that no document outside the partial index has the slightest possibility of being scanned.

Conclusion

In essence, partial indexes can be used on documents that are queried frequently and you are not very concerned about the P90 or P99 latencies for those queries. This will help reduce the memory requirements to store the index.

Note
The intention of this post is only to make developers aware of partial indexes.

For more details, features and use cases of partial indexes, visit the official documentation for this.

Forem: Shreetesh M

10 Best Practices While Using MongoDB Indexes

Introduction

Best Practices

Note

Partial Indexes in MongoDB: A Brief Overview

Introduction

The Problem

A Solution

Usage

Caveats

Conclusion