Otimizar consultas usando índices

Cobertura e desempenho da query

Quando você executa uma query no MongoDB, seu comando pode incluir os seguintes elementos:

• Critérios de query que especificam campos e valores que você está procurando

• Opções que afetam a execução da query, como a read concern

• Critérios de projeção que especificam os campo que o MongoDB retorna (opcional)

• Critérios de classificação que especificam a ordem em que os documento são retornados (opcional)

Quando todos os campos na query, projeção e classificação estão no mesmo índice, o MongoDB retorna resultados do índice. Esse processo é chamado de query coberta.

name_1_age_-1

For more information about index coverage, see Query Optimization in the MongoDB Server manual.

Considerações operacionais

As diretrizes a seguir descrevem como você pode otimizar a forma como seu aplicativo usa índices:

• Para melhorar o desempenho da query, crie índices em campos que aparecem com frequência nas queries e operações do seu aplicativo que retornam resultados ordenados.

• Acompanhe a memória do índice e o uso do disco para o planejamento da capacidade, pois cada índice adicionado consome espaço em disco e memória quando ativo.

• Evite adicionar índices que você usa com pouca frequência. Observe que quando uma operação de gravação atualiza um campo indexado, o MongoDB atualiza o índice relacionado.

Since MongoDB supports dynamic schemas, applications can query against fields whose names cannot be known in advance or are arbitrary. MongoDB 4.2 introduced wildcard indexes to help support these queries. Wildcard indexes are not designed to replace workload-based index planning.

Para obter mais informações sobre como projetar seu modelo de dados e escolher índices apropriados para seu aplicativo, consulte a documentação do servidor MongoDB sobre Estratégias de indexação e Modelagem de dados e índices.

Aplicativo de amostra

Você pode usar o seguinte aplicação de amostra para testar o código nesta página. Para usar o aplicação de amostra , execute as seguintes etapas:

1. Verifique se você tem o driver Scala instalado em seu projeto. Consulte o guia Download e instalação para saber mais.

2. Copie o seguinte código e cole-o em um novo arquivo .scala .

3. Copie um exemplo de código desta página e cole-o nas linhas especificadas no arquivo.

import org.mongodb.scala._
import org.mongodb.scala.model.SearchIndexModel
import java.util.concurrent.TimeUnit
import scala.concurrent.Await
import scala.concurrent.duration.Duration
import org.mongodb.scala.model.Indexes
object SearchIndexes {
  def main(args: Array[String]): Unit = {
    // Create a new client and connect to the server
    val mongoClient = MongoClient("<connection string URI>")
    val database = mongoClient.getDatabase("<database name>")
    val collection = database.getCollection("<collection name>")
    // Start example code here
    
    // End example code here
    Thread.sleep(1000)
    mongoClient.close()
  }
}

Dados de amostra

The examples in this guide use the movies collection in the sample_mflix database from the Atlas sample datasets. To learn how to create a free MongoDB Atlas cluster and load the sample datasets, see Get Started with Atlas.

Índices de campo único

Os índices de campo único são índices com uma referência a um único campo dentro dos documentos de uma coleção. Eles melhoram o desempenho da consulta de campo único e da classificação e oferecem suporte a índices TTL que removem automaticamente documentos de uma coleção após um determinado período de tempo ou em um horário específico.

O exemplo seguinte cria um índice ascendente no campo especificado:

val index = Indexes.ascending("<field name>")
val observable = collection.createIndex(index)
Await.result(observable.toFuture(), Duration(10, TimeUnit.SECONDS))

Para executar os exemplos a seguir nesta seção, você deve incluir as seguintes declarações de importação em seu arquivo:

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

Utilize o método createIndex() para criar um índice de campo único. O exemplo seguinte cria um índice em ordem crescente no campo title :

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

Você pode verificar se o índice foi criado usando o método listIndexes(). Você deve ver um índice para title na lista, conforme mostrado na seguinte saída:

collection.listIndexes().subscribe((doc: Document) => println(doc.toJson()),
                        (e: Throwable) => println(s"There was an error: $e"))

{"v": 2, "key": {"title": 1}, "name": "title_1"}

O seguinte é um exemplo de uma query coberta pelo índice criado no campo title :

val filter = equal("title", "Sweethearts")
collection.find(filter).first().subscribe((doc: Document) => println(doc.toJson()),
                        (e: Throwable) => println(s"There was an error: $e"))

{"_id":...,"plot":"A musical comedy duo...",
"genres":["Musical"],...,"title":"Sweethearts",...}

Índices compostos

Os índices compostos contêm referências a vários campos nos documentos de uma coleção, melhorando o desempenho de consulta e classificação.

O exemplo seguinte cria um índice composto nos dois campos especificados.

val index = Indexes.compoundIndex(
    Indexes.descending("<field name 1>"), 
    Indexes.ascending("<field name 2>")
)
val observable = collection.createIndex(index)
Await.result(observable.toFuture(), Duration(10, TimeUnit.SECONDS))

Para executar os exemplos a seguir nesta seção, você deve incluir as seguintes declarações de importação em seu arquivo:

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

Utilize o método createIndex() para criar um índice composto. O exemplo a seguir cria um índice em ordem decrescente no campo runtime e em ordem crescente no campo year :

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

Você pode verificar se o índice foi criado usando o método listIndexes(). Você deve ver um índice para runtime e year na lista, conforme mostrado na seguinte saída:

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"}

O seguinte é um exemplo de uma consulta coberta pelo índice criado nos campos runtime e year :

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,...}

Multikey Indexes

Multikey indexes are indexes that improve the performance of queries on array-valued fields. You can create a multikey index on a collection by using the createIndex() method and the same syntax that you use to create a single field index.

Ao criar um índice de múltiplas chaves, você deve especificar os seguintes detalhes:

• Os campos nos quais criar o índice

• A ordem de classificação para cada campo (crescente ou decrescente)

O exemplo a seguir cria um índice de múltiplas chaves no campo com valor de array especificado:

val index = Indexes.ascending("<field name>")
val observable = collection.createIndex(index)
Await.result(observable.toFuture(), Duration(10, TimeUnit.SECONDS))

Para executar os exemplos a seguir nesta seção, você deve incluir as seguintes declarações de importação em seu arquivo:

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

Utilize o método createIndex() para criar um índice de múltiplas chaves. O exemplo seguinte cria um índice em ordem crescente no campo cast :

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

Você pode verificar se o índice foi criado chamando o método listIndexes(). Você deve ver um índice para cast na lista, conforme mostrado na seguinte saída:

collection.listIndexes().subscribe((doc: Document) => println(doc.toJson()),
                        (e: Throwable) => println(s"There was an error: $e"))

{"v": 2, "key": {"cast": 1}, "name": "cast_1"}

O seguinte é um exemplo de uma query coberta pelo índice criado no campo cast :

val filter = and(equal("cast", "Aamir Khan"), equal("cast", "Kajol"))
collection.find(filter).first().subscribe((doc: Document) => println(doc.toJson()),
                        (e: Throwable) => println(s"There was an error: $e"))

{"_id":...,"title":"Fanaa",...,"cast": ["Aamir Khan", "Kajol", "Rishi Kapoor", "Tabu"],...}

Índices de Pesquisa do MongoDB e Índices de Pesquisa Vetorial do MongoDB

MongoDB Search enables you to perform full-text searches on collections hosted on MongoDB Atlas. MongoDB Search indexes specify the behavior of the search and which fields to index.

A MongoDB Vector Search permite que você realize uma pesquisa semântica em vetores incorporados armazenados no MongoDB. Para saber mais sobre o MongoDB Vector Search, consulte a Visão geral do MongoDB Vector Search.

Você pode chamar os seguintes métodos em uma coleção para gerenciar seus índices MongoDB Search e MongoDB Vector Search :

• createSearchIndex()

• createSearchIndexes()

• listSearchIndexes()

• updateSearchIndex()

• dropSearchIndex()

val index = Document("mappings" -> Document("dynamic" -> true))
collection.createSearchIndex("<index name>", index)
          .subscribe((result: String) => ())

val searchIdxMdl = SearchIndexModel(
  Option("searchIdx"),
  Document("analyzer" -> "lucene.standard", "mappings" -> Document("dynamic" -> true)),
  Option(SearchIndexType.search())
)
val vectorSearchIdxMdl = SearchIndexModel(
  Option("vsIdx"),
  Document(
    "fields" -> List(
      Document("type" -> "vector", "path" -> "embeddings", "numDimensions" -> 1536, "similarity" -> "dotProduct")
    )
  ),
  Option(SearchIndexType.vectorSearch())
)
collection.createSearchIndexes(List(searchIdxMdl, vectorSearchIdxMdl))
          .subscribe((result: String) => ())

collection.listSearchIndexes()
          .subscribe((result: Document) => println(result.toJson()))

{"id": "...", "name": "<index name 1>", "type": "search", "status": "READY", "queryable": true, ... }
{"id": "...", "name": "<index name 2>", "type": "search", "status": "READY", "queryable": true, ... }

val updateIndex = Document("mappings" -> Document("dynamic" -> false))
collection.updateSearchIndex("<index to update>", updateIndex)
          .subscribe((result: Unit) => ())

collection.dropSearchIndex("<index name>")
          .subscribe((result: Unit) => ())    

Índices geoespaciais

O exemplo seguinte cria um índice dsphere do 2no campo especificado que contém objetos GeoJSON:

val observable = collection.createIndex(Indexes.geo2dsphere("<2d index>"))
Await.result(observable.toFuture(), Duration(10, TimeUnit.SECONDS))

For more information on 2dsphere indexes, see the 2dsphere Indexes guide in the MongoDB Server manual.

Para obter mais informações sobre o tipo GeoJSON, consulte o guia Objetos GeoJSON no manual do MongoDB Server .