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. Você deve monitorar 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, MongoDB também tem que atualizar o índice relacionado.

Como o MongoDB suporta esquemas dinâmicos, seu aplicação pode consultar em campos com nomes atualmente desconhecidos ou arbitrários. O MongoDB 4.2 introduziu índices curinga para ajudar a suportar essas queries. Os índices curinga não são projetados para substituir o planejamento de índice baseado em volume 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 TLL que removem automaticamente documentos de uma coleção após um determinado período de tempo.

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)

Í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.

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)

Í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.

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)

Í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("tea")
cio := bson.D{{"key", bson.D{{"_id", 1}}}, {"unique", true}}
opts := options.CreateCollection().SetClusteredIndex(cio)
db.CreateCollection(context.TODO(), "vendors", 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 collection só pode conter um índice de texto. Se você deseja criar um índice de texto para múltiplos campos de texto, você precisa criar um índice composto. A pesquisa de texto é executada em todos os campos de texto dentro do índice composto.

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)

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

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)

Documentação da API

Para saber mais sobre qualquer um dos métodos discutidos nesta guia, consulte a seguinte documentação da API:

• IndexModel

• CreateOne()

• IndexOptions

• SetDefaultLanguage()

• DropOne()

• CreateCollection()

• CreateCollectionOptions