Í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 um ou mais campos e valores que você está procurando

• 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 (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 mais informações 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 adicionado consome espaço em disco e memória quando ativo, portanto, pode ser necessário monitorar 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.

Para obter mais informações sobre como projetar seu modelo de dados e escolher os í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:

// List the indexes on the collection and output them as an array
const result = await collection.listIndexes().toArray();
// Print the list of indexes
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 coberta pelo índice criado acima.

// Define the query parameters
const query = { title: "Batman" }
const sort = { title: 1 };
const projection = { _id: 0, title: 1 };
// Execute the query using the defined parameters
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.

// Connect to the "sample_mflix" database
const database = client.db("sample_mflix");
// Access the database's "movies" collection
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 coberta pelo índice criado acima.

// Define a query to find movies in the "Drama" genre
const query = { type: "movie", genre: "Drama" };
// Define sorting criteria for the query results
const sort = { type: 1, genre: 1 };
// Include only the type and genre fields in the query results
const projection = { _id: 0, type: 1, genre: 1 };
// Execute the query using the defined criteria and projection
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 in the "movies" collection
const result = await movies.createIndex({ cast: 1 });

O código a seguir consulta o índice de várias chaves para localizar documentos nos quais o valor do campo cast contém "Viola Davis":

const query = { cast: "Viola Davis" };
const projection = { _id: 0, cast: 1 , title: 1 };
// Perform a find operation with the preceding filter and projection
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 servidor MongoDB.

Í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 Índices agrupados e coleções agrupadas.

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

// 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
"movies" collection */
const result = await movies.createIndex({ "location.geo": "2dsphere" });
// Print the result of the index creation
console.log(`Index created: ${result}`);

O MongoDB também suporta índices 2d para calcular distâncias em um plano euclidiano e para trabalhar com a sintaxe dos "pares de coordenadas herdados" usada no MongoDB 2.2 e anterior. 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:

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

Ao conectar ao Servidor MongoDB v6.0.11 e versões posteriores v6 ou v7.0. Nas versões 2 e posterior v7 , você pode usar o driver para criar um índice do Atlas Vector Search em uma collection. Saiba mais sobre este recurso na documentação do Atlas Vector Search.

O seguinte código mostra como utilizar 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 listSearchIndexes() para retornar um cursor que contém os índices de pesquisa de uma determinada coleção. O listSearchIndexes() método utiliza um parâmetro de string opcional, name, para retornar somente os índices com nomes correspondentes. Ele também usa um aggregateOptions opcional Parâmetro.

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

// List search indexes
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:

// Update a search index
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:

// Dropping (deleting) a search index
await collection.dropSearchIndex("search1");