Indexes

Cobertura e desempenho da query

Uma consulta no MongoDB pode conter os seguintes elementos:

Ao especificar esses elementos no mesmo índice, o MongoDB gera resultados diretamente do índice, também chamado de query coberta.

name_1_age_-1

Considerações operacionais

Para melhorar o desempenho de sua consulta, crie índices em campos que aparecem com frequência em suas consultas e operações que retornam resultados ordenados. Acompanhe a memória do índice e o uso do disco para o planejamento da capacidade, pois cada índice adicionado consome espaço em disco e memória. Além disso, quando uma operação de gravação atualiza um campo indexado, o MongoDB também deve atualizar o índice relacionado.

Como o MongoDB suporta esquemas dinâmicos, seu aplicativo pode fazer queries em campos com nomes desconhecidos ou arbitrários. O MongoDB 4.2 introduziu índices curinga para ajudar a suportar essas consultas. Os índices curinga não são projetados para substituir o planejamento de índice baseado em carga de trabalho.

Para saber mais sobre como criar seu modelo de dados e escolher índices apropriados para seu aplicativo, consulte Estratégias de Indexação e Modelagem de Dados e Índices.

Índices de campo único

Os índices de campo único mantêm uma referência a um campo dentro dos documentos de uma coleção.

Esse índice melhora as consultas de campo único e o desempenho da classificação, além de oferecer suporte a índices TTL que removem automaticamente documentos de uma coleção após um determinado período de tempo.

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 compostos

Os índices compostos mantêm uma referência a vários campos dentro dos documentos de uma coleção. Este índice melhora o desempenho de consulta e classificação.

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 de várias teclas (índices em campos de array)

Os índices de múltiplas chaves utilizam a mesma sintaxe que um índice de campo único e um índice composto. Este índice melhora o desempenho de consultas que especificam um campo de matriz como um í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

Atlas Search e índices Atlas Vector Search

Você pode gerenciar programaticamente seus índices do Atlas Search e Atlas Vector Search usando o driver Go.

O recurso Atlas Search permite realizar pesquisas de texto completo em collections hospedadas no MongoDB Atlas. Para saber mais sobre o Atlas Search, consulte a documentação do Atlas Search.

O Atlas Vector Search permite realizar pesquisas semânticas em incorporações vetoriais armazenadas no Atlas. Para saber mais sobre o Atlas Vector Search, consulte a documentação do Atlas Vector Search.

Para saber mais sobre como executar queries do Atlas Vector Search, consulte o guia Executar uma query do Atlas Vector Search.

As seções seguintes contêm exemplos de código que demonstram como gerenciar índices Atlas Search e Atlas 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 Atlas 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 Atlas 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 aglomerados

Os índices clusterizados melhoram o desempenho das operações de inserção, atualização e exclusão em coleções clusterizadas. Coleções clusterizadas armazenam documentos ordenados pelo valor da chave do índice agrupado.

Para criar um índice de cluster, especifique a opção de índice de cluster com o campo _id como a chave e o campo único como true ao criar a collection.

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

Índices de texto oferecem suporte a pesquisas de query de texto no conteúdo da string. Este índice exige um campo de string ou uma array de strings. O MongoDB suporta pesquisa de texto para vários idiomas. Você pode especificar o idioma padrão como uma opção ao criar o índice.

Uma coleção pode conter somente um índice de texto. Se você deseja criar um índice de texto para múltiplos campos de texto, deve criar um índice composto. A pesquisa de texto é executada em todos os campos de texto dentro do índice composto.

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 geoespaciais

O MongoDB suporta queries contendo de dados de coordenadas geoespaciais usando índices 2dsphere. Um índice 2dsphere deve estar em um campo de objetos GeoJSON.

Este índice permite que você execute o seguinte:

• Consulta dados geoespaciais para inclusão, interseção e proximidade.

• Cálculo de distâncias em um plano euclidiano e para trabalhar com a sintaxe de "pares de coordenadas legados" usada no MongoDB 2.2 e 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

Índices únicos garantem que os campos indexados não armazenem valores duplicados. Por padrão, o MongoDB cria um índice único no campo _id durante a criação de uma coleção.

Para criar um índice exclusivo, especifique o campo ou a combinação de campos em que você deseja evitar a duplicação e defina a opção unique como 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

Documentação da API

Para saber mais sobre os métodos discutidos neste guia e outros relacionados, consulte a seguinte documentação da API:

• IndexModel

• IndexOptions

• SetDefaultLanguage()

• CreateOne()

• DropOne()

• CreateCollection()

• CreateCollectionOptions

• Índices de pesquisa

• SearchIndexView