MongoDB Indexing (Day 13)

Before reading this article, I highly recommend reading the previous installments in the series:

• MongoDB - Day 1 (Introduction To MongoDB)
• MongoDB - Day 2 (Install MongoDB in Windows)
• MongoDB - Day 3 (Database Basics)
• MongoDB - Day 4 (Basics of Collection)
• MongoDB - Day 5 (Data Types in MongoDB)
• MongoDB - Day 6 (Insert Method)
• MongoDB - Day 7 (Find Method Part 1)
• MongoDB - Day 8 (Find Method Part
• MongoDB- Day 9 (Update Method)
• MongoDB- Day10 (Remove Method)
• MongoDB - Day 11 (Collection Methods)
• MongoDB - Day12 (Cursor Methods)
  

• Default Index
• Single Field Index
• Compound Index
• MultiKey Index
• Text Index
• Geospatial Index
• Hashed Index

Now to briefly describe each type of index.

Default _ID

Each MongoDB collection contains a builtin index on the _id field of the collection. This is a default index used by MongoDB. The index of the _id field contains the Unique property. In other words, we can’t insert a duplicate value into the _id field. If we don’t specify the value for the _id field then MongoDb inserts a unique value into the _id field automatically. The index of the _id field stores the data in ascending order.

Example

db.post.find({},{_id:1,Likes:1}).pretty()

In the preceding example we retrieve _id, like a field from the “post” collection. The _id in the preceding output is in ascending order.

Single Field Index

In MongoDB, we can create an index for a single field or multiple fields. To create an index on a single field, pass the name of that field with the sorting order option.

Syntax

db.Collection_Name.createIndex({field:sorting_order})

Sorting_Order

1 for sort in ascending order and -1 for sort in descending order.

Example

db.post.createIndex({Likes:1})

Output

• { Comment:1}
• {Comment:1,Title:-1}

MongoDB uses the preceding index for queries containing the following fields.

• Comment field
• Comment and Title field
• Comment and Title and PostBY field

MongoDB never uses the preceding index for queries that contain the following fields.

• Title field
• PostBY field
• Title and PostBY field

MongoDB can use the preceding index for queries that contain “Comment” and “PostBY” fields because the “Comment” field corresponds to a prefix. But this index would not be as efficient as a separate index for the “Comment” and “PostBY” fields.

MultiKey Indexes

If we create an index on a field that holds the array value, then MongoDB creates an index key for each element in the array. Multikey indexes support efficient queries against array fields. Multikey indexes can be created on an array field that contains either scalar values (in other words string or Integer) or nested documents. MongoDB automatically creates a multikey index if an indexed field is an array type. We don’t need to specify the multikey type.

Let's see an example:

In the preceding document, we have two fields that are array types. The first one is “Tags” that contain scalar values and the second is “Comment” that contains nested documents. Now we create an index for both fields.

Index for “Tags” field.
db.post.createIndex({"Tags":-1})

Index for “Comment” field.
db.post.createIndex({"Comment":1})

Compound Multikey Indexes

In the previous example, we create two indexes, one for the “Tags” field and another for the “Comment” field. But we can’t create a compound index if more than one field is the “Array” type.

Let's try to create a compound index for the “Tags” and “ Comment” fields.

db.post.createIndex({"Comment":-1,"Tags":1 })

Output
MongoDB throws an error if we execute the preceding query because MongoDB doesn’t allow creation of a compound index for multiple “Array” fields.

But we can create a compound index if at most one field is the “Array” type.

db.post.createIndex({"Comment":-1,"Title":1 })

Text Indexes

MongoDB provides the feature “Text Index” to search the string contents in the documents of a collection. The Text Index can contain any field that has a string or array of strings. A collection can have at most one text index. But we can specify multiple fields for the text index.

To create a Text Index field set the value of the “comments” parameter to “text” in the createIndex() method.

Syntax

db.Collection_Name.createIndex({comments:”text”})

Example1

db.post.createIndex({"Title":1 },{comments:"text"})

Example2

db.post.createIndex({"Title":1 ,PostBY:1},{comments:"text"})

Wildcard Text Indexes

We know that a MongoDB database consists of unstructured data, so sometimes it is difficult to predict which fields contain text type data. MongoDB provides the wildcard specifier ($**) to allow for a text search on all fields with string content. Using a wildcard index MongoDB indexes all the fields containing string or text type data.

Let us see an example:

db.post.createIndex( { "$**": "text" } )

The preceding example creates a text index using a wildcard specifier.

We can create a wildcard text index in the compound index. Let us see an example.

db.post.createIndex({"Title":1,"$**":"text"})

In the preceding example, we create a compound index. This compound index contains a “Title” field and a wildcard text index.

Geospatial Indexes

A Geospatial index is mainly used to store the location data or geospatial information. Before storing any data we must decide the type of surface. MongoDB supports two types of surfaces.

1. Spherical
   
   Calculates the geometry over a spherical surface (such as Earth) and stores location data on a spherical surface using 2dsphare.
   
   
2. Flat
   
   Calculates distance over a Euclidean and store location as legacy coordinate pairs using a 2d index.

Hashed Index

Hashed indexed entries are maintained with hashes of the values of the indexed field. The Hashing function collapses embedded documents and computes the hash for the entire value. A Hashed index supports equality queries but doesn’t support range queries and multi-key index. We can’t create a compound index for a Hashed index. However, we can create a non-hashed index (such as a single field or a compound index) and hashed index on the same field.

Syntax

db.Collection_Name.createIndex({Field:”hashed”})

Let us see an example:

db.post.createIndex({"Title":"hashed"})

In the preceding query, we created a hashed index on the “Title” field.

Index Properties

Indexes in MongoDB supports these three properties for indexes.

• Unique Index
• TTL Index
• Sparse Index

Unique Index

Unique index properties are used to restrict all the documents with a duplicate value for the indexed field or that already exists. To create a unique index, set the value of the “Unique” parameter to “true” in the createIndex method. By default the value unique is false.

Syntax

db.Collection_Name.createIndex({fieldname:sorting_order},{unique:true})

Example

Consider the following “Demo” collection. The Id field of the “Demo” collection has the following values.

db.My_Collection.find({},{_id:0})

Now we create a Unique index on the “Id” field .

db.Demo.createIndex({"Id":1},{unique:true})

Now we try to insert a duplicate value into the “Id” field.

db.Demo.insert({Id:"1"})

Output
This output shows that if we try to insert a duplicate value into the “Unique” field then MongoDB will throw an error.

TTL Indexes

TTL indexes are special types of indexes that MongoDB uses to remove documents automatically from a collection after a certain time period. This approach is very useful for machine generating data, logs, session information or storing the information for a temporary time period. To create a TTL index, use the expireAfterSeconds option with the createIndex method. In the expireAfterSeconds option we provide the time period in seconds. The TTL index does not guarantee that expired data will be deleted immediately upon expiration. There may be a delay between the time a document expires and the time that MongoDB removes the document from the database.

Syntax

db.Collection_Name.createIndex({fieldname:sorting_order},{ expireAfterSeconds:time})

Example

The Demo collection contains the following documents.

Now we create an index on the “Id” field with the expireAfterSeconds option.

db.Demo.createIndex({Name:1},{expireAfterSeconds:120 })

In the preceding example, we create an index and set the value of expireAfterSeconds to 120. In other words, MongoDB removes the document after 120 seconds.

Sparse Index

The Sparse option in an index ensures that the index only contains entries for documents that have the indexed field. It also removes documents containing null values. A non-sparse index contains all documents even if the documents don’t contain the indexed field. The index is “sparse” because it does not include all the documents of the collection.

Syntax

db.Collection_Name.createIndex({fieldname:sorting_order}, { sparse: true })

Example

The Demo collection has the following documents.
Now we create an index on the “Id” field with the sparse option.

db.Demo.createIndex({Name:1},{sparse:true })

In the preceding example, we create an index and set the value of the sparse option to true.

Basic Index Methods

Now we consider some basic index methods.

getIndexes() Method

The getIndexes() method retrieves all the existing indexes in a collection.

Syntax

db.Collection_Name.getIndexes()

Example

db.Demo.getIndexes()

Output
dropIndex() Method

The dropIndex() method removes a specific index from a collection.

Syntax

db.Collection_Name.dropIndex({Field_Name})

Example

db.Demo.dropIndex({"Id":1})

Output

{ "nIndexesWas" : 3, "ok" : 1 }

In the preceding output, “nIndexesWas” reflects the number of indexes before removing this index and “ok” execution status of command.

ensureIndex() Method

The ensureIndex() method creates an index. The ensureIndex() method only creates an index if an index of the same specification does not already exist.

Syntax

db.Collection_Name.ensureIndex({field_name:sorting_order})

Example

db.Demo.ensureIndex({"Id":1})

reIndex() Method

The reIndex() method rebuilds the indexes for a collection. The reIndex() method first drops all the indexes, then rebuilds all the indexes.

Syntax

db.Collection_Name.reIndex()

Example

db.Demo.reIndex()

Output
Indexes.find() Method

The indexes.find() method returns a list of all indexes on all collections of a database.

Syntax

db.system.indexes.find()

Example

db.system.indexes.find()

Output
Today we learned about indexes, their types and some basic methods for indexes. In the next article we will learn about Aggregation.