Gerenciar índices

Ver índices existentes

MongoDB Shell

Compass

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

Listar todos os índices em uma collection

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()

Listar todos os índices para um banco de dados

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);
});

Listar tipos específicos de índices

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.

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

Remover índices

MongoDB Shell

Compass

Ao remover índices no MongoDB Shell, você pode:

• Remova um índice específico.

• Remova todos os índices da coleção.

Remover índice específico

Para remover um índice, use o método db.collection.dropIndex() .

Por exemplo, a seguinte operação remove um índice ascendente no campo tax-id na collection accounts :

db.accounts.dropIndex( { "tax-id": 1 } )

A operação retorna um documento com o status da operação:

{ "nIndexesWas" : 3, "ok" : 1 }

Onde o valor de nIndexesWas reflete o número de índices antes de remover este índice.

Para índices de texto , passe o nome do índice para o método db.collection.dropIndex() . Consulte Usar o nome do índice para descartar um índice text para obter detalhes.

Observação

db.collection.dropIndexes() pode aceitar uma array de nomes de índice.

db.collection.dropIndexes() pode interromper a criação de índices em andamento. Consulte Interromper as Compilações de Índices em Andamento para obter mais informações.

Remover todos os índices

Você também pode usar o db.collection.dropIndexes() para remover todos os índices, exceto o índice _id de uma collection.

Por exemplo, o seguinte comando remove todos os índices da coleção accounts :

db.accounts.dropIndexes()

Esses ajudantes de shell fornecem wrappers em torno do comando dropIndexes database. Sua biblioteca cliente pode ter uma interface diferente ou adicional para essas operações.

Para remover um índice de uma collection no MongoDB Compass:

1. Navegue até a coleção que contém o índice de destino.

2. Clique na aba Indexes.

3. Na coluna Drop do índice de destino, clique no ícone da lixeira.

Modificar um Índice

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

url_1

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

url_1_dummyField_1

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

{ nIndexesWas: 3, ok: 1 }

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

url_1

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

{ nIndexesWas: 3, ok: 1 }

db.siteAnalytics.getIndexes()

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

Encontrar Índices Inconsistentes entre Shards

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:

• Execute uma criação de índice em rotação para a coleção no(s) fragmento(s) afetado(s).

  -OU-

• Emita uma criação de índice db.collection.createIndex() a partir de uma instância mongos. A operação só cria o índice da coleção nos fragmentos que não possuem o índice.

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:

• Execute uma criação de índice em rotação para a coleção no fragmento afetado.

  -OU-

• Emita uma criação de índice db.collection.createIndex() a partir de uma instância mongos. A operação só cria o índice da coleção nos fragmentos que não possuem o índice.

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.