Optimiza las consultas utilizando índices

Cobertura y rendimiento de la query

Cuando ejecuta una query en MongoDB, su comando puede incluir los siguientes elementos:

• Criterios de consulta que especifican los campos y valores que buscas

• Opciones que afectan la ejecución de la consulta, como el nivel de consistencia de lectura

• Criterios de proyección que especifican los campos que MongoDB devuelve (opcional)

• Criterios de orden para especificar el orden de los documentos devueltos (opcional)

Cuando todos los campos de la query, la proyección y la ordenación están en el mismo índice, MongoDB devuelve los resultados del índice. Este proceso se denomina query cubierta.

name_1_age_-1

Para obtener más información sobre la cobertura del índice, consulte Optimización de consultas en el manual de MongoDB Server.

Consideraciones operativas

Las siguientes pautas describen cómo puedes optimizar la forma en que tu aplicación utiliza los índices:

• Para mejorar el rendimiento de las consultas, crea índices en los campos que aparecen con mayor frecuencia en las consultas de tu aplicación y en las operaciones que devuelven resultados ordenados.

• Rastrea el uso de memoria y disco del índice para la planificación de la capacidad, ya que cada índice que añades consume espacio en disco y memoria cuando está activo.

• Evite añadir índices que utilice con poca frecuencia. Tenga en cuenta que cuando una operación de escritura actualiza un campo indizado, MongoDB actualiza el índice relacionado.

Dado que MongoDB brinda soporte a esquemas dinámicos, las aplicaciones pueden realizar queries contra campos cuyos nombres no se pueden conocer de antemano o son arbitrarios. MongoDB 4.2 introdujo índices comodín para ayudar a respaldar estas consultas. Los índices comodín no están diseñados para reemplazar la planificación de índices basada en cargas de trabajo.

Para obtener más información sobre cómo diseñar su modelo de datos y elegir índices apropiados para su aplicación, consulte la documentación del servidor MongoDB sobre Estrategias de indexación y Modelado de datos e índices.

Aplicación de muestra

Puedes usar la siguiente aplicación de muestra para probar el código en esta página. Para usar la aplicación de muestra, realice los siguientes pasos:

1. Asegúrate de tener instalado el driver de Scala en tu proyecto. Consulta la guía Descargar e Instalar para aprender más.

2. Copia el siguiente código y pégalo en un nuevo archivo .scala.

3. Copia un ejemplo de código de esta página y pégalo en las líneas especificadas del archivo.

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

Datos de muestra

Los ejemplos de esta guía utilizan la colección movies en la base de datos sample_mflix de los conjuntos de datos de ejemplo de Atlas. Para aprender cómo crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulta Comienza con Atlas.

Índices de un solo campo

Índices de campo único son índices con una referencia a un solo campo dentro de los documentos de una colección. Mejoran el rendimiento de las queries de campo único y de la ordenación, y admiten Índices TTL que remueven automáticamente documentos de una colección tras un período de tiempo determinado o en un horario definido.

El siguiente ejemplo crea un índice ascendente en el campo especificado:

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

Para ejecutar los siguientes ejemplos en esta sección, debe incluir las siguientes instrucciones de importación en su archivo:

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

Utiliza el método createIndex() para crear un índice de campo único. El siguiente ejemplo crea un índice en orden ascendente en el campo title:

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

Puedes verificar que se creó el índice utilizando el método listIndexes(). Deberías ver un índice para title en la lista, como se muestra en la siguiente salida:

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

A continuación, se muestra un ejemplo de una query que está cubierta por el índice creado en el 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 compuestos

Los índices compuestos contienen referencias a múltiples campos dentro de los documentos de una colección, mejorando la query y el rendimiento de clasificación.

El siguiente ejemplo crea un índice compuesto en los dos 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 ejecutar los siguientes ejemplos en esta sección, debe incluir las siguientes instrucciones de importación en su archivo:

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

Utilice el método createIndex() para crear un índice compuesto. El siguiente ejemplo crea un índice en orden descendente en el campo runtime y en orden ascendente en el 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))

Puedes verificar que el índice fue creado utilizando el método listIndexes(). Debería ver un índice para runtime y year en la lista, como se muestra en la siguiente salida:

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

A continuación se muestra un ejemplo de una query que está cubierta por el índice creado en los campos runtime y 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

Los índices multiclave son índices que mejoran el rendimiento de las queries en campos con valores de arreglo. Puede crear un índice multiclave en una colección utilizando el método createIndex() y la misma sintaxis que utiliza para crear un índice de un solo campo.

Al crear un índice multiclave, debes especificar los siguientes detalles:

• Los campos sobre los que crear el índice

• El orden de clasificación para cada campo (ascendente o descendente)

El siguiente ejemplo crea un índice de varias claves en el campo especificado que tiene valores de arreglo:

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

Para ejecutar los siguientes ejemplos en esta sección, debe incluir las siguientes instrucciones de importación en su archivo:

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

Utiliza el método createIndex() para crear un índice múltiple. El siguiente ejemplo crea un índice en orden ascendente en el campo cast:

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

Puedes verificar que el índice se creó llamando al método listIndexes(). Deberías ver un índice para cast en la lista, como se muestra en la siguiente salida:

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

A continuación, se muestra un ejemplo de una query que está cubierta por el índice creado en el 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"],...}

MongoDB Search e MongoDB Vector Search Indexes

MongoDB Search te permite realizar búsquedas de texto completo en colecciones alojadas en MongoDB Atlas. Los índices de búsqueda de MongoDB Search especifican el comportamiento de la búsqueda y cuáles campos indexar.

MongoDB Vector Search permite realizar búsquedas semánticas en incrustaciones vectoriales almacenadas en MongoDB. Para obtener más información sobre MongoDB Vector Search, consulte la Descripción general de MongoDB Vector Search.

Puedes llamar a los siguientes métodos en una colección para gestionar tus índices de MongoDB Search y 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 geoespaciales

El siguiente ejemplo crea un 2índice dsphere en el campo especificado que contiene objetos GeoJSON:

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

Para obtener más información sobre índices 2dsphere, consulte la guía de índices2dsphere en el manual de MongoDB Server.

Para obtener más información sobre el tipo GeoJSON, consulta la guía de Objetos GeoJSON en el manual de MongoDB Server.