Índices

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 índice.

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.

Listar índices

Você pode usar o listIndexes() método para listar todos os índices de uma coleção. Os métodos listIndexes() método usa uma ListIndexesOptions opcional Parâmetro. O listIndexes() método retorna um objeto do tipo ListIndexesCursor.

O código a seguir usa o método listIndexes() para listar todas as indexações em uma coleção:

const result = await collection.listIndexes().toArray();
console.log("Existing indexes:\n");
for(const doc in result){
    console.log(doc);
}

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

Índices de texto

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

// Get the database and collection on which to create the index 
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:

// Query for documents where body or title contain "life ahead"
const query = { $text: { $search: "life ahead" } };
// Show only the title field
const projection = { _id: 0, title: 1 };
// Execute the find operation
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.

Índices únicos

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

Criar um índice de pesquisa

Você pode usar o createSearchIndex() e createSearchIndexes() métodos para criar novos índices de pesquisa.

O código a seguir mostra como usar o método createSearchIndex() para criar um índice chamado search1:

const index1 = {
    name: "search1",
    definition: {
        "mappings": {
            "dynamic": true
        }
    }
}
await collection.createSearchIndex(index1);

Ao se conectar ao MongoDB Server v6.0.11 e versões posteriores de v6 ou versões posteriores de v7.0.2 e v7 , você pode usar o driver para criar um índice do Atlas Vector Search em uma coleção. Saiba mais sobre esse recurso na documentação do Atlas Vector Search.

O código a seguir mostra como usar o método createSearchIndex() para criar um índice de pesquisa no qual o campo type é vectorSearch:

// Create a Vector Search index
const vectorSearchIdx = {
    name: "vsidx1",
    type: "vectorSearch",
    definition: {
        fields: [{
            type: "vector",
            numDimensions: 384,
            path: "summary",
            similarity: "dotProduct"
        }]
    }
}
await collection.createSearchIndex(vectorSearchIdx);

Listar índices de pesquisa

Você pode usar o método listSearchIndexes() para retornar um cursor que contenha os índices de pesquisa de uma determinada coleção. O método listSearchIndexes() utiliza um parâmetro de string opcional, name, para retornar somente os índices com nomes correspondentes. Ele também usa um parâmetro opcional aggregateOptions.

O seguinte código usa o método listSearchIndexes() para listar os índices de pesquisa em uma coleção:

const result = await collection.listSearchIndexes().toArray();
console.log("Existing search indexes:\n");
for (const doc in result) {
    console.log(doc);
}

Atualizar um Índice de Pesquisa

Você pode usar o updateSearchIndex() para atualizar um índice de pesquisa.

O seguinte código mostra como utilizar o método updateSearchIndex() para atualizar um índice chamado search1 para especificar um tipo de string para o campo description:

const index2 = {
    "mappings": {
        "dynamic": true,
        "fields": {
            "description": {
                "type": "string"
            }
        }
    }
}
await collection.updateSearchIndex("search1", index2);

Eliminar um Índice de Pesquisa

Você pode usar o dropSearchIndex() para remover um índice de pesquisa.

O código a seguir mostra como usar o método dropSearchIndex() para remover um índice chamado search1:

await collection.dropSearchIndex("search1");