Indexes
Nesta página
- Visão geral
- Cobertura e desempenho da query
- Considerações operacionais
- Listar índices
- Tipos de índice
- Índices de campo único
- Índices compostos
- Índices de várias teclas (índices em campos de array)
- Índices aglomerados
- Text Indexes
- Índices geoespaciais
- Unique Indexes
- Índices de pesquisa
- Criar um índice de pesquisa
- Listar índices de pesquisa
- Atualizar um Índice de Pesquisa
- Eliminar um Índice de Pesquisa
Visão geral
Os índices são estruturas de dados que oferecem suporte à execução eficiente de queries no MongoDB. Elas contêm cópias de partes dos dados em documentos para tornar as queries mais eficientes.
Sem índices, o MongoDB deve digitalizar todos os documentos em uma collection para encontrar os documentos que correspondem a cada query. Essas verificações da collection são lentas e podem afetar negativamente o desempenho do seu aplicativo. Ao usar um índice para limitar o número de verificações de documentos do MongoDB, as queries podem ser mais eficientes e, portanto, retornar mais rapidamente.
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 consulta 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 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.
Para obter mais informações sobre como projetar seu modelo de dados e escolher índices apropriados para seu aplicativo, consulte a documentação do MongoDB Server sobre Estratégias de indexação e Modelagem de dados e índices.
Listar índices
Você pode usar o método listIndexes()
para listar todos os índices de uma coleção. O método listIndexes() utiliza um parâmetro ListIndexesOptions opcional. O método listIndexes()
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); }
Tipos de índice
O MongoDB suporta vários tipos de índice diferentes para auxiliar na consulta de seus dados. As seções a seguir descrevem os tipos de índice mais comuns e fornecem código de amostra para criar cada tipo de índice.
Í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}`);
A seguir, um exemplo de uma query que é 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}`);
A seguir, um exemplo de uma query que é 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 que não são multichave em termos de cobertura de query, computação vinculada a índice e comportamento de classificação. Para obter uma explicação completa sobre os índices multichave, 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 queries 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 campostitle
ebody
na coleçãoblogPosts
Especifique
english
como o idioma padrãoDefinir o peso do campo de
body
para10
etitle
para3
// 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 2dsphere, você deve especificar um campo que contenha somente objetos GeoJSON. Para mais detalhes sobre este tipo, consulte a página manual do MongoDB Server 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 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.
Índices de pesquisa
Atlas Search é um recurso que permite realizar Full Text Searches. Para saber mais, consulte a documentação da Pesquisa do Atlas .
Antes de executar uma pesquisa em uma coleção do Atlas, você deve primeiro criar um índice de Atlas Search na coleção. Um índice do Atlas Search é uma estrutura de dados que categoriza os dados em um formato pesquisável.
Você pode usar os seguintes métodos para gerenciar seus índices de pesquisa:
createSearchIndex()
createSearchIndexes()
listSearchIndexes()
updateSearchIndex()
dropSearchIndex()
As seções a seguir fornecem amostras de código que usam cada um dos métodos anteriores para gerenciar índices de pesquisa.
Criar um índice de pesquisa
Você pode usar os métodos createSearchIndex() e createSearchIndexes() 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 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:
// 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 método 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 método 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");