Indexes

Cobertura y rendimiento de las consultas

Una query en MongoDB puede contener los siguientes elementos:

Cuando especificas estos elementos en el mismo índice, MongoDB devuelve resultados directamente del índice, lo que también se llama covered query.

name_1_age_-1

Consideraciones operativas

Para mejorar el rendimiento de las queries, crea índices en los campos que aparecen con frecuencia en tus queries y operaciones que devuelven resultados ordenados. Rastrea el uso de memoria y disco de índices para la planificación de capacidad, ya que cada índice que agregas 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 soporta esquemas dinámicos, tu aplicación puede consultar campos con nombres desconocidos o 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 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 arreglos)

Los índices multiclave emplean la misma sintaxis que un índice de campo único y un índice compuesto. Este índice mejora el rendimiento de las queries que especifican un campo de arreglo 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

MongoDB Search e MongoDB Vector Search Indexes

Puedes administrar programáticamente sus índices de MongoDB Search y MongoDB Vector Search usando el driver de 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.

MongoDB Vector Search te permite realizar búsquedas semánticas sobre embeddings vectoriales almacenados en Atlas. Para obtener más información sobre MongoDB Vector Search, consulta la documentación de MongoDB Vector Search.

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 gestionar 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 clusterizados

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

Para crear un índice agrupado, especifica la opción de índice agrupado con el campo _id como clave y el campo único como true cuando crees tu 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 quieres crear un índice de texto para varios campos de texto, debes crear un índice compuesto. La query 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 **queries** que contienen datos de coordenadas geoespaciales mediante el uso de **índices 2dsphere**. Un índice 2dsphere debe estar en un campo de objetos GeoJSON.

Este índice permite realizar lo siguiente:

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

• Cálculo de distancias en un plano euclidiano y para trabajar con la sintaxis de “legacy coordinate pairs” 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

• SetDefaultLanguage()

• Crear uno()

• DropOne()

• CreateCollection()

• CreateCollectionOptions

• SearchIndexes

• SearchIndexView