Gestionar índices

Ver los índices existentes

MongoDB Shell

Compass

Las siguientes secciones proporcionan métodos para visualizar índices existentes en una colección o en una base de datos completa.

Lista todos los índices de una colección

Para devolver una lista de todos los índices de una colección, utilice el db.collection.getIndexes()Método o un método similar para su controlador.

Por ejemplo, para ver todos los índices de la colección people, ejecute el siguiente comando:

db.people.getIndexes()

Listar todos los índices de una base de datos

Para enumerar todos los índices de colección en una base de datos, ejecute el siguiente comando mongosh en:

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

Lista de tipos específicos de índices

Para enumerar todos los índices de un tipo determinado (como hash o texto) para todas las colecciones en todas las bases de datos, ejecute el siguiente comando mongosh en:

// 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 una lista de todos los índices de una colección en MongoDB Compass, haga clic en la colección de destino en el panel izquierdo y seleccione el Indexes tab.

Para más detalles sobre la información mostrada en esta pestaña, consulte la documentación de Compass.

Eliminar índices

MongoDB Shell

Compass

Cuando elimine índices en la Shell de MongoDB, puede:

• Eliminar un índice específico.

• Eliminar todos los índices de la colección.

Eliminar índice específico

Para eliminar un índice, utilice el db.collection.dropIndex() método.

Por ejemplo, la siguiente operación elimina un índice ascendente en el campo tax-id de la colección accounts:

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

La operación devuelve un documento con el estado de la operación:

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

Donde el valor de nIndexesWas refleja la cantidad de índices antes de eliminar este índice.

Para índices de texto, pase el nombre del índice al método. Consulte "Usar db.collection.dropIndex() el nombre del índice para eliminar un text índice " para obtener más información.

Nota

db.collection.dropIndexes() Puede aceptar una matriz de nombres de índice.

db.collection.dropIndexes() puede detener la creación de índices en curso. Consulte "Detener la creación de índices en curso" para obtener más información.

Eliminar todos los índices

También puedes usar el db.collection.dropIndexes() para remover todos los índices excepto el índice _id de una colección.

Por ejemplo, el siguiente comando elimina todos los índices de la colección accounts:

db.accounts.dropIndexes()

Estos ayudantes de shell proporcionan envoltorios para el comando de dropIndexes base de datos. Su biblioteca cliente puede tener una interfaz diferente o adicional para estas operaciones.

Para eliminar un índice de una colección en MongoDB Compass:

1. Navegue hasta la colección que contiene el índice de destino.

2. Haz clic en la pestaña Indexes.

3. En la columna Drop del índice de destino, haga clic en el icono de la papelera.

Modificar un í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 fragmentos

Una colección fragmentada tiene un índice incoherente si no tiene exactamente los mismos índices (incluidas las opciones de índice) en cada fragmento que contiene fragmentos de la colección. Aunque no deberían producirse índices incoherentes durante las operaciones normales, pueden ocurrir, por ejemplo:

• Cuando un usuario está creando un índice con una restricción de clave unique y una partición contiene un fragmento con documentos duplicados. En tales casos, la operación de creación de índice puede tener éxito en las particiones sin duplicados, pero no en la partición con duplicados.

• Cuando un usuario está compilando un índice en las particiones de forma continua (es decir, compilando manualmente el índice uno por uno en las particiones), pero no logra compilar el índice para una partición asociado o compila incorrectamente un índice con una especificación diferente.

De manera predeterminada, el servidor de configuración principal verifica si hay inconsistencias de índice en los fragmentos para las colecciones fragmentadas, y el serverStatus comando, cuando se ejecuta en el servidor de configuración principal, devuelve el campo shardedIndexConsistency para informar la cantidad de colecciones fragmentadas con inconsistencias de índice.

Si informa alguna inconsistencia en el índice, puede ejecutar la siguiente secuencia para sus colecciones fragmentadas hasta que encuentre las shardedIndexConsistency inconsistencias.

1. Defina la siguiente canalización de agregación:

   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. Ejecute el pipeline de agregación en la colección particionada para realizar una prueba. Por ejemplo, para probar si la colección particionada test.reviews tiene índices inconsistentes en sus particiones asociadas:

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

   Si la colección tiene índices inconsistentes, la agregación para esa colección devuelve detalles sobre los índices inconsistentes:

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

   Los documentos devueltos indican dos inconsistencias para la colección fragmentada test.reviews:

   1. Falta un índice llamado page_1_score_1 en la colección en shardB.

   2. Un índice denominado reviewDt_1 tiene propiedades inconsistentes entre las particiones de la colección; específicamente, las propiedades expireAfterSeconds difieren.

Para resolver la inconsistencia donde falta un índice de la colección en un fragmento en particular,

Puedes:

• Ejecute una compilación de índice db.collection.createIndex() desde una instancia. La operación solo compila el índice de la colección en los fragmentos que no lo mongos tienen.

  -O-

• Realice una compilación de índice móvil para la colección en los fragmentos afectados.

  Nota

  Los índices rotativos pueden afectar negativamente a la implementación. Para obtener información sobre cuándo usar esta compilación de índice, consulte Compilaciones de índices rotativos.

Para resolver dónde difieren las propiedades del índice entre los fragmentos,

Elimine el índice incorrecto de la colección en los fragmentos afectados y reconstruya el índice. Para ello, puede:

• Ejecute una compilación de índice db.collection.createIndex() desde una instancia. La operación solo compila el índice de la colección en los fragmentos que no lo mongos tienen.

  -O-

• Realice una compilación de índice móvil para la colección en el fragmento afectado.

  Nota

  Los índices rotativos pueden afectar negativamente a la implementación. Para obtener información sobre cuándo usar esta compilación de índice, consulte Compilaciones de índices rotativos.

Alternativamente, si la inconsistencia es la expireAfterSeconds propiedad, puede ejecutar el comando para actualizar la cantidad de segundos en lugar de eliminar y reconstruir el collMod índice.