Type of Indexes

Introduction

Indexing in MongoDB is a method used to enhance the speed and efficiency of data queries. It revolves around the creation of indexes, which are data structures storing a condensed version of the data in a more efficient format. These indexes enable MongoDB to swiftly locate and retrieve data.

Analogous to indexes in a book, MongoDB indexes act as rapid references that guide the system to the specific location of desired information. By leveraging indexes, MongoDB can quickly identify and retrieve relevant data, resulting in improved query performance.

Let's consider an example to gain a better understanding of indexing in MongoDB:

Imagine we have a collection named "books" that stores documents representing various books. Each document contains fields such as "title," "author," "genre," and "year."

In the absence of an index, if we wanted to find all books written by a specific author, MongoDB would have to examine each document in the collection, comparing the author field to the given value. This process can become time-consuming, particularly as the collection grows larger.

However, by creating an index on the "author" field, MongoDB constructs a data structure that maps author values to the corresponding locations of documents. This enables MongoDB to rapidly locate and retrieve the documents that match the specified author.

To create an index on the "author" field within the "books" collection, we can employ the createIndex() method:

What Are the Different Types of Indexes?

Single Field Indexes

Syntax

To illustrate the concept of a single field index in MongoDB, let's take an example. Imagine we have a collection named "products" that stores documents representing various products. Each document has fields like "name," "category," "price," and "quantity."

To improve query performance, we can create a single field index on the "name" field within the "products" collection. This can be done using the createIndex() method provided by MongoDB.

By creating an index on the "name" field, MongoDB builds a data structure that maps the "name" values to the corresponding document locations. This allows for fast and efficient retrieval of documents based on the indexed field.

For instance, consider the following index creation syntax on the collection "products":

In this case, we use the createIndex() method to create a single field index on the "name" field in ascending order (indicated by the value 1).

Compound Indexes

In MongoDB, a compound index enables the indexing of multiple fields together within a collection, leading to enhanced query performance for queries involving multiple fields. Let's consider an example to better understand how a compound index can be used.

Syntax

Imagine we have a collection named "products" that stores documents representing different products. Each document contains fields like "name", "category", "price", and "quantity".

To illustrate the usage of a compound index, let's create an index on the "price" and "category" fields in the "products" collection:

In this example, we employ the createIndex() method to create a compound index on the "category" and "price" fields. The value 1 denotes an ascending order for both fields. MongoDB constructs a compound index by combining the values of the indexed fields and mapping them to their corresponding document locations.

Multikey Indexes

A multikey index in MongoDB enables the indexing of array fields within documents, facilitating efficient retrieval and querying based on array values. It accomplishes this by creating individual index entries for each element in the array, linking them to the respective document locations. As a result, accessing and querying documents based on array values becomes faster and more streamlined.

Syntax

Let's use the "products" collection example to explain multikey indexes:

Assuming you have a collection called "products" with documents containing fields like "name," "price," "quantity," and "category," where "category" is an array field containing multiple categories for each product:

In this example, we use the createIndex() method to create a multikey index on the "category" field in the "products" collection. The value 1 indicates ascending order.

A multikey index allows you to index array fields, such as the "category" field in this case. When you create a multikey index, MongoDB will extract each category value from the "category" array in each document and map it to the corresponding document locations.

Geospatial Indexes and Queries

Geospatial indexes and queries in MongoDB offer an efficient solution for storing, indexing and retrieving location-based data. These features are especially valuable when dealing with geographical coordinates, like latitude and longitude, and performing tasks such as proximity searches or spatial analysis.

Syntax

To grasp the concept of geospatial indexes and queries, let's explore an example involving a collection named "locations." This collection stores documents that represent different points of interest, including fields like "name," "location," and "type."

1. Creating a Geospatial Index:

To create a geospatial index on the "location" field in the "locations" collection, you can use the createIndex() method with the "2dsphere" index type:

This creates a geospatial index on the "location" field, enabling efficient querying of the spatial data.

2. Inserting Documents:

Let's insert some sample documents into the "locations" collection:

In this example, we insert three documents representing different locations, each having a "name," "location" (specified as a "Point" with coordinates), and "type" (e.g., "Park" or "Landmark").

3. Performing Geospatial Queries:
Now, let's perform geospatial queries to find nearby locations based on a given point. For instance, to find all locations within a certain distance from a specific longitude and latitude, you can use the $nearSphere operator along with the $geometry and $maxDistance parameters:

In this query, we search for locations within a 1000-meter radius from the specified longitude and latitude. MongoDB uses the geospatial index to efficiently retrieve and rank the matching locations based on proximity.

These geospatial queries enable you to find nearby locations, calculate distances, perform polygonal searches, and more, based on the geospatial information stored in the collection.

Text Index

A text index in MongoDB is a specialized index type that allows for an efficient full-text search of textual data within a collection. It enables searching for words, phrases, or even complex queries across one or more text fields in documents.

Syntax

To create a text index, you need to specify the text index type on one or more fields of the collection. MongoDB will tokenize and stem the text data to build an index that facilitates quick text-based searches.

Here's an example to illustrate the usage of a text index:

Consider a collection named "articles" that stores documents representing different articles. Each document contains fields like "title" and "content."

To create a text index on the "title" and "content" fields within the "articles" collection, you can use the createIndex() method with the "text" index type:

This command creates a text index on the "title" and "content" fields, enabling efficient text-based searches on those fields.

Now, you can perform text searches using the $text operator. For example, to find articles containing the word "database" in either the title or content fields, you can use the following query:

This query will return all articles that match the search term "database" in the indexed fields.

Text indexes support advanced features like stemming, language-specific stop words, and relevance scoring, which allows you to sort and rank the search results based on relevance.

Hash Index

A hash index in MongoDB is utilized to store entries containing the hashed values of the indexed field. It is frequently employed for the _id field across all collections and plays a crucial role in ensuring balanced data distribution, especially in sharded cluster environments. The hashing mechanism employed allows for the effective partitioning of data across shards, contributing to improved scalability and performance.

Syntax

In the syntax above, replace "collection" with the name of your collection. By specifying "hashed" as the index type for the _id field, MongoDB will create a hash index that helps partition the data across the sharded cluster.

The hashed keys generated by the index ensure an even distribution of documents across the shards, allowing for better performance and scalability when working with sharded environments.

Starting from MongoDB version 4.4, it is now possible to use compound hashed indexes.