Indexes

Cobertura y rendimiento de las consultas

Cuando ejecuta una consulta en MongoDB, su comando puede incluir varios 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 para especificar los campos que MongoDB devuelve (opcional)

• Criterios de ordenación para especificar el orden de los documentos devueltos desde MongoDB (opcional)

Cuando todos los campos especificados en la consulta, proyección y ordenación están en el mismo índice, MongoDB devuelve 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 su índice cubra sus criterios de consulta y proyección, consulte los artículos del manual de MongoDB sobre cobertura de consultas.

Consideraciones operativas

Para mejorar el rendimiento de las queries, cree índices en campos que aparezcan frecuentemente en las queries de su aplicación y en operaciones que devuelvan resultados ordenados. Cada índice que agregues consume espacio en disco y memoria cuando está activo, así que recomendamos que rastrees el uso de memoria y disco por parte del índice para la planificación de la capacidad. Además, cuando una operación de escritura actualiza un campo indexado, MongoDB actualiza el índice relacionado.

Dado que MongoDB admite esquemas dinámicos, las aplicaciones pueden consultar campos cuyos nombres no se conocen de antemano o son arbitrarios. MongoDB 4.2 introdujo los índices comodín para ayudar a admitir estas consultas. Los índices comodín no están diseñados para sustituir la planificación de índices basada en la carga de trabajo.

Para obtener más información sobre el diseño de tu modelo de datos y la elección de índices apropiados para tu aplicación, consulte el modelado de datos e índices del MongoDB Server.

Índices de campo único y compuestos

String resultCreateIndex = collection.createIndex(Indexes.ascending("title"));
System.out.println(String.format("Index created: %s", resultCreateIndex));

Bson filter = eq("title", "Batman");
Bson sort = Sorts.ascending("title");
Bson projection = fields(include("title"), excludeId());
FindIterable<Document> cursor = collection.find(filter).sort(sort).projection(projection);

String resultCreateIndex = collection.createIndex(Indexes.ascending("type", "rated"));
System.out.println(String.format("Index created: %s", resultCreateIndex));

Bson filter = and(eq("type", "movie"), eq("rated", "G"));
Bson sort = Sorts.ascending("type", "rated");
Bson projection = fields(include("type", "rated"), excludeId());
FindIterable<Document> cursor = collection.find(filter).sort(sort).projection(projection);

Í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 múltiples claves en los campos rated, genres (una matriz de cadenas) y title:

String resultCreateIndex = collection.createIndex(Indexes.ascending("rated", "genres", "title"));
System.out.println(String.format("Index created: %s", resultCreateIndex));

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

Bson filter = and(eq("genres", "Animation"), eq("rated", "G"));
Bson sort = Sorts.ascending("title");
Bson projection = fields(include("title", "rated"), excludeId());
FindIterable<Document> cursor = collection.find(filter).sort(sort).projection(projection);

Los índices multiclave se comportan de forma diferente a otros índices en cuanto a la cobertura de consultas, el cálculo de los límites de índice y el ordenamiento. Para obtener más información sobre los índices multiclave, incluyendo una explicación de su comportamiento y limitaciones, consulte la página Índices multiclave del manual de MongoDB.

MongoDB Search e índices de búsqueda vectorial

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

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

La Búsqueda Vectorial de MongoDB permite realizar búsquedas semánticas en incrustaciones vectoriales almacenadas en MongoDB Atlas. Para obtener más información sobre la Búsqueda Vectorial de MongoDB, consulte Guíade búsqueda vectorial de MongoDB.

Puedes llamar a los siguientes métodos en una colección para gestionar tus índices de búsqueda y búsqueda vectorial de MongoDB:

• createSearchIndex() (válido solo para índices de búsqueda de MongoDB)

• createSearchIndexes()

• listSearchIndexes()

• updateSearchIndex()

• dropSearchIndex()

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

Document searchIdx = new Document("mappings",
        new Document("dynamic", true));
collection.createSearchIndex("myIndex", searchIdx);

SearchIndexModel searchIdxMdl = new SearchIndexModel(
    "searchIdx",
    new Document("analyzer", "lucene.standard").append(
        "mappings", new Document("dynamic", true)),
    SearchIndexType.search()
);
SearchIndexModel vectorSearchIdxMdl = new SearchIndexModel(
    "vsIdx",
    new Document(
        "fields",
        Arrays.asList(
            new Document("type", "vector")
                .append("path", "embeddings")
                .append("numDimensions", 1536)
                .append("similarity", "dotProduct")
        )
    ),
    SearchIndexType.vectorSearch()
);
collection.createSearchIndexes(
    Arrays.asList(searchIdxMdl, vectorSearchIdxMdl)
);

try (MongoCursor<Document> resultsCursor = collection.listSearchIndexes().iterator()) {
    while (resultsCursor.hasNext()) {
        System.out.println(resultsCursor.next());
    }
}

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

collection.dropSearchIndex("myIndex");

Text Indexes

Los índices de texto admiten consultas de texto sobre contenido de cadena. Estos índices pueden incluir cualquier campo cuyo valor sea una cadena o un array de elementos de cadena. MongoDB admite consultas de texto en varios idiomas. Puede especificar el idioma predeterminado al crear el índice.

try {
    String resultCreateIndex = collection.createIndex(Indexes.text("plot"));
    System.out.println(String.format("Index created: %s", resultCreateIndex));
// Prints a message if a text index already exists with a different configuration 
} catch (MongoCommandException e) {
    if (e.getErrorCodeName().equals("IndexOptionsConflict"))
        System.out.println("there's an existing text index with different options");
}

Bson filter = text("java coffee shop");
Bson projection = fields(include("fullplot"), excludeId());
FindIterable<Document> cursor = collection.find(filter).projection(projection);

collection.createIndex(Indexes.compoundIndex(Indexes.text("title"), Indexes.text("genre")));

Í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 cómo consultar datos geoespaciales, consulta Consultas geoespaciales.

Para crear un índice 2dsphere, se debe especificar un campo que contenga únicamente objetos GeoJSON. Para obtener más detalles sobre este tipo, consulte la página del manual de MongoDB Server sobre objetos GeoJSON.

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:

try {
    String resultCreateIndex = collection.createIndex(Indexes.geo2dsphere("location.geo"));
    System.out.println(String.format("Index created: %s", resultCreateIndex));
// Prints a message if a geospatial index already exists with a different configuration 
} catch (MongoCommandException e) {
    if (e.getErrorCodeName().equals("IndexOptionsConflict"))
        System.out.println("there's an existing geospatial index with different options");
}

El siguiente es un ejemplo de una query geoespacial que utiliza la "ubicación.geo" índice.

// Stores the coordinates of the NY MongoDB headquarters
Point refPoint = new Point(new Position(-73.98456, 40.7612));
// Retrieves documents that represent locations up to 1000 meters from the specified point directly from the geospatial index
// Creates a filter to match a document 
Bson filter = near("location.geo", refPoint, 1000.0, 0.0);
FindIterable<Document> cursor = collection.find(filter);

MongoDB también admite 2d índices para calcular distancias en un plano euclidiano y para trabajar con la sintaxis de "legacy coordinate pairs" utilizada en MongoDB 2.2 y anteriores. Para obtener más información, consulta la página de Consultas geoespaciales en el manual de MongoDB Server.

Unique Indexes

Los índices únicos garantizan que los campos indexados no almacenen valores duplicados. De forma predeterminada, 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 que desea evitar la duplicación y configure la opción unique como true.

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

try {
    IndexOptions indexOptions = new IndexOptions().unique(true);
    String resultCreateIndex = collection.createIndex(Indexes.descending("theaterId"), indexOptions);
    System.out.println(String.format("Index created: %s", resultCreateIndex));
// Prints a message if the "theaterID" field contains duplicate values
} catch (DuplicateKeyException e) {
    System.out.printf("duplicate field values encountered, couldn't create index: \t%s\n", e);
}

E11000 duplicate key error index

Para más información, consulta la página Índices Únicos en el manual del MongoDB Server.

Índices comodín

Los índices comodín permiten realizar consultas sobre campos desconocidos o arbitrarios. Estos índices pueden ser beneficiosos si se utiliza un esquema dinámico.

El siguiente ejemplo crea un índice de comodín ascendente en todos los valores del campo location, incluidos los valores anidados en subdocumentos y arreglos:

String resultCreateIndex = collection.createIndex(Indexes.ascending("location.$**")); 
System.out.println(String.format("Index created: %s", resultCreateIndex));

Para obtener más información, consulta la página Índices comodín en el manual de MongoDB Server.

Índices clusterizados

Los índices agrupados indican a una colección que almacene documentos ordenados por un valor de clave. Para crear un índice agrupado, especifique la opción de índice agrupado con el _id campo como clave y el campo único al true crear la colección.

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

MongoDatabase database = mongoClient.getDatabase("tea");
ClusteredIndexOptions clusteredIndexOptions = new ClusteredIndexOptions(new Document("_id", 1), true);
CreateCollectionOptions createCollectionOptions = new CreateCollectionOptions().clusteredIndexOptions(clusteredIndexOptions);
database.createCollection("vendors", createCollectionOptions);

Consulta las secciones del manual del servidor de MongoDB para 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:

collection.dropIndex(Indexes.ascending("title"));

Eliminar un índice mediante un campo de nombre

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

Para encontrar el nombre de tu índice, utiliza el método listIndexes() para ver el valor de los campos name en tus índices.

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

collection.listIndexes().forEach(doc -> System.out.println(doc.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:

collection.dropIndex("title_text");

Eliminar un índice usando 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:

collection.dropIndexes();

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

collection.dropIndex("*");

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

• soltarÍndice()

• dropIndexes()