Indexes

Query Coverage and Performance

When you execute a query against MongoDB, your query can include three parts:

• Query criteria that specify one or more fields and values that you are looking for

• Options that affect the query's execution, such as read concern

• Projection criteria to specify the fields you want MongoDB to return (optional)

When all the fields specified in the query criteria and projection of a query are indexed, MongoDB returns results directly from the index without scanning any documents in the collection or loading them into memory.

For more information on how to ensure your index covers your query criteria and projection, see the MongoDB manual articles on query coverage and index intersection.

Operational Considerations

To improve query performance, build indexes on fields that appear often in your application's queries and operations that return sorted results. Each index that you add consumes disk space and memory when active, so it might be necessary to track index memory and disk usage for capacity planning. In addition, when a write operation updates an indexed field, MongoDB also updates the related index.

For more information on designing your data model and choosing indexes appropriate for your application, see the MongoDB Server documentation on Indexing Strategies and Data Modeling and Indexes.

List Indexes

You can use the listIndexes() method to list all the indexes for a collection. The listIndexes() method takes an optional ListIndexesOptions parameter. The listIndexes() method returns an object of type ListIndexesCursor.

The following code uses the listIndexes() method to list all the indexes in a collection:

// List the indexes on the collection and output them as an array
const result = await collection.listIndexes().toArray();
// Print the list of indexes
console.log("Existing indexes:\n");
for(const doc in result){
    console.log(doc);
}

Single Field Indexes

Single field indexes are indexes that improve performance for queries that specify ascending or descending sort order on a single field of a document.

The following example uses the createIndex() method to create an ascending order index on the title field in the movies collection in the sample_mflix database.

const database = client.db("sample_mflix");
const movies = database.collection("movies");
// Create an ascending index on the "title" field in the
// "movies" collection.
const result = await movies.createIndex({ title: 1 });
console.log(`Index created: ${result}`);

The following is an example of a query that is covered by the index created above.

// Define the query parameters
const query = { title: "Batman" }
const sort = { title: 1 };
const projection = { _id: 0, title: 1 };
// Execute the query using the defined parameters
const cursor = movies
  .find(query)
  .sort(sort)
  .project(projection);

To learn more, see Single Field Indexes.

Compound Indexes

Compound indexes are indexes that improve performance for queries that specify ascending or descending sort order for multiple fields of a document. You must specify the direction (ascending or descending) for each field in the index.

The following example uses the createIndex() method to create a compound index on the type and genre fields in the movies collection in the sample_mflix database.

// Connect to the "sample_mflix" database
const database = client.db("sample_mflix");
// Access the database's "movies" collection
const movies = database.collection("movies");
// Create an ascending index on the "type" and "genre" fields
// in the "movies" collection.
const result = await movies.createIndex({ type: 1, genre: 1 });
console.log(`Index created: ${result}`);

The following is an example of a query that is covered by the index created above.

// Define a query to find movies in the "Drama" genre
const query = { type: "movie", genre: "Drama" };
// Define sorting criteria for the query results
const sort = { type: 1, genre: 1 };
// Include only the type and genre fields in the query results
const projection = { _id: 0, type: 1, genre: 1 };
// Execute the query using the defined criteria and projection
const cursor = movies
  .find(query)
  .sort(sort)
  .project(projection);

To learn more, see Compound Indexes.

Multikey Indexes (Indexes on Array Fields)

Multikey indexes are indexes that improve the performance of queries on fields that contain array values.

You can create a multikey index on a field with an array value by calling the createIndex() method. The following code creates an ascending index on the cast field in the movies collection of the sample_mflix database:

const database = client.db("sample_mflix");
const movies = database.collection("movies");
// Create a multikey index on the "cast" field in the "movies" collection
const result = await movies.createIndex({ cast: 1 });

The following code queries the multikey index to find documents in which the cast field value contains "Viola Davis":

const query = { cast: "Viola Davis" };
const projection = { _id: 0, cast: 1 , title: 1 };
// Perform a find operation with the preceding filter and projection
const cursor = movies
  .find(query)
  .project(projection);

Multikey indexes behave differently from non-multikey indexes in terms of query coverage, index bound computation, and sort behavior. For a full explanation of multikey indexes, including a discussion of their behavior and limitations, see the Multikey Indexes page in the MongoDB Server manual.

Clustered Indexes

Clustered indexes are indexes that improve the performance of insert, update, and delete operations on clustered collections. Clustered collections store documents ordered by the clustered index key value.

To create a clustered index, specify the clusteredIndex option in the CollectionOption. The clusteredIndex option must specify the _id field as the key and the unique field as true.

The following example uses the createCollection() method to create a clustered index on the _id field in the vendors collection of the tea database.

const db = client.db('tea');
await db.createCollection('ratings', {
  clusteredIndex: {
    key: { _id: 1 },
    unique: true
  }
});

To learn more, see Clustered Indexes and Clustered Collections.

Text Indexes

Text indexes support text search queries on string content. These indexes can include any field whose value is a string or an array of string elements.

MongoDB supports text search for various languages, so you can specify the default language as an option when creating the index. You can also specify a weight option to prioritize certain text fields in your index. These weights denote the significance of fields relative to the other indexed fields.

To learn more about text searches, see our guide on text search queries.

The following example uses the createIndex() method to perform the following actions:

• Create a text index on the title and body fields in the blogPosts collection

• Specify english as the default language

• Set the field weight of body to 10 and title to 3

// Get the database and collection on which to create the index 
const myDB = client.db("testDB");
const myColl = myDB.collection("blogPosts");
// Create a text index on the "title" and "body" fields
const result = await myColl.createIndex(
  { title: "text", body: "text" },
  { default_language: "english" },
  { weights: { body: 10, title: 3 } }
);

The following query uses the text index created in the preceding code:

// Query for documents where body or title contain "life ahead"
const query = { $text: { $search: "life ahead" } };
// Show only the title field
const projection = { _id: 0, title: 1 };
// Execute the find operation
const cursor = myColl.find(query).project(projection);

To learn more about text indexes, see Text Indexes in the Server manual.

Geospatial Indexes

MongoDB supports queries of geospatial coordinate data using 2dsphere indexes. With a 2dsphere index, you can query the geospatial data for inclusion, intersection, and proximity. For more information on querying geospatial data with the MongoDB Node.js driver, read our Search Geospatial guide.

To create a 2dsphere index, you must specify a field that contains only GeoJSON objects. For more details on this type, see the MongoDB Server manual page on GeoJSON objects.

The location.geo field in following sample document from the theaters collection in the sample_mflix database is a GeoJSON Point object that describes the coordinates of the theater:

{
   "_id" : ObjectId("59a47286cfa9a3a73e51e75c"),
   "theaterId" : 104,
   "location" : {
      "address" : {
         "street1" : "5000 W 147th St",
         "city" : "Hawthorne",
         "state" : "CA",
         "zipcode" : "90250"
      },
      "geo" : {
         "type" : "Point",
         "coordinates" : [
            -118.36559,
            33.897167
         ]
      }
   }
}

The following example uses the createIndexes() method to create a 2dsphere index on the location.geo field in the theaters collection in the sample_mflix database to enable geospatial searches.

const database = client.db("sample_mflix");
const movies = database.collection("movies");
/* Create a 2dsphere index on the "location.geo" field in the
"movies" collection */
const result = await movies.createIndex({ "location.geo": "2dsphere" });
// Print the result of the index creation
console.log(`Index created: ${result}`);

MongoDB also supports 2d indexes for calculating distances on a Euclidean plane and for working with the "legacy coordinate pairs" syntax used in MongoDB 2.2 and earlier. To learn more, see Geospatial Queries.

Unique Indexes

Unique indexes ensure that the indexed fields do not store duplicate values. By default, MongoDB creates a unique index on the _id field during the creation of a collection. To create a unique index, specify the field or combination of fields that you want to prevent duplication on and set the unique option to true.

The following example uses the createIndex() method to create a unique index on the theaterId field in the theaters collection of the sample_mflix database.

const database = client.db("sample_mflix");
const movies = database.collection("movies");
// Create a unique index on the "theaterId" field in the "theaters" collection.
const result = await movies.createIndex({ theaterId: 1 }, { unique: true });
console.log(`Index created: ${result}`);

If you attempt to perform a write operation that stores a duplicate value that violates the unique index, MongoDB will throw an error that resembles the following:

E11000 duplicate key error index

To learn more, see Unique Indexes.

Create a Search Index

You can use the createSearchIndex() and createSearchIndexes() methods to create new Search indexes.

The following code shows how to use the createSearchIndex() method to create an index called search1:

// Create a search index
const index1 = {
    name: "search1",
    definition: {
        "mappings": {
            "dynamic": true
        }
    }
}
await collection.createSearchIndex(index1);

When connecting to MongoDB Server v6.0.11 and later v6 versions, or v7.0.2 and later v7 versions, you can use the driver to create an Atlas Vector Search index on a collection. Learn more about this feature in the Atlas Vector Search documentation.

The following code shows how to use the createSearchIndex() method to create a search index in which the type field is vectorSearch:

// Create a Vector Search index
const vectorSearchIdx = {
    name: "vsidx1",
    type: "vectorSearch",
    definition: {
        fields: [{
            type: "vector",
            numDimensions: 384,
            path: "summary",
            similarity: "dotProduct"
        }]
    }
}
await collection.createSearchIndex(vectorSearchIdx);

List Search Indexes

You can use the listSearchIndexes() method to return a cursor that contains the Search indexes of a given collection. The listSearchIndexes() method takes an optional string parameter, name, to return only the indexes with matching names. It also takes an optional aggregateOptions parameter.

The following code uses the listSearchIndexes() method to list the Search indexes in a collection:

// List search indexes
const result = await collection.listSearchIndexes().toArray();
console.log("Existing search indexes:\n");
for (const doc in result) {
    console.log(doc);
}

Update a Search Index

You can use the updateSearchIndex() method to update a Search index.

The following code shows how to use the updateSearchIndex() method to update an index called search1 to specify a string type for the description field:

// Update a search index
const index2 = {
    "mappings": {
        "dynamic": true,
        "fields": {
            "description": {
                "type": "string"
            }
        }
    }
}
await collection.updateSearchIndex("search1", index2);

Drop a Search Index

You can use the dropSearchIndex() method to remove a Search index.

The following code shows how to use the dropSearchIndex() method to remove an index called search1:

// Dropping (deleting) a search index
await collection.dropSearchIndex("search1");