Manage Indexes管理索引

View Existing Indexes查看现有索引

MongoDB ShellCompass

The following sections provide methods for viewing existing indexes on a collection or an entire database.以下部分提供了查看集合或整个数据库上现有索引的方法。

To view a list of all indexes on a collection in MongoDB Compass, click on the target collection in the left-hand pane and select the Indexes tab.要查看MongoDB Compass中集合上所有索引的列表，请单击左侧窗格中的目标集合并选择“索引”选项卡。

click to enlarge

For details on the information displayed in this tab, refer to the Compass documentation.有关此选项卡中显示的信息的详细信息，请参阅Compass文档。

db.people.getIndexes()

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

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

Remove Indexes删除索引

MongoDB ShellCompass

When removing indexes in the MongoDB Shell, you can either:在MongoDB Shell中删除索引时，您可以：

• Remove a specific index.删除特定索引。

• Remove all indexes from the collection.从集合中删除所有索引。

Remove Specific Index删除特定索引

To remove an index, use the db.collection.dropIndex() method.要删除索引，请使用db.collection.dropIndex()方法。

For example, the following operation removes an ascending index on the tax-id field in the accounts collection:例如，以下操作将删除accounts集合中tax-id字段上的升序索引：

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

The operation returns a document with the status of the operation:该操作返回一个文档，其中包含该操作的状态：

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

Where the value of nIndexesWas reflects the number of indexes before removing this index.其中nIndexesWas的值反映了删除此索引之前的索引数。

For text indexes, pass the index name to the db.collection.dropIndex() method. 对于text索引，将索引名称传递给db.collection.dropIndex()方法。See Use the Index Name to Drop a text Index for details.有关详细信息，请参阅使用索引名称删除text索引。

Note注意

Starting in MongoDB 4.2, db.collection.dropIndexes() can accept an array of index names.从MongoDB 4.2开始，db.collection.dropIndexes()可以接受索引名称数组。

Starting in MongoDB 4.4, db.collection.dropIndexes() can stop in-progress index builds. 从MongoDB 4.4开始，db.collection.dropIndexes()可以停止正在进行的索引构建。See Stop In-Progress Index Builds for more information.有关详细信息，请参阅停止进行中的索引生成。

Remove All Indexes删除所有索引

You can also use the db.collection.dropIndexes() to remove all indexes except for the _id index from a collection.您还可以使用db.collection.dropIndexes()从集合中删除除_id索引之外的所有索引。

For example, the following command removes all indexes from the accounts collection:例如，以下命令从accounts集合中删除所有索引：

db.accounts.dropIndexes()

These shell helpers provide wrappers around the dropIndexes database command. 这些shell助手为dropIndexes数据库命令提供包装。Your client library may have a different or additional interface for these operations.对于这些操作，您的客户端库可能具有不同的或附加的接口。

To remove an index from a collection in MongoDB Compass:要从MongoDB Compass中的集合中删除索引，请执行以下操作：

1. Navigate to the collection containing the target index.导航到包含目标索引的集合。

2. Click the Indexes tab.单击“索引”选项卡。

3. In the Drop column for the target index, click the trash icon.在目标索引的“放置”列中，单击回收站图标。

Modify an Index修改索引

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

Find Inconsistent Indexes Across Shards跨分片查找不一致的索引

A sharded collection has an inconsistent index if the collection does not have the exact same indexes (including the index options) on each shard that contains chunks for the collection. 如果集合在包含集合块的每个分片上没有完全相同的索引（包括索引选项），则分片集合具有不一致的索引。Although inconsistent indexes should not occur during normal operations, inconsistent indexes can occur , such as:尽管在正常操作期间不应出现不一致的索引，但可能会出现不一致索引，例如：

• When a user is creating an index with a unique key constraint and one shard contains a chunk with duplicate documents. 当用户使用unique键约束创建索引时，一个分片包含一个包含重复文档的块。In such cases, the create index operation may succeed on the shards without duplicates but not on the shard with duplicates.在这种情况下，创建索引操作可能在没有重复项的分片上成功，但在有重复项的分片上失败。

• When a user is creating an index across the shards in a rolling manner (i.e. manually building the index one by one across the shards) but either fails to build the index for an associated shard or incorrectly builds an index with different specification.当用户以滚动方式在分片上创建索引时（即，在分片上一个接一个地手动构建索引），但未能为相关分片构建索引，或者使用不同的规范错误地构建索引。

Starting in MongoDB 4.4 (and 4.2.6), the config server primary, by default, checks for index inconsistencies across the shards for sharded collections, and the command serverStatus, when run on the config server primary, returns the field shardedIndexConsistency field to report on the number of sharded collections with index inconsistencies.从MongoDB 4.4（和4.2.6）开始，默认情况下，配置服务器 primary会检查分片集合中的索引不一致，而在配置服务器primary上运行的命令serverStatus会返回字段shardedIndexConsistency，以报告索引不一致的分片集合数。

If shardedIndexConsistency reports any index inconsistencies, you can run the following pipeline for your sharded collections until you find the inconsistencies.如果shardedIndexConsistency报告了任何索引不一致，您可以为分片集合运行以下管道，直到找到不一致。

1. Define the following aggregation pipeline:定义以下聚合管道：

   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. Run the aggregation pipeline for the sharded collection to test. 运行要测试的分片集合的聚合管道。For example, to test if the sharded collection test.reviews has inconsistent indexes across its associated shards:例如，要测试分片集合test.reviews是否在其关联的分片上具有不一致的索引：

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

   If the collection has inconsistent indexes, the aggregation for that collection returns details regarding the inconsistent indexes:如果集合具有不一致的索引，则该集合的聚合将返回有关不一致索引的详细信息：

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

   The returned documents indicate two inconsistencies for the sharded collection test.reviews:返回的文档表明分片集合test.reviews有两个不一致之处：

   1. An index named page_1_score_1 is missing from the collection on shardB.shardB上的集合中缺少名为page_1_score_1的索引。

   2. An index named reviewDt_1 has inconsistent properties across the collection's shards, specifically, the expireAfterSeconds properties differ.名为reviewDt_1的索引在集合的分片中具有不一致的属性，具体而言，expireAfterSeconds属性不同。

To resolve the inconsistency where an index is missing from the collection on a particular shard(s),为了解决在特定分片上的集合中缺少索引的不一致性，

You can either:您可以：

• Perform a rolling index build for the collection on the affected shard(s).对受影响的分片上的集合执行滚动索引构建。

  -OR-

• Issue an index build db.collection.createIndex() from a mongos instance. 从mongos实例发出索引构建。The operation only builds the collection's index on the shard(s) missing the index.该操作仅在缺少索引的分片上构建集合的索引。

To resolve where the index properties differ across the shards,为了解决在分片上索引属性不同的地方，

Drop the incorrect index from the collection on the affected shard(s) and rebuild the index. 从受影响的分片上的集合中删除不正确的索引并重新生成索引。To rebuild the index, you can either:要重建索引，您可以：

• Perform a rolling index build for the collection on the affected shard.对受影响的分片上的集合执行滚动索引构建。

  -OR-

• Issue an index build db.collection.createIndex() from a mongos instance. 从mongos实例发出索引构建db.collection.createIndex()。The operation only builds the collection's index on the shard(s) missing the index.该操作仅在缺少索引的分片上构建集合的索引。

Alternatively, if the inconsistency is the expireAfterSeconds property, you can run the collMod command to update the number of seconds instead of dropping and rebuilding the index.或者，如果不一致性是expireAfterSeconds属性，则可以运行collMod命令来更新秒数，而不是删除和重建索引。