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 en una colección, use el método db.collection.getIndexes() o un método similar para tu controlador.

Por ejemplo, para ver todos los índices de la colección people, ejecuta 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 listar todos los índices de un cierto tipo (como encriptada o text) para todas las colecciones en toda la base de datos, ejecuta el siguiente comando en 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 una lista de todos los índices en una colección en MongoDB Compass, haz clic en la colección objetivo en el panel izquierdo y selecciona la Indexes tab.

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

Remueva índices

MongoDB Shell

Compass

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

• Remover un índice específico.

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

Eliminar índice específico

Para remover un índice, utiliza el método db.collection.dropIndex().

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 los índices text, coloque el nombre del índice en el método db.collection.dropIndex(). Consulte Use el nombre del índice para descartar un índice text para obtener más detalles.

Nota

db.collection.dropIndexes() puede aceptar un arreglo de nombres de índices.

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

Remover 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 asistentes de shell proporcionan contenedores alrededor del dropIndexes comando de base de datos. Tu librería cliente podría tener una interfaz diferente o adicional para estas operaciones.

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

1. Navegue a la colección que contiene el índice objetivo.

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 }
]

Buscar índices inconsistentes entre particiones

Una colección particionada tiene un índice inconsistente si la colección no tiene exactamente los mismos índices (incluidas las opciones de índice) en cada partición que contiene fragmentos de la colección. Aunque no deberían ocurrir índices inconsistentes durante las operaciones normales, pueden ocurrir índices inconsistentes, como 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.

Por defecto, el servidor de configuración primario verifica la falta de coherencia de los índices entre las particiones para las colecciones particionadas. El comando serverStatus, cuando se ejecuta en el primario del servidor de configuración, devuelve el campo shardedIndexConsistency para informar sobre el número de colecciones particionadas con inconsistencias en los índices.

Si shardedIndexConsistency reporta alguna inconsistencia de los índices, puedes ejecutar el siguiente pipeline para tus colecciones particionadas hasta que encuentres la inconsistencia.

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 particionada 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:

• Emita una creación de índices db.collection.createIndex() desde una mongos instancia. La operación solo compila el índice de la colección en la partición o particiones que les falta el índice.

  -O-

• Realiza una creación de índices progresiva para la colección en la(s) partición(es) afectada(s).

  Nota

  Los índices continuos pueden afectar negativamente a su proceso de implementación. Para obtener información sobre cuándo usar esta creación de índices, consulta Construcciones de índice continuas.

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

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

• Emita una creación de índices db.collection.createIndex() desde una mongos instancia. La operación solo compila el índice de la colección en la partición o particiones que les falta el índice.

  -O-

• Realiza una creación de índices continua para la colección en la partición afectada.

  Nota

  Los índices continuos pueden afectar negativamente a su proceso de implementación. Para obtener información sobre cuándo usar esta creación de índices, consulta Construcciones de índice continuas.

Alternativamente, si la inconsistencia es la propiedad expireAfterSeconds, puede ejecutar el comando collMod para actualizar el número de segundos en lugar de eliminar y volver a crear el índice.