分析查询性能_MonogDB 中文网

MongoDB 中文手册

参考 > MongoDB CRUD操作 > MongoDB CRUD概念 > 分析查询性能

在本页面

评估查询的性能

蒙哥·壳
罗盘

该 cursor.explain("executionStats") 和db.collection.explain("executionStats")方法提供了有关查询的性能统计信息。这些统计信息可用于衡量查询是否以及如何使用索引。

db.collection.explain()提供有关其他操作执行的信息，例如db.collection.update()。有关db.collection.explain()详细信息，请参见。

MongoDB Compass提供了一个“ 解释计划” 选项卡，该选项卡显示有关查询性能的统计信息。这些统计信息可用于衡量查询是否以及如何使用索引。

评估查询的性能¶

考虑inventory包含以下文档的集合：

{ "_id" : 1, "item" : "f1", type: "food", quantity: 500 }
{ "_id" : 2, "item" : "f2", type: "food", quantity: 100 }
{ "_id" : 3, "item" : "p1", type: "paper", quantity: 200 }
{ "_id" : 4, "item" : "p2", type: "paper", quantity: 150 }
{ "_id" : 5, "item" : "f3", type: "food", quantity: 300 }
{ "_id" : 6, "item" : "t1", type: "toys", quantity: 500 }
{ "_id" : 7, "item" : "a1", type: "apparel", quantity: 250 }
{ "_id" : 8, "item" : "a2", type: "apparel", quantity: 400 }
{ "_id" : 9, "item" : "t2", type: "toys", quantity: 50 }
{ "_id" : 10, "item" : "f4", type: "food", quantity: 75 }

罗盘

这些文档在MongoDB Compass中的显示如下：

指南针库存收集文件

查询与无索引¶

蒙哥·壳
罗盘

以下查询检索该quantity字段的值介于100和之间200（含）的文档：

db.inventory.find( { quantity: { $gte: 100, $lte: 200 } } )

该查询返回以下文档：

{ "_id" : 2, "item" : "f2", "type" : "food", "quantity" : 100 }
{ "_id" : 3, "item" : "p1", "type" : "paper", "quantity" : 200 }
{ "_id" : 4, "item" : "p2", "type" : "paper", "quantity" : 150 }

要查看所选的查询计划，请将 cursor.explain("executionStats") 游标方法链接到find命令的末尾：

db.inventory.find(
   { quantity: { $gte: 100, $lte: 200 } }
).explain("executionStats")

explain() 返回以下结果：

{
   "queryPlanner" : {
         "plannerVersion" : 1,
         ...
         "winningPlan" : {
            "stage" : "COLLSCAN",
            ...
         }
   },
   "executionStats" : {
      "executionSuccess" : true,
      "nReturned" : 3,
      "executionTimeMillis" : 0,
      "totalKeysExamined" : 0,
      "totalDocsExamined" : 10,
      "executionStages" : {
         "stage" : "COLLSCAN",
         ...
      },
      ...
   },
   ...
}

queryPlanner.winningPlan.stage显示 COLLSCAN以指示收集扫描。

集合扫描表明， mongod必须逐个文档扫描整个集合文档以识别结果。这通常是一项昂贵的操作，并且可能导致查询缓慢。
executionStats.nReturned显示3表示查询匹配并返回三个文档。
executionStats.totalKeysExamined显示0 以指示这是查询未使用索引。
executionStats.totalDocsExamined显示10 以指示MongoDB必须扫描十个文档（即集合中的所有文档）才能找到三个匹配的文档。

以下查询检索该quantity字段的值介于100和之间200（含）的文档：

将以下过滤器复制到“指南针”查询栏中，然后单击“ 查找”：

{ quantity: { $gte: 100, $lte: 200 } }

该查询返回以下文档：

指南针无索引查询结果

要查看所选的查询计划：

单击集合的“ 解释计划”选项卡 test.inventory。
单击解释。

MongoDB Compass显示查询计划，如下所示：

指南针无索引查询计划

注意

因为在本教程中我们正在使用如此小的数据集，所以即使我们没有使用索引，“ 实际查询执行时间”0也会显示秒。

在更大的数据集中，索引查询与非索引查询之间的查询执行时间差异会更大。

视觉树

该查询性能概要显示查询的执行统计：
- 显示“返回的文档”3以指示查询匹配并返回三个文档。
- 显示“ 已检查索引键”0以指示此查询未使用索引。
- 已检查的文档显示10表明MongoDB必须扫描十个文档（即集合中的所有文档）才能找到三个匹配的文档。
在“ 查询性能摘要”下，MongoDB Compass显示COLLSCAN查询阶段，以指示对该查询使用了集合扫描。

集合扫描表明， mongod必须逐个文档扫描整个集合文档以识别结果。这通常是一项昂贵的操作，并且可能导致查询缓慢。

原始JSON

也可以通过单击查询栏下方的Raw JSON以原始JSON格式查看说明详细信息：

指南针无索引查询计划原始JSON

匹配文档数和已检查文档数之间的差异可能表明，为了提高效率，查询可能会受益于索引的使用。

查询与索引¶

要支持对该quantity字段的查询，请在该字段上添加一个索引 quantity：

蒙哥·壳
罗盘

db.inventory.createIndex( { quantity: 1 } )

要查看查询计划统计信息，请使用以下 explain("executionStats")方法：

db.inventory.find(
   { quantity: { $gte: 100, $lte: 200 } }
).explain("executionStats")

该explain()方法返回以下结果：

{
   "queryPlanner" : {
         "plannerVersion" : 1,
         ...
         "winningPlan" : {
               "stage" : "FETCH",
               "inputStage" : {
                  "stage" : "IXSCAN",
                  "keyPattern" : {
                     "quantity" : 1
                  },
                  ...
               }
         },
         "rejectedPlans" : [ ]
   },
   "executionStats" : {
         "executionSuccess" : true,
         "nReturned" : 3,
         "executionTimeMillis" : 0,
         "totalKeysExamined" : 3,
         "totalDocsExamined" : 3,
         "executionStages" : {
            ...
         },
         ...
   },
   ...
}

queryPlanner.winningPlan.inputStage.stage显示 IXSCAN以指示索引的使用。
executionStats.nReturned 显示3表示查询匹配并返回三个文档。
executionStats.totalKeysExamined显示3 以指示MongoDB扫描了三个索引条目。检查的键数与返回的文档数相匹配，这意味着mongod只需检查索引键即可返回结果。在 mongod没有扫描所有的文件，只有三个匹配文档不得不被拉入内存中。这导致非常有效的查询。
executionStats.totalDocsExamined屏幕显示3 MongoDB扫描了三个文档。

单击集合的“ 索引”选项卡 test.inventory。
点击创建索引。
选择quantity从选择一个字段名称下拉。
从类型下拉列表中选择。1 (asc)
点击创建。

在指南针中创建库存索引

返回到收集的“ 解释计划”选项卡， inventory然后从上一步重新运行查询：

{ quantity: { $gte: 100, $lte: 200 } }

MongoDB Compass显示查询计划，如下所示：

指南针用索引解释计划

视觉树

该查询性能概要显示查询的执行统计：
- 显示“返回的文档”3以指示查询匹配并返回三个文档。
- 显示“ 已检查索引键”3 以指示MongoDB扫描了三个索引条目。检查的键数与返回的文档数相匹配，这意味着mongod只需检查索引键即可返回结果。在 mongod没有扫描所有的文件，只有三个匹配文档不得不被拉入内存中。这导致非常有效的查询。
- 显示“已检查的文档”3以指示MongoDB扫描了三个文档。
- 在“ 查询性能摘要”的右侧，MongoDB Compass显示该查询使用了quantity索引。
在“ 查询性能摘要”下方，MongoDB Compass显示查询阶段FETCH和IXSCAN。 IXSCAN指示 mongod在执行FETCH阶段和检索文档之前使用索引来满足查询。

原始JSON

也可以通过单击查询栏下方的Raw JSON以原始JSON格式查看说明详细信息：

带有索引原始JSON的指南针查询计划

没有索引，查询将扫描整个10 文档集合以返回3匹配的文档。该查询还必须扫描每个文档的整体，可能会将它们拉入内存。这导致昂贵且可能缓慢的查询操作。

当使用索引运行时，查询会扫描3索引条目和3文档以返回3匹配的文档，从而产生非常高效的查询。

蒙哥·壳
罗盘

比较指数表现

若要手动比较使用多个索引的查询的性能，可以将该hint() 方法与该explain() 方法结合使用。

考虑以下查询：

db.inventory.find( {
   quantity: {
      $gte: 100, $lte: 300
   },
   type: "food"
} )

该查询返回以下文档：

{ "_id" : 2, "item" : "f2", "type" : "food", "quantity" : 100 }
{ "_id" : 5, "item" : "f3", "type" : "food", "quantity" : 300 }

要支持查询，请添加复合索引。对于复合索引，字段的顺序很重要。

例如，添加以下两个复合索引。第一个索引按quantity字段顺序排序，然后按 type字段排序。第二个索引按顺序排序type，然后按quantity字段排序。

db.inventory.createIndex( { quantity: 1, type: 1 } )
db.inventory.createIndex( { type: 1, quantity: 1 } )

评估第一个索引对查询的影响：

db.inventory.find(
   { quantity: { $gte: 100, $lte: 300 }, type: "food" }
).hint({ quantity: 1, type: 1 }).explain("executionStats")

该explain()方法返回以下输出：

{
   "queryPlanner" : {
      ...
      "winningPlan" : {
         "stage" : "FETCH",
         "inputStage" : {
            "stage" : "IXSCAN",
            "keyPattern" : {
               "quantity" : 1,
               "type" : 1
            },
            ...
            }
         }
      },
      "rejectedPlans" : [ ]
   },
   "executionStats" : {
      "executionSuccess" : true,
      "nReturned" : 2,
      "executionTimeMillis" : 0,
      "totalKeysExamined" : 5,
      "totalDocsExamined" : 2,
      "executionStages" : {
      ...
      }
   },
   ...
}

MongoDB扫描了5索引键（executionStats.totalKeysExamined）以返回2 匹配的文档（executionStats.nReturned）。

评估第二个索引对查询的影响：

db.inventory.find(
   { quantity: { $gte: 100, $lte: 300 }, type: "food" }
).hint({ type: 1, quantity: 1 }).explain("executionStats")

该explain()方法返回以下输出：

{
   "queryPlanner" : {
      ...
      "winningPlan" : {
         "stage" : "FETCH",
         "inputStage" : {
            "stage" : "IXSCAN",
            "keyPattern" : {
               "type" : 1,
               "quantity" : 1
            },
            ...
         }
      },
      "rejectedPlans" : [ ]
   },
   "executionStats" : {
      "executionSuccess" : true,
      "nReturned" : 2,
      "executionTimeMillis" : 0,
      "totalKeysExamined" : 2,
      "totalDocsExamined" : 2,
      "executionStages" : {
         ...
      }
   },
   ...
}

MongoDB扫描了2索引键（executionStats.totalKeysExamined）以返回2 匹配的文档（executionStats.nReturned）。

对于此示例查询，复合索引比复合索引效率更高。{ type: 1, quantity: 1 }{ quantity: 1, type: 1 }

也可以看看

查询优化，查询计划，优化查询性能，索引策略

也可以看看