Indexes

Cobertura y rendimiento de la query

Cuando ejecutas una query en MongoDB, tu comando puede incluir varios elementos:

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

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

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

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

Cuando todos los campos especificados en la query, proyección y orden están en el mismo índice, MongoDB devuelve los resultados directamente desde el índice, también llamado consulta cubierta.

name_1_age_-1

Para obtener más información sobre cómo garantizar que tu índice cubra tus criterios de query y proyección, consulta los artículos del manual del servidor sobre cobertura de la query.

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.

Índices de un solo campo e índices compuestos

val resultCreateIndex = moviesCollection.createIndex(Indexes.ascending(Movie::title.name))
println("Index created: $resultCreateIndex")

Index created: title_1

val filter = Filters.eq(Movie::title.name, "The Dark Knight")
val sort = Sorts.ascending(Movie::title.name)
val projection = Projections.fields(
    Projections.include(Movie::title.name),
    Projections.excludeId()
)
data class Results(val title: String)
val resultsFlow = moviesCollection.find<Results>(filter).sort(sort).projection(projection)
resultsFlow.collect { println(it) }

val resultCreateIndex = moviesCollection.createIndex(Indexes.ascending(Movie::type.name, Movie::rated.name))
println("Index created: $resultCreateIndex")

Index created: type_1_rated_1

val filter = Filters.and(
    Filters.eq(Movie::type.name, "movie"),
    Filters.eq(Movie::rated.name, "G")
)
val sort = Sorts.ascending(Movie::type.name, Movie::rated.name)
val projection = Projections.fields(
    Projections.include(Movie::type.name, Movie::rated.name),
    Projections.excludeId()
)
val resultsFlow = moviesCollection.find(filter).sort(sort).projection(projection)
resultsFlow.collect { println(it) }

Índices multiclave (índices en campos de arreglos)

Los índices multiclave son índices que mejoran el rendimiento de las queries que especifican un campo con un índice que contiene un valor de arreglo. Puedes definir un índice multiclave utilizando la misma sintaxis que un índice de campo único o compuesto.

El siguiente ejemplo crea un índice compuesto de varias claves en los campos rated, genres (un arreglo de cadenas de texto) y title:

val resultCreateIndex =
    moviesCollection.createIndex(Indexes.ascending(Movie::rated.name, Movie::genres.name, Movie::title.name))
println("Index created: $resultCreateIndex")

Index created: rated_1_genres_1_title_1

El siguiente es un ejemplo de una query que está cubierta por el índice creado en el snippet de código anterior:

val filter = Filters.and(
    Filters.eq(Movie::genres.name, "Animation"),
    Filters.eq(Movie::rated.name, "G")
)
val sort = Sorts.ascending(Movie::title.name)
val projection = Projections.fields(
    Projections.include(Movie::title.name, Movie::rated.name),
    Projections.excludeId()
)
val resultsFlow = moviesCollection.find(filter).sort(sort).projection(projection)
resultsFlow.collect { println(it) }

Los índices de clave múltiple se comportan de manera diferente a otros índices en términos de cobertura de consultas, cálculo de límites del índice y comportamiento de ordenación. Para obtener más información sobre los índices multikey, incluyendo una discusión sobre su comportamiento y limitaciones, consulta Índices multikey en el manual del servidor.

MongoDB Search e MongoDB Vector Search Indexes

Puedes gestionar programáticamente tus índices de MongoDB Search y MongoDB Vector Search utilizando el controlador de Kotlin.

La funcionalidad de búsqueda de MongoDB permite realizar búsquedas de texto completo en colecciones alojadas en MongoDB. Para obtener más información sobre MongoDB Search, consulte la documentación de Índices de MongoDB Search.

MongoDB Vector Search permite realizar búsquedas semánticas sobre embeddings de vectores almacenados en MongoDB. Para obtener más información sobre MongoDB Vector Search, consulte MongoDB Vector Search guide.

Puedes llamar a los siguientes métodos en una colección para gestionar tus índices de MongoDB Search y MongoDB Vector Search:

• createSearchIndex() (válido solamente para índice de MongoDB Search)

• createSearchIndexes()

• listSearchIndexes()

• updateSearchIndex()

• dropSearchIndex()

Las siguientes secciones muestran ejemplos de código que demuestran cómo utilizar cada uno de los métodos anteriores.

val searchIdx = Document(
    "mappings",
    Document("dynamic", true)
)
val resultCreateIndex = moviesCollection.createSearchIndex("myIndex", searchIdx)

val searchIdxMdl = SearchIndexModel(
    "searchIdx",
    Document("analyzer", "lucene.standard").append(
        "mappings", Document("dynamic", true)
    ),
    SearchIndexType.search()
)
val vectorSearchIdxMdl = SearchIndexModel(
    "vsIdx",
    Document(
        "fields",
        listOf(
            Document("type", "vector")
                .append("path", "embeddings")
                .append("numDimensions", 1536)
                .append("similarity", "dotProduct")
        )
    ),
    SearchIndexType.vectorSearch()
)
val resultCreateIndexes = moviesCollection.createSearchIndexes(
    listOf(searchIdxMdl, vectorSearchIdxMdl)
)

val searchIndexesList = moviesCollection.listSearchIndexes().toList()

moviesCollection.updateSearchIndex(
    "myIndex",
    Document("analyzer", "lucene.simple").append(
        "mappings",
        Document("dynamic", false)
            .append(
                "fields",
                Document(
                    "title",
                    Document("type", "string")
                )
            )
    )
)

moviesCollection.dropSearchIndex("myIndex");

Text Indexes

Los índices de texto permiten realizar queries de texto sobre contenido de string. Estos índices pueden incluir cualquier campo cuyo valor sea un string o un arreglo de elementos de tipo string. MongoDB soporta queries de texto para varios lenguajes. Puedes especificar el lenguaje por defecto como una opción al crear el índice.

try {
    val resultCreateIndex = moviesCollection.createIndex(Indexes.text(Movie::plot.name))
    println("Index created: $resultCreateIndex")
} catch (e: MongoCommandException) {
    if (e.errorCodeName == "IndexOptionsConflict") {
        println("there's an existing text index with different options")
    }
}

Index created: plot_text

val filter = Filters.text("Batman")
val projection = Projections.fields(
    Projections.include(Movie::fullplot.name),
    Projections.excludeId()
)
data class Results(val fullplot: String)
val resultsFlow = moviesCollection.find<Results>(filter).projection(projection)
resultsFlow.collect { println(it) }

try {
    val resultCreateIndex = moviesCollection.createIndex(
        Indexes.compoundIndex(
            Indexes.text(Movie::title.name), Indexes.text(Movie::genres.name)
        )
    )
    println("Index created: $resultCreateIndex")
} catch (e: MongoCommandException) {
    if (e.errorCodeName == "IndexOptionsConflict") {
        println("there's an existing text index with different options")
    }
}

Index created: title_text_genre_text

Índices geoespaciales

MongoDB admite consultas de datos de coordenadas geoespaciales utilizando 2índices dsphere. Con un 2dsphere índice, puedes query los datos geoespaciales para inclusión, intersección y proximidad. Para obtener más información sobre la consulta de datos geoespaciales, consulte Consultas geoespaciales en el manual del servidor.

Para crear un índice 2dsphere, debes especificar un campo que contenga solo objetos GeoJSON. Para obtener más información sobre este tipo, consulta Objetos GeoJSON en el manual del servidor.

El campo location.geo en el siguiente documento de ejemplo de la colección theaters en la base de datos sample_mflix es un objeto punto GeoJSON que describe las coordenadas del teatro:

{
   "_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
         ]
      }
   }
}

El siguiente ejemplo crea un índice 2dsphere en el campo location.geo:

val resultCreateIndex = theatersCollection.createIndex(
    Indexes.geo2dsphere("${Theater::location.name}.${Theater.Location::geo.name}")
)
println("Index created: $resultCreateIndex")

Index created: location.geo_2dsphere

El siguiente es un ejemplo de una query geoespacial que está cubierta por el índice creado en el snippet de código anterior:

// MongoDB Headquarters in New York, NY.
val refPoint = Point(Position(-73.98456, 40.7612))
val filter = Filters.near(
    "${Theater::location.name}.${Theater.Location::geo.name}",
    refPoint, 1000.0, 0.0
)
val resultsFlow = theatersCollection.find(filter)
resultsFlow.collect { println(it) }

MongoDB también admite índices 2d para calcular distancias en un plano euclidiano. Para obtener más información, consulte Consultas geoespaciales en el manual del Servidor.

Unique Indexes

Los índices únicos aseguran que los campos indexados no almacenen valores duplicados. Por defecto, MongoDB crea un índice único en el campo _id durante la creación de una colección. Para crear un índice único, especifique el campo o la combinación de campos en los que desea evitar la duplicación y configure la opción unique en true.

El siguiente ejemplo crea un índice descendente único en el campo theaterId:

try {
    val indexOptions = IndexOptions().unique(true)
    val resultCreateIndex = theatersCollection.createIndex(
        Indexes.descending(Theater::theaterId.name), indexOptions
    )
    println("Index created: $resultCreateIndex")
} catch (e: DuplicateKeyException) {
    println("duplicate field values encountered, couldn't create index: \t${e.message}")
}

Index created: theaterId_-1

E11000 duplicate key error index

Consulta la página de Índices Únicos en el manual del servidor de MongoDB para obtener más información.

Índices clusterizados

Los índices agrupados instruyen a una colección para almacenar los documentos ordenados por un valor clave. Para crear un índice agrupado, especifica la opción de índice agrupado teniendo el campo _id como clave y el campo único como true cuando crees tu colección.

El siguiente ejemplo crea un índice clusteringado en el campo _id de la colección vendors:

val clusteredIndexOptions = ClusteredIndexOptions(Document("_id", 1), true)
val createCollectionOptions = CreateCollectionOptions().clusteredIndexOptions(clusteredIndexOptions)
database.createCollection("vendors", createCollectionOptions)

Consulta las secciones del manual del servidor MongoDB para obtener más información:

• Índice del clúster

• Colecciones con índice clusterizado

Remover un índice utilizando un documento de especificación de índice

Pase un documento de especificación del índice al método dropIndex() para remover un índice de una colección. Un documento de especificación del índice es una instancia de Bson que especifica el tipo de índice en un campo determinado.

El siguiente snippet elimina un índice ascendente en el campo title de una colección:

moviesCollection.dropIndex(Indexes.ascending(Movie::title.name));

Remover un índice usando un campo de nombre

Pasa el campo name del índice al método dropIndex() para remover un índice de una colección.

Si necesita encontrar el nombre de su índice, use el método listIndexes() para ver el valor de los campos name en sus índices.

El siguiente snippet recupera e imprime todos los índices de una colección:

val indexes = moviesCollection.listIndexes()
indexes.collect { println(it.toJson()) }

Si llamas a listIndex() en una colección que contiene un índice de texto, la salida podría parecerse a la siguiente:

{ "v": 2, "key": {"_id": 1}, "name": "_id_" }
{ "v": 2, "key": {"_fts": "text", "_ftsx": 1}, "name": "title_text", "weights": {"title": 1},
"default_language": "english", "language_override": "language", "textIndexVersion": 3 }

Esta salida nos dice que los nombres de los índices existentes son "_id" y "title_text".

El siguiente snippet remueve el índice "title_text" de la colección:

moviesCollection.dropIndex("title_text")

Remover un índice utilizando un carácter comodín

A partir de MongoDB 4.2, puede eliminar todos los índices llamando al método dropIndexes() en su colección:

moviesCollection.dropIndexes()

Para versiones anteriores de MongoDB, pasa "*" como parámetro en tu llamada a dropIndex() en tu colección:

moviesCollection.dropIndex("*")

Para obtener más información sobre los métodos de esta sección, consulte la siguiente Documentación de la API:

• dropIndex()

• dropIndexes()