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

Para obter mais informações sobre a cobertura do índice,consulte Query Optimization no manual do MongoDB Server .

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.

Como o MongoDB oferece suporte a esquemas dinâmicos, os aplicativos podem executar consulta dos campos cujos nomes não podem ser conhecidos antecipadamente ou são arbitrários. O MongoDB 4.2 introduziu índices curinga para ajudar a suportar essas queries. Os índices curinga não são projetados para substituir o planejamento de índice baseado em volume de trabalho.

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

Os exemplos neste guia usam a coleção movies no banco de dados sample_mflix dos conjuntos de dados de amostra do Atlas. Para aprender como criar um cluster gratuito do MongoDB Atlas e carregar os conjuntos de dados de amostra, consulte Introdução ao 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

Índices multichave são índices que melhoram o desempenho de queries em campos com valor de array. Você pode criar um índice de múltiplas chaves em uma coleção utilizando o createIndex() método e a mesma sintaxe que você utiliza para criar um índice de campo único.

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

O MongoDB Search permite realizar pesquisas de texto completo em collections hospedadas no MongoDB Atlas. Os índices de pesquisa do MongoDB especificam o comportamento da pesquisa e quais campos indexar.

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))

Para obter mais informações sobre 2índices dsphere, consulte o guia 2de índices dsphere no manual do MongoDB Server .

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