Indexes

Cobertura y rendimiento de las consultas

Una consulta en MongoDB puede contener los siguientes elementos:

Cuando se especifican estos elementos en el mismo índice, MongoDB devuelve resultados directamente del índice, también llamado consulta cubierta.

name_1_age_-1

Consideraciones operativas

Para mejorar el rendimiento de sus consultas, cree índices en los campos que aparecen con frecuencia en sus consultas y operaciones que devuelven resultados ordenados. Realice un seguimiento del uso de memoria y disco del índice para planificar la capacidad, ya que cada índice que agregue consume espacio en disco y memoria. Además, cuando una operación de escritura actualiza un campo indexado, MongoDB también debe actualizar el índice relacionado.

Dado que MongoDB admite esquemas dinámicos, su aplicación puede realizar consultas a campos con nombres desconocidos o arbitrarios. MongoDB 4.2 introdujo índices comodín para facilitar estas consultas. Los índices comodín no están diseñados para reemplazar la planificación de índices basada en la carga 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 Estrategias de indexación y Modelado de datos e índices.

Índices de un solo campo

Los índices de campo único mantienen una referencia a un campo dentro de los documentos de una colección.

Este índice mejora las queries de un solo campo y el rendimiento de la ordenación, y admite índices TTL que remueven automáticamente documentos de una colección después de un cierto tiempo.

coll := client.Database("sample_mflix").Collection("movies")
indexModel := mongo.IndexModel{
    Keys: bson.D{{"title", 1}},
}
name, err := coll.Indexes().CreateOne(context.TODO(), indexModel)
if err != nil {
    panic(err)
}
fmt.Println("Name of Index Created: " + name)

Name of Index Created: title_1

Índices compuestos

Los índices compuestos tienen una referencia a varios campos dentro de los documentos de una colección. Este índice mejora el rendimiento de query y orden.

coll := client.Database("sample_mflix").Collection("movies")
indexModel := mongo.IndexModel{
    Keys: bson.D{
        {"fullplot", -1},
        {"title", 1}
    }
}
name, err := coll.Indexes().CreateOne(context.TODO(), indexModel)
if err != nil {
    panic(err)
}
fmt.Println("Name of Index Created: " + name)

Name of Index Created: fullplot_-1_title_1

Índices multiclave (índices en campos de matriz)

Los índices multiclave utilizan la misma sintaxis que los índices de campo único y compuestos. Este índice mejora el rendimiento de las consultas que especifican un campo de matriz como índice.

coll := client.Database("sample_mflix").Collection("movies")
indexModel := mongo.IndexModel{
    Keys: bson.D{{"cast", -1}}
}
name, err := coll.Indexes().CreateOne(context.TODO(), indexModel)
if err != nil {
    panic(err)
}
fmt.Println("Name of Index Created: " + name)

Name of Index Created: cast_-1

Índices de búsqueda de MongoDB y búsqueda vectorial de MongoDB

Puede administrar mediante programación sus índices MongoDB Search y MongoDB Vector Search utilizando el controlador Go.

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 la búsqueda de MongoDB.

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

Para obtener más información sobre cómo ejecutar consultas de búsqueda vectorial de MongoDB, consulte Guía paraejecutar una consulta de búsqueda vectorial de MongoDB.

Las siguientes secciones contienen ejemplos de código que demuestran cómo administrar los índices de MongoDB Search y MongoDB Vector Search.

// Sets the index name and type to "search"
const indexName = "search_index"
opts := options.SearchIndexes().SetName(indexName).SetType("search")
// Defines the index definition
searchIndexModel := mongo.SearchIndexModel{
	Definition: bson.D{
		{Key: "mappings", Value: bson.D{
			{Key: "dynamic", Value: false},
			{Key: "fields", Value: bson.D{
				{Key: "plot", Value: bson.D{
					{Key: "type", Value: "string"},
				}},
			}},
		}},
	},
	Options: opts,
}
// Creates the index
searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, searchIndexModel)
if err != nil {
	log.Fatalf("Failed to create the MongoDB Search index: %v", err)
}

// Defines the structs used for the index definition
type vectorDefinitionField struct {
	Type          string `bson:"type"`
	Path          string `bson:"path"`
	NumDimensions int    `bson:"numDimensions"`
	Similarity    string `bson:"similarity"`
	Quantization  string `bson:"quantization"`
}
type vectorDefinition struct {
	Fields []vectorDefinitionField `bson:"fields"`
}
// Sets the index name and type to "vectorSearch"
const indexName = "vector_search_index"
opts := options.SearchIndexes().SetName(indexName).SetType("vectorSearch")
// Defines the index definition
vectorSearchIndexModel := mongo.SearchIndexModel{
	Definition: vectorDefinition{
		Fields: []vectorDefinitionField{{
			Type:          "vector",
			Path:          "plot_embedding",
			NumDimensions: 1536,
			Similarity:    "dotProduct",
			Quantization:  "scalar"}},
	},
	Options: opts,
}
// Creates the index
searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, vectorSearchIndexModel)
if err != nil {
	log.Fatalf("Failed to create the MongoDB Vector Search index: %v", err)
}

// Specifies the index to retrieve
const indexName = "myIndex"
opts := options.SearchIndexes().SetName(indexName)
// Retrieves the details of the specified index
cursor, err := coll.SearchIndexes().List(ctx, opts)
// Prints the index details to the console as JSON
var results []bson.D
if err := cursor.All(ctx, &results); err != nil {
	log.Fatalf("Failed to unmarshal results to bson: %v", err)
}
res, err := json.Marshal(results)
if err != nil {
	log.Fatalf("Failed to marshal results to json: %v", err)
}
fmt.Println(res)

// Specifies the index name and the new index definition
const indexName = "vector_search_index"
type vectorDefinitionField struct {
	Type          string `bson:"type"`
	Path          string `bson:"path"`
	NumDimensions int    `bson:"numDimensions"`
	Similarity    string `bson:"similarity"`
}
type vectorDefinition struct {
	Fields []vectorDefinitionField `bson:"fields"`
}
definition := vectorDefinition{
	Fields: []vectorDefinitionField{
		{
			Type:          "vector",
			Path:          "plot_embedding",
			NumDimensions: 1536,
			Similarity:    "cosine",
			Quantization:  "scalar",
		},
	},
}
// Updates the specified index
err := coll.SearchIndexes().UpdateOne(ctx, indexName, definition)
if err != nil {
	log.Fatalf("Failed to update the index: %v", err)
}

// Deletes the specified index
err := coll.SearchIndexes().DropOne(ctx, "myIndex")
if err != nil {
	log.Fatalf("Failed to delete the index: %v", err)
}

Índices agrupados

Los índices agrupados mejoran el rendimiento de las operaciones de inserción, actualización y eliminación en colecciones agrupadas. Almacenan documentos ordenados por el valor de la clave del índice agrupado.

Para crear un índice agrupado, especifique la opción de índice agrupado con el campo _id como clave y el campo único como true cuando cree su colección.

db := client.Database("db")
cio := bson.D{{"key", bson.D{{"_id", 1}}}, {"unique", true}}
opts := options.CreateCollection().SetClusteredIndex(cio)
db.CreateCollection(context.TODO(), "tea", opts)

Text Indexes

Los índices de texto admiten consultas de texto sobre contenido de cadenas. Este índice requiere un campo de cadena o una matriz de cadenas. MongoDB admite la búsqueda de texto en varios idiomas. Puede especificar el idioma predeterminado al crear el índice.

Una colección solo puede contener un índice de texto. Si desea crear un índice de texto para varios campos de texto, debe crear un índice compuesto. La consulta de texto se ejecuta en todos los campos de texto dentro del índice compuesto.

coll := client.Database("sample_mflix").Collection("movies")
indexModel := mongo.IndexModel{Keys: bson.D{{"plot", "text"}, {"default_language", "italian"}}}
name, err := coll.Indexes().CreateOne(context.TODO(), indexModel)
if err != nil {
   panic(err)
}
fmt.Println("Name of Index Created: " + name)

Name of Index Created: plot_text

Índices geoespaciales

MongoDB admite consultas que contienen datos de coordenadas geoespaciales mediante 2índices dsphere. Un 2dsphere índice debe estar en un campo de objetos GeoJSON.

Este índice le permite realizar lo siguiente:

• Consultar datos geoespaciales para inclusión, intersección y proximidad.

• Cálculo de distancias en un plano euclidiano y para trabajar con la sintaxis de "pares de coordenadas heredadas" utilizada en MongoDB 2.2 y versiones anteriores.

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

indexModel := mongo.IndexModel{
    Keys: bson.D{{"location.geo", "2dsphere"}}
}
name, err := coll.Indexes().CreateOne(context.TODO(), indexModel)
if err != nil {
    panic(err)
}
fmt.Println("Name of Index Created: " + name)

location.geo_2dsphere

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 en los que desea evitar la duplicación y defina la opción unique en true.

indexModel := mongo.IndexModel{
    Keys: bson.D{{"theaterId", -1}},
    Options: options.Index().SetUnique(true),
}
name, err := coll.Indexes().CreateOne(context.TODO(), indexModel)
if err != nil {
    panic(err)
}
fmt.Println("Name of Index Created: " + name)

Name of Index Created: theaterId_-1

Documentación de la API

Para obtener más información sobre los métodos analizados en esta guía y otros relacionados, consulte la siguiente documentación de API:

• IndexModel

• Opciones del índice

• Establecer idioma predeterminado()

• Crear uno()

• DropOne()

• Crear colección()

• Opciones de creación de colección

• Índices de búsqueda

• Vista de índice de búsqueda