Indexes

Cobertura e desempenho da query

Quando você executa uma query em relação ao MongoDB, sua query pode incluir três partes:

• critérios de query que especificam o(s) campo(s) e o(s) valor(es) que você está procurando

• opções que afetam a execução da query, como ler preocupações

• critérios de projeção para especificar os campos que MongoDB deve retornar (opcional)

Quando todos os campos especificados nos critérios de query e projeção de uma query são indexados, o MongoDB retorna os resultados diretamente do índice sem digitalizar nenhum documento na coleta ou carregá-los na memória.

Para obter informações adicionais sobre como garantir que seu índice cubra seus critérios de query e projeção, consulte os artigos do manual do MongoDB sobre cobertura de query e interseção de índices.

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 que você adiciona consome espaço em disco e memória quando ativo, portanto, você deve 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 tem que atualizar o índice relacionado.

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

Índices de campo único

Índices de campo único são índices que melhoram o desempenho para queries que especificam a ordem de classificação crescente ou decrescente em um único campo de um documento.

O exemplo seguinte utiliza o método createIndex() para criar um índice de ordem crescente no campo title na collection movies no reconhecimento de data center sample_mflix .

const database = client.db("sample_mflix");
const movies = database.collection("movies");
// Create an ascending index on the "title" field in the
// "movies" collection.
const result = await movies.createIndex({ title: 1 });
console.log(`Index created: ${result}`);

O seguinte é um exemplo de uma query que seria coberta pelo índice criado acima.

const query = { title: "Batman" }
const sort = { title: 1 };
const projection = { _id: 0, title: 1 };
const cursor = movies
  .find(query)
  .sort(sort)
  .project(projection);

Para saber mais, consulte Índices de campo único.

Índices compostos

Índices compostos são índices que melhoram o desempenho de queries que especificam ordem de classificação crescente ou decrescente para vários campos de um documento. Você deve especificar a direção (ascendente ou decrescente) para cada campo no índice.

O exemplo seguinte utiliza o método createIndex() para criar um índice composto nos campos type e genre na coleção movies no banco de dados sample_mflix.

const database = client.db("sample_mflix");
const movies = database.collection("movies");
// Create an ascending index on the "type" and "genre" fields
// in the "movies" collection.
const result = await movies.createIndex({ type: 1, genre: 1 });
console.log(`Index created: ${result}`);

O seguinte é um exemplo de uma query que seria coberta pelo índice criado acima.

const query = { type: "movie", genre: "Drama" };
const sort = { type: 1, genre: 1 };
const projection = { _id: 0, type: 1, genre: 1 };
const cursor = movies
  .find(query)
  .sort(sort)
  .project(projection);

Para saber mais, consulte Índices compostos.

Índices de várias teclas (índices em campos de array)

Índices multichave são índices que melhoram o desempenho de queries em campos que contêm valores de array.

Você pode criar um índice de múltiplas chaves em um campo com um valor de array chamando o método createIndex(). O seguinte código cria um índice ascendente no campo cast na coleção movies do banco de dados sample_mflix:

const database = client.db("sample_mflix");
const movies = database.collection("movies");
// Create a multikey index on the "cast" field
const result = await movies.createIndex({ cast: 1 });

O código a seguir consulta o índice multichave para encontrar documentos com um valor de campo cast que contenha "Viola Davis":

const query = { cast: "Viola Davis" };
const projection = { _id: 0, cast: 1 , title: 1 };
const cursor = movies
  .find(query)
  .project(projection);

Os índices multichave se comportam de forma diferente dos índices não multichave em termos de cobertura de query, computação vinculada a índice e comportamento de classificação. Para obter uma explicação completa dos í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 MongoDB Server .

Índices aglomerados

Índices clusterizados são índices que melhoram o desempenho de operações de inserção, atualização e exclusão em coleções clusterizadas. As coleções agrupadas armazenam documentos ordenados pelo valor da chave do índice agrupado.

Para criar um índice agrupado, especifique a opção clusteredIndex no CollectionOption. A opção clusteredIndex deve especificar o campo _id como a chave e o campo exclusivo como true.

O exemplo seguinte utiliza o método createCollection() para criar um índice agrupado no campo _id na coleção vendors do banco de dados tea.

const db = client.db('tea');
await db.createCollection('ratings', {
  clusteredIndex: {
    key: { _id: 1 },
    unique: true
  }
});

Para saber mais, consulte Índice em clusters e Coleções clusterizadas.

Text Indexes

Índices de texto oferecem suporte a queries de pesquisa de texto no conteúdo da 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 em vários idiomas, para que você possa especificar o idioma padrão como opção ao criar o índice. Você também pode especificar uma opção de peso para priorizar determinados campos de texto em seu índice. Esses pesos denotam a importância dos campos relativos aos outros campos indexados.

Para saber mais sobre pesquisas de texto, consulte nosso guia sobre consultas de pesquisa de texto.

O exemplo a seguir usa o método createIndex() para executar as ações a seguir:

• Criar um índice text nos campos title e body na coleção blogPosts

• Especifique english como o idioma padrão

• Definir o peso do campo de body para 10 e title para 3

const myDB = client.db("testDB");
const myColl = myDB.collection("blogPosts");
// Create a text index on the "title" and "body" fields
const result = await myColl.createIndex(
  { title: "text", body: "text" },
  { default_language: "english" },
  { weights: { body: 10, title: 3 } }
);

A seguinte query utiliza o índice de texto criado no código anterior:

const query = { $text: { $search: "life ahead" } };
const projection = { _id: 0, title: 1 };
const cursor = myColl.find(query).project(projection);

Para saber mais sobre índices de texto, consulte Índices de texto no manual do servidor.

Índices geoespaciais

MongoDB suporta queries de dados de coordenadas geoespaciais usando índices 2dsphere. Com um índice 2dsphere, você pode consultar os dados geoespaciais para inclusão, interseção e proximidade. Para mais informações sobre como consultar dados geoespaciais com o driver Node.js do MongoDB, leia nosso guia de pesquisa geoespacial .

Para criar um índice dsphere 2 , você deve especificar um campo que contenha apenas objetos GeoJSON. Para mais detalhes sobre este tipo, consulte a página manual do servidor MongoDB em Objetos GeoJSON.

O campo location.geo no seguinte documento de amostra da coleção theaters no banco de dados sample_mflix é 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 exemplo seguinte utiliza o método createIndexes() para criar um índice 2dsphere no campo location.geo na coleção theaters no banco de dados sample_mflix para habilitar pesquisas geoespaciais.

const database = client.db("sample_mflix");
const movies = database.collection("movies");
// Create a 2dsphere index on the "location.geo" field in the "theaters" collection.
const result = await movies.createIndex({ "location.geo": "2dsphere" });
console.log(`Index created: ${result}`);

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

Unique Indexes

Índices únicos garantem que os campos indexados não armazenam 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 o campo ou a combinação de campos em que você deseja evitar a duplicação e defina a opção unique para true.

O exemplo seguinte utiliza o método createIndex() para criar um índice único no campo theaterId na coleção theaters do banco de dados sample_mflix.

const database = client.db("sample_mflix");
const movies = database.collection("movies");
// Create a unique index on the "theaterId" field in the "theaters" collection.
const result = await movies.createIndex({ theaterId: 1 }, { unique: true });
console.log(`Index created: ${result}`);

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.