Indexes

Cobertura e desempenho da query

Quando você executa uma query em relação ao MongoDB, sua query pode incluir vários elementos:

• Critérios de query que especificam campos e valores que você procura

• Opções que afetam a execução da query, como a read concern

• Critérios de projeção para especificar os campos que você deseja que o MongoDB retorne

• Classificar critérios para especificar a ordem dos documentos devolvidos do MongoDB

Quando todos os campos especificados na query, projeção e classificação encontram-se no mesmo índice, o MongoDB gera resultados diretamente desse índice, também chamado de query coberta.

Para obter mais informações sobre como garantir que seu índice cubra seus critérios de query e projeção , consulte a seção Query coberta no manual do servidor MongoDB .

Considerações operacionais

Para melhorar o desempenho da query, crie índices em campos que aparecem com frequência nas queries e operações do seu aplicativo que retornam resultados ordenados. Cada índice adicionado consome espaço em disco e memória quando ativo, portanto, pode ser necessário rastrear a memória do índice e o uso do disco para o planejamento da capacidade. Além disso, quando uma operação de gravação atualiza um campo indexado, MongoDB também atualiza o índice relacionado.

Como o MongoDB oferece suporte a esquemas dinâmicos, os aplicativos podem executar a query dos campos cujos nomes não podem ser conhecidos antecipadamente ou são 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 carga de trabalho.

Para obter mais informações sobre como projetar o modelo de dados e escolher os índices apropriados para o seu aplicação, consulte a documentação do servidor sobre Estratégias de indexação e Modelagem de dados e índices.

Índices de campo único

Os índices de campo único são índices com uma referência a um único campo dentro dos documentos de uma coleção. Eles melhoram o desempenho da consulta de campo único e da classificação e oferecem suporte a índices TTL que removem automaticamente documentos de uma coleção após um determinado período de tempo ou em um horário específico.

O exemplo seguinte cria um índice em ordem crescente no campo title dentro da coleção sample_mflix.movies :

var indexModel = new CreateIndexModel<Movie>(Builders<Movie>.IndexKeys.Ascending(m => m.Title));
collection.Indexes.CreateOne(indexModel);

A seguir, um exemplo de uma query coberta pelo índice criado no trecho de código anterior:

// Define query parameters
var filter = Builders<Movie>.Filter.Eq(m => m.Title, "Batman");
var sort = Builders<Movie>.Sort.Ascending(m => m.Title);
var projection = Builders<Movie>.Projection.Include(m => m.Title).Exclude(m => m.Id);
// Execute query
var results = collection.Find(filter).Sort(sort).Project(projection);

Para obter mais informações, consulte Índices de campo único no manual do servidor.

Índices compostos

Os índices compostos contêm referências a vários campos dentro dos documentos de uma collection, melhorando o desempenho de query e classificação.

O exemplo seguinte cria um índice composto nos campos type e rated dentro da collection sample_mflix.movies :

var indexModel = new CreateIndexModel<Movie>(Builders<Movie>.IndexKeys
    .Ascending(m => m.Type)
    .Ascending(m => m.Rated));
collection.Indexes.CreateOne(indexModel);

A seguir, um exemplo de uma query coberta pelo índice criado no trecho de código anterior:

// Define query parameters
var typeFilter = Builders<Movie>.Filter.Eq(m => m.Type, "movie");
var ratedFilter = Builders<Movie>.Filter.Eq(m => m.Rated, "G");
var filter = Builders<Movie>.Filter.And(typeFilter, ratedFilter);
var sort = Builders<Movie>.Sort.Ascending(m => m.Type).Ascending(m => m.Rated);
var projection = Builders<Movie>.Projection
    .Include(m => m.Type)
    .Include(m => m.Rated)
    .Exclude(m => m.Id);
// Execute query
var results = collection.Find(filter).Sort(sort).Project(projection);

Para obter mais informações, consulte Índices compostos no manual do servidor.

Multikey Indexes

Índices de múltiplas chave coletam e classificam dados de campos contendo valores de array. Você pode definir um índice de múltiplas chaves utilizando a mesma sintaxe de um único campo ou índice composto.

O exemplo a seguir cria um índice composto de várias chaves nos campos rated, genres (uma array de Strings) e title dentro da collection sample_mflix.movies :

var indexModel = new CreateIndexModel<Movie>(Builders<Movie>.IndexKeys
    .Ascending(m => m.Rated)
    .Ascending(m => m.Genres)
    .Ascending(m => m.Title));
collection.Indexes.CreateOne(indexModel);

A seguir, um exemplo de uma query coberta pelo índice criado no trecho de código anterior:

// Define query parameters
var genreFilter = Builders<Movie>.Filter.AnyEq(m => m.Genres, "Animation");
var ratedFilter = Builders<Movie>.Filter.Eq(m => m.Rated, "G");
var filter = Builders<Movie>.Filter.And(genreFilter, ratedFilter);
var sort = Builders<Movie>.Sort.Ascending(m => m.Title);
var projection = Builders<Movie>.Projection
    .Include(m => m.Title)
    .Include(m => m.Rated)
    .Exclude(m => m.Id);
// Execute query
var results = collection.Find(filter).Sort(sort).Project(projection);

Os índices multicamadas se comportam de forma diferente de outros índices em termos de cobertura de consulta, computação vinculada a índice e comportamento de classificação. Para saber mais sobre índices de várias chaves, incluindo uma discussão sobre seu comportamento e limitações, consulte a página Índices de várias chaves no manual do servidor.

Índices aglomerados

Os índices de cluster instruem a collection a armazenar documentos ordenados por um valor de chave. Para criar um índice de cluster, especifique a opção de índice de cluster com o campo _id como a chave e a propriedade Unique como true ao criar a collection. Uma collection só pode conter um único índice clusterizado. Se você deseja criar um índice clusterizado, ele deverá ser especificado ao criar uma coleção.

O exemplo seguinte cria um índice agrupado no campo _id ao criar uma nova coleção sample_mflix.reviews :

var database = mongoClient.GetDatabase("sample_mflix");
var clusteredIndexOptions = new ClusteredIndexOptions<Review>
{
    Key = Builders<Review>.IndexKeys.Ascending(r => r.Id),
    Unique = true
};
database.CreateCollection("reviews", new CreateCollectionOptions<Review>
{
    ClusteredIndex = clusteredIndexOptions
});

Para saber mais, consulte Índices agrupados e coleções agrupadas no manual do servidor.

Índices de pesquisa do Atlas

O recurso Atlas Search permite realizar pesquisas de texto completo em collections hospedadas no MongoDB Atlas. Os índices especificam o comportamento da busca e quais campos indexar.

Para saber mais sobre o MongoDB Atlas Search, consulte a documentação dos índices do Atlas Search.

As seções a seguir contêm links para tutoriais que demonstram como criar e interagir com índices de Atlas Search .

Text Indexes

Os índices de texto suportam queries de pesquisa de texto no conteúdo de string. Esses índices podem incluir qualquer campo cujo valor seja uma string ou uma array de elementos de string. 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.

var indexModel = new CreateIndexModel<Movie>(Builders<Movie>.IndexKeys.Text(m => m.Plot));
collection.Indexes.CreateOne(indexModel);

// Define query parameters
var filter = Builders<Movie>.Filter.Text("java coffee shop");
var projection = Builders<Movie>.Projection.Include(m => m.Plot).Exclude(m => m.Id);
// Execute query
var results = collection.Find(filter).Project(projection);

var indexModel = new CreateIndexModel<Movie>(Builders<Movie>.IndexKeys
    .Text(m => m.Title)
    .Text(m => m.Genre));
collection.Indexes.CreateOne(indexModel);

Índices geoespaciais

O MongoDB suporta queries de dados de coordenadas geoespaciais utilizando índices dsphere do2. Com um índice dsphere 2 , você pode consultar os dados geoespaciais para inclusão, interseção e proximidade.

Para criar um índice dsphere 2 , você deve especificar um campo que contenha apenas objetos GeoJSON. Para mais detalhes sobre este tipo, consulte Objetos GeoJSON no manual do MongoDB Server .

O campo location.geo no seguinte documento de amostra da coleção sample_mflix.theaters é um objeto de ponto GeoJSON que descreve as coordenadas do teatro:

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

O seguinte exemplo cria um índice 2dsphere no campo location.geo:

var indexModel = new CreateIndexModel<Theater>(Builders<Theater>.IndexKeys.Geo2DSphere(t => t.Location.Geo));
collection.Indexes.CreateOne(indexModel);

O seguinte é um exemplo de uma consulta geoespacial utilizando "location.geo" Índice:

// Stores the coordinates of the NY MongoDB headquarters
var refPoint = GeoJson.Point(GeoJson.Position(-73.98456, 40.7612));
// Creates a filter to match documents that represent locations up to 1000 meters from the specified point directly from the geospatial index
var filter = Builders<Theater>.Filter.Near(m => m.Location.Geo, refPoint, 1000.0, 0.0);
// Execute the query
var results = collection.Find(filter);

O MongoDB também suporta índices 2d para calcular distâncias em um plano euclidiano e para trabalhar com a sintaxe dos "legacy coordinate pairs" usada no MongoDB 2.2 e anteriores. Para saber mais, consulte Queries geoespaciais no manual do servidor MongoDB.

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 collection. Para criar um índice único, especifique os campos nos quais você deseja evitar a duplicação e defina a opção Unique para true.

O exemplo seguinte cria um índice descendente único no campo theaterId dentro da collection sample_mflix.theaters .

var options = new CreateIndexOptions { Unique = true };
var indexModel = new CreateIndexModel<Theater>(Builders<Theater>.IndexKeys.Descending(t => t.TheaterId),
    options);
collection.Indexes.CreateOne(indexModel);

Se você tentar executar uma operação de gravação que armazena um valor duplicado que viola o índice único, o MongoDB lançará um erro que se assemelha ao seguinte:

E11000 duplicate key error index

Para saber mais, consulte Índices únicos no manual do servidor.

Índices curinga

Os índices curinga permitem queries em campos desconhecidos ou arbitrários. Esses índices podem ser benéficos se você estiver usando um esquema dinâmico.

O exemplo seguinte cria um índice curinga ascendente em todos os valores do campo location dentro da coleção sample_mflix.theaters , incluindo valores aninhados em subdocumentos e arrays:

var indexModel = new CreateIndexModel<Theater>(Builders<Theater>.IndexKeys.Wildcard(t => t.Location));
collection.Indexes.CreateOne(indexModel);

Para obter mais informações, consulte a página Índices curinga no manual do servidor.