Docs Menu
Docs Home
/ / /
Scala
/

Compound Indexes

On this page

  • Overview
  • Sample Data
  • Create a Compound Index
  • Additional Information
  • API Documentation

Compound indexes hold references to multiple fields within a collection's documents, improving query and sort performance.

When creating a compound index, you must specify the following details:

  • The fields on which to create the index

  • The sort order for each field (ascending or descending)

The examples in this guide use the movies collection in the sample_mflix database from the Atlas sample datasets. To access this collection from your Scala application, create a MongoClient that connects to an Atlas cluster and assign the following values to your database and collection variables:

val database: MongoDatabase = mongoClient.getDatabase("sample_mflix")
val collection: MongoCollection[Document] = database.getCollection("movies")

To learn how to create a free MongoDB Atlas cluster and load the sample datasets, see the Get Started with Atlas guide.

To run the examples in this guide, you must include the following import statements in your file:

import org.mongodb.scala._
import org.mongodb.scala.model.Indexes
import org.mongodb.scala.model.IndexOptions._
import org.mongodb.scala.model.Filters._
import scala.concurrent.Await
import scala.concurrent.duration._
import scala.util.{Failure, Success}
import java.util.concurrent.TimeUnit

Use the createIndex() method to create a compound index. The following example creates an index in descending order on the runtime field and in ascending order on the year field:

val index = Indexes.compoundIndex(Indexes.descending("runtime"),
Indexes.ascending("year"))
val observable = collection.createIndex(index)
Await.result(observable.toFuture(), Duration(10, TimeUnit.SECONDS))

You can verify that the index was created by using the listIndexes() method. You should see an index for runtime and year in the list, as shown in the following output:

collection.listIndexes().subscribe((doc: Document) => println(doc.toJson()),
(e: Throwable) => println(s"There was an error: $e"))
{"v": 2, "key": {"runtime": -1, "year": 1}, "name": "runtime_-1_year_1"}

The following is an example of a query that is covered by the index created on the runtime and year fields:

val filter = and(gt("runtime", 80), gt("year", 1999))
collection.find(filter).first().subscribe((doc: Document) => println(doc.toJson()),
(e: Throwable) => println(s"There was an error: $e"))
{"_id":...,"runtime": 98,...,"title": "In the Mood for Love",...,"year": 2000,...}

To learn more about compound indexes, see Compound Indexes in the MongoDB Server manual.

To view runnable examples that demonstrate how to manage indexes, see Optimize Queries by Using Indexes.

To learn more about any of the methods discussed in this guide, see the following API documentation:

Back

Single Field