Menu Docs
Página inicial do Docs
/
Manual do MongoDB
/

Gerenciar índices

Nesta página

  • Ver índices existentes
  • Remover índices
  • Modificar um Índice
  • Encontrar Índices Inconsistentes entre Shards

Esta página mostra como gerenciar índices existentes. Para obter instruções sobre como criar índices, consulte as páginas específicas do tipo de índice.

As seções a seguir fornecem métodos para exibir índices existentes em uma collection ou em um banco de dados inteiro.

Para retornar uma lista de todos os índices em uma coleção, use o método db.collection.getIndexes() ou um método semelhante para seu driver.

Por exemplo, para visualizar todos os índices na collection people, execute o seguinte comando:

db.people.getIndexes()

Para listar todos os índices de coleção em um banco de dados, execute o seguinte comando em mongosh:

db.getCollectionNames().forEach(function(collection) {
indexes = db[collection].getIndexes();
print("Indexes for " + collection + ":");
printjson(indexes);
});

Para listar todos os índices de um determinado tipo (como hashed ou texto) para todas as coleções em todos os bancos de dados, execute o seguinte comando em mongosh:

// The following finds all hashed indexes
db.adminCommand("listDatabases").databases.forEach(function(d){
let mdb = db.getSiblingDB(d.name);
mdb.getCollectionInfos({ type: "collection" }).forEach(function(c){
let currentCollection = mdb.getCollection(c.name);
currentCollection.getIndexes().forEach(function(idx){
let idxValues = Object.values(Object.assign({}, idx.key));
if (idxValues.includes("hashed")) {
print("Hashed index: " + idx.name + " on " + d.name + "." + c.name);
printjson(idx);
};
});
});
});

Para ver uma lista de todos os índices em uma coleção no MongoDB Compass, clique na coleção de destino no painel esquerdo e selecione a aba Indexes.

Exibir índices em uma coleção no Compass

Para obter detalhes sobre as informações exibidas nessa guia, consulte a documentação do Compass.

Dica

Ocultar um índice antes de descartá-lo

Se você descartar um índice utilizado ativamente na produção, seu aplicativo poderá sofrer degradação no desempenho. Antes de descartar um índice, você pode avaliar o impacto potencial da queda ocultando o índice.

Índices ocultos não são usados para dar suporte a consultas. Se você ocultar um índice e observar um impacto negativo substancial no desempenho, considere manter e exibir o índice para que as consultas possam continuar a usá-lo.

Para saber como remover um índice existente, consulte Soltar um índice.

Para saber como remover um índice no MongoDB Compass, consulte Gerenciar índices no Compass.

Para modificar um índice existente na Shell MongoDB, você precisa soltar e recriar o índice. A exceção a esta regra é para Índices TTL, que podem ser modificados pelo comando collMod em conjunto com a bandeira de collection index.

Para modificar um índice existente no MongoDB Compass, você precisa descartar e recriar o índice.

Se você descartar um índice que é usado ativamente na produção, seu aplicativo poderá sofrer degradação de desempenho. Para garantir que as consultas ainda possam usar um índice durante a modificação, você pode criar um índice temporário e redundante que contenha os mesmos campos que o índice modificado.

Este exemplo cria um novo índice e modifica esse índice para torná-lo exclusivo.

1

Execute este comando:

db.siteAnalytics.createIndex( { "url": 1 } )

O comando retorna o nome do índice:

url_1
2

Execute este comando:

db.siteAnalytics.createIndex( { "url": 1, "dummyField": 1 } )

O comando retorna o nome do índice:

url_1_dummyField_1

Este índice temporário permite descartar com segurança o índice { "url": 1 } original sem afetar o desempenho.

3

Execute este comando:

db.siteAnalytics.dropIndex( { "url_1" } )

O comando retorna:

{ nIndexesWas: 3, ok: 1 }
4

Execute este comando:

db.siteAnalytics.createIndex( { "url": 1 }, { "unique": true } )

O comando retorna o nome do índice:

url_1

O índice url_1 é recriado e você pode descartar o índice temporário sem afetar o desempenho. As consultas no campo url podem usar o novo índice exclusivo.

5

Execute este comando:

db.siteAnalytics.dropIndex( { "url_1_dummyField_1" } )

O comando retorna:

{ nIndexesWas: 3, ok: 1 }
6

Para ver os índices da coleção siteAnalytics, execute este comando:

db.siteAnalytics.getIndexes()

O comando retorna estes índices, indicando que o índice url_1 agora é único:

[
{ v: 2, key: { _id: 1 }, name: '_id_' },
{ v: 2, key: { url: 1 }, name: 'url_1', unique: true }
]

Uma collection fragmentada tem um índice inconsistente se a collection não tiver exatamente os mesmos índices (incluindo as opções de índices) em cada shard que contém chunks para a collection. Embora índices inconsistentes não devam ocorrer durante operações normais, eles podem ocorrer, como:

  • Quando um usuário está criando um índice com uma restrição de chave unique e um fragmento contém um bloco com documentos duplicados. Nesses casos, a operação de criação do índice pode ser bem-sucedida nos fragmentos sem duplicatas, mas não no fragmento com duplicatas.

  • Quando um usuário está criando um índice nos fragmentos de maneira contínua (ou seja, criando manualmente o índice um a um nos fragmentos), mas não consegue criar o índice para um fragmento associado ou cria incorretamente um índice com especificação diferente.

O servidor de configuração primário, por padrão, verifica se há inconsistências de índice nos fragmentos de coleções fragmentadas, e o comando serverStatus, quando executado no servidor de configuração primário, retorna o campo shardedIndexConsistency para relatar o número de coleções fragmentadas com inconsistências de índice.

Se shardedIndexConsistency informar alguma inconsistência de índice, você poderá executar o seguinte pipeline para suas coleção fragmentadas até encontrar as inconsistências.

  1. Defina o seguinte pipeline de agregação:

    const pipeline = [
    // Get indexes and the shards that they belong to.
    {$indexStats: {}},
    // Attach a list of all shards which reported indexes to each document from $indexStats.
    {$group: {_id: null, indexDoc: {$push: "$$ROOT"}, allShards: {$addToSet: "$shard"}}},
    // Unwind the generated array back into an array of index documents.
    {$unwind: "$indexDoc"},
    // Group by index name.
    {
    $group: {
    "_id": "$indexDoc.name",
    "shards": {$push: "$indexDoc.shard"},
    // Convert each index specification into an array of its properties
    // that can be compared using set operators.
    "specs": {$push: {$objectToArray: {$ifNull: ["$indexDoc.spec", {}]}}},
    "allShards": {$first: "$allShards"}
    }
    },
    // Compute which indexes are not present on all targeted shards and
    // which index specification properties aren't the same across all shards.
    {
    $project: {
    missingFromShards: {$setDifference: ["$allShards", "$shards"]},
    inconsistentProperties: {
    $setDifference: [
    {$reduce: {
    input: "$specs",
    initialValue: {$arrayElemAt: ["$specs", 0]},
    in: {$setUnion: ["$$value", "$$this"]}}},
    {$reduce: {
    input: "$specs",
    initialValue: {$arrayElemAt: ["$specs", 0]},
    in: {$setIntersection: ["$$value", "$$this"]}}}
    ]
    }
    }
    },
    // Only return output that indicates an index was inconsistent, i.e. either a shard was missing
    // an index or a property on at least one shard was not the same on all others.
    {
    $match: {
    $expr:
    {$or: [
    {$gt: [{$size: "$missingFromShards"}, 0]},
    {$gt: [{$size: "$inconsistentProperties"}, 0]},
    ]
    }
    }
    },
    // Output relevant fields.
    {$project: {_id: 0, indexName: "$$ROOT._id", inconsistentProperties: 1, missingFromShards: 1}}
    ];
  2. Execute o pipeline de agregação para testar a coleção fragmentada. Por exemplo, para testar se a coleção fragmentada test.reviews tem índices inconsistentes em seus fragmentos associados:

    db.getSiblingDB("test").reviews.aggregate(pipeline)

    Se a coleção tiver índices inconsistentes, a agregação para essa coleção retornará detalhes sobre os índices inconsistentes:

    { "missingFromShards" : [ "shardB" ], "inconsistentProperties" : [ ], "indexName" : "page_1_score_1" }
    { "missingFromShards" : [ ], "inconsistentProperties" : [ { "k" : "expireAfterSeconds", "v" : 60 }, { "k" : "expireAfterSeconds", "v" : 600 } ], "indexName" : "reviewDt_1" }

    Os documentos devolvidos indicam duas inconsistências para a coleção fragmentada test.reviews:

    1. Um índice chamado page_1_score_1 está faltando na coleção em shardB.

    2. Um índice nomeado reviewDt_1 tem propriedades inconsistentes ao longo coleções fragmentadas, especificamente, as propriedades expireAfterSeconds diferem.

Para resolver a inconsistência em que um índice estiver ausente da coleção em um fragmento específico,

Você também pode:

Para resolver onde as propriedades do índice diferem entre os fragmentos,

Descarte o índice incorreto da coleção nos fragmentos afetados e recrie o índice. Para recriar o índice, você pode:

Como alternativa, se a inconsistência for a propriedade expireAfterSeconds, você poderá executar o comando collMod para atualizar o número de segundos em vez de descartar e recriar o índice.

Voltar

Criar em clusters fragmentados