Indexes

Cobertura y rendimiento de la query

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 tu modelo de datos y elegir índices apropiados para tu aplicación, consulta 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 funcionalidad de búsqueda en MongoDB permite realizar búsquedas de texto completas en las colecciones alojadas en MongoDB Atlas. Para obtener más información sobre la Búsqueda de MongoDB, consulte la documentación de MongoDB Search.

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 aprender más sobre cómo ejecutar consultas de MongoDB Vector Search, consulte la Ejecutar una MongoDB Vector Search query guía.

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

Modelo de índice de búsqueda con auto-embebido de MongoDB

Puedes usar el driver de Go para crear un índice MongoDB Vector Search que genera automáticamente incrustaciones vectoriales para campos de texto mediante la especificación de una definición de índice que utiliza el tipo de campo autoEmbed en un índice vectorSearch. Esto permite que MongoDB llame a un modelo de incrustación de IA de Voyage en tu nombre y mantenga las incrustaciones sincronizadas a medida que se insertan o actualizan documentos.

Cuando defines un índice de búsqueda vectorial MongoDB con auto-incrustación, especificas un índice vectorSearch cuyo documento de definición contiene un arreglo fields requerido. de definiciones de campo. Este arreglo debe contener al menos un campo autoEmbed y, opcionalmente, puede incluir campos filter. Cada documento de campo en este arreglo utiliza las siguientes opciones:

El siguiente ejemplo crea un índice vectorSearch llamado auto_embedding_index que lleva a cabo las siguientes acciones:

• Genera automáticamente incrustaciones para el campo plot mediante el uso del modelo "voyage-4".

• Agrega campos de filtro opcionales en runtime y year para que puedas restringir las $vectorSearch query por esos valores.

El siguiente ejemplo muestra cómo definir las estructuras para la definición del modelo de índice:

// Defines the structs for the index definition
type autoEmbeddingField struct {
	Type     string `bson:"type"`     // "autoEmbed"
	Modality string `bson:"modality"` // "text"
	Path     string `bson:"path"`     // e.g. "plot"
	Model    string `bson:"model"`    // e.g. "voyage-4"
}
type filterField struct {
	Type string `bson:"type"` // "filter"
	Path string `bson:"path"`
}
type autoEmbeddingDefinition struct {
	Fields []any `bson:"fields"`
}

El siguiente ejemplo muestra cómo crear el índice de incrustación automática en la colección sample_mflix.movies:

// Gets collection reference
coll := client.Database("sample_mflix").Collection("movies")
// Sets the index name and type to "vectorSearch"
const indexName = "auto_embedding_index"
opts := options.SearchIndexes().
	SetName(indexName).
	SetType("vectorSearch")
// Specifies the index definition
def := autoEmbeddingDefinition{
	Fields: []any{
		autoEmbeddingField{
			Type:     "autoEmbed",
			Modality: "text",
			Path:     "plot",
			Model:    "voyage-4",
		},
		// Optional filter fields
		filterField{
			Type: "filter",
			Path: "runtime",
		},
		filterField{
			Type: "filter",
			Path: "year",
		},
	},
}
indexModel := mongo.SearchIndexModel{
	Definition: def,
	Options:    opts,
}
// Creates the index on the movies collection
searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, indexModel)
if err != nil {
	log.Fatalf("Failed to create the MongoDB Vector Search auto-embedding index: %v", err)
}
fmt.Println("Created MongoDB Vector Search auto-embedding index:", searchIndexName)

Para obtener más información sobre cómo realizar consultas en un índice de búsqueda vectorial de MongoDB con autoincrustación, consulte la sección Consultar un índice de autoincrustación de la Guía para ejecutar una consulta de búsqueda vectorial de MongoDB.

Í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 permiten realizar queries de texto sobre contenido en string. Este índice requiere un campo de string o un arreglo de strings. MongoDB es compatible con la búsqueda de texto para varios lenguajes. Puedes especificar el lenguaje por defecto como una opción 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 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 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 aprender más acerca de los métodos analizados en esta guía y los relacionados, consulta la siguiente documentación de la API:

• IndexModel

• Opciones del índice

• SetDefaultLanguage()

• CreateOne()

• DropOne()

• CreateCollection()

• CreateCollectionOptions

• SearchIndexes

• SearchIndexView