mongodb 3.0+ 查询性能分析

mongodb性能分析方法：explain()

为了演示的效果，我们先来创建一个有200万个文档的记录。（我自己的电脑耗了15分钟左右插入完成。如果你想插更多的文档也没问题，只要有耐心等就可以了。）

  1.  for(var i=0;i<2000000;i++){
  2.      db.person.insert({"name":"ryan"+i,"age":i});
  3.  }

explain查询性能分析 - 图1

MongoDB 3.0之后，explain的返回与使用方法与之前版本有了很大的变化，介于3.0之后的优秀特色和我们目前所使用给的是3.0.7版本，本文仅针对MongoDB 3.0+的explain进行讨论。

3.0+的explain有三种模式，分别是：queryPlanner、executionStats、allPlansExecution。现实开发中，常用的是executionStats模式，主要分析这种模式。

给这个person集合创建age键的索引：db.person.createIndex({"age":1})

  1. {
  2.     "queryPlanner" : {
  3.         "plannerVersion" : 1,
  4.         "namespace" : "personmap.person",
  5.         "indexFilterSet" : false,
  6.         "parsedQuery" : {
  7.             "age" : {
  8.                 "$lte" : 2000.0
  9.             }
  10.         },
  11.         "winningPlan" : {
  12.             "stage" : "FETCH",
  13.             "inputStage" : {
  14.                 "stage" : "IXSCAN",
  15.                 "keyPattern" : {
  16.                     "age" : 1.0
  17.                 },
  18.                 "indexName" : "age_1",
  19.                 "isMultiKey" : false,
  20.                 "direction" : "forward",
  21.                 "indexBounds" : {
  22.                     "age" : [ 
  23.                         "[-1.#INF, 2000.0]"
  24.                     ]
  25.                 }
  26.             }
  27.         },
  28.         "rejectedPlans" : []
  29.     },
  30.     "executionStats" : {
  31.         "executionSuccess" : true,
  32.         "nReturned" : 2001,
  33.         "executionTimeMillis" : 143,
  34.         "totalKeysExamined" : 2001,
  35.         "totalDocsExamined" : 2001,
  36.         "executionStages" : {
  37.             "stage" : "FETCH",
  38.             "nReturned" : 2001,
  39.             "executionTimeMillisEstimate" : 0,
  40.             "works" : 2002,
  41.             "advanced" : 2001,
  42.             "needTime" : 0,
  43.             "needFetch" : 0,
  44.             "saveState" : 16,
  45.             "restoreState" : 16,
  46.             "isEOF" : 1,
  47.             "invalidates" : 0,
  48.             "docsExamined" : 2001,
  49.             "alreadyHasObj" : 0,
  50.             "inputStage" : {
  51.                 "stage" : "IXSCAN",
  52.                 "nReturned" : 2001,
  53.                 "executionTimeMillisEstimate" : 0,
  54.                 "works" : 2002,
  55.                 "advanced" : 2001,
  56.                 "needTime" : 0,
  57.                 "needFetch" : 0,
  58.                 "saveState" : 16,
  59.                 "restoreState" : 16,
  60.                 "isEOF" : 1,
  61.                 "invalidates" : 0,
  62.                 "keyPattern" : {
  63.                     "age" : 1.0
  64.                 },
  65.                 "indexName" : "age_1",
  66.                 "isMultiKey" : false,
  67.                 "direction" : "forward",
  68.                 "indexBounds" : {
  69.                     "age" : [ 
  70.                         "[-1.#INF, 2000.0]"
  71.                     ]
  72.                 },
  73.                 "keysExamined" : 2001,
  74.                 "dupsTested" : 0,
  75.                 "dupsDropped" : 0,
  76.                 "seenInvalidated" : 0,
  77.                 "matchTested" : 0
  78.             }
  79.         }
  80.     },
  81.     "serverInfo" : {
  82.         "host" : "qinxiongzhou",
  83.         "port" : 27017,
  84.         "version" : "3.0.7",
  85.         "gitVersion" : "6ce7cbe8c6b899552dadd907604559806aa2e9bd"
  86.     },
  87.     "ok" : 1.0
  88. }
  90. db.getCollection('person').find({"age":{"$lte":2000}}).explain("executionStats")

对queryPlanner分析

queryPlanner: queryPlanner的返回

queryPlanner.namespace: 该值返回的是该query所查询的表

queryPlanner.indexFilterSet: 针对该query是否有indexfilter

queryPlanner.winningPlan: 查询优化器针对该query所返回的最优执行计划的详细内容。

queryPlanner.winningPlan.stage: 最优执行计划的stage，这里返回是FETCH，可以理解为通过返回的index位置去检索具体的文档（stage有数个模式，将在后文中进行详解）。

queryPlanner.winningPlan.inputStage: 用来描述子stage，并且为其父stage提供文档和索引关键字。

queryPlanner.winningPlan.stage的child stage， 此处是IXSCAN，表示进行的是index scanning。

queryPlanner.winningPlan.keyPattern: 所扫描的index内容，此处是did:1,status:1,modify_time: -1与scid : 1

queryPlanner.winningPlan.indexName：winning plan所选用的index。

queryPlanner.winningPlan.isMultiKey: 是否是Multikey，此处返回是false，如果索引建立在array上，此处将是true。

queryPlanner.winningPlan.direction：此query的查询顺序，此处是forward，如果用了.sort({modify_time:-1})将显示backward。

queryPlanner.winningPlan.indexBounds: winningplan所扫描的索引范围,如果没有制定范围就是[MaxKey, MinKey]，这主要是直接定位到mongodb的chunck中去查找数据，加快数据读取。

queryPlanner.rejectedPlans：其他执行计划（非最优而被查询优化器reject的）的详细返回，其中具体信息与winningPlan的返回中意义相同，故不在此赘述。

对executionStats返回逐层分析

第一层，executionTimeMillis

最为直观explain返回值是executionTimeMillis值，指的是我们这条语句的执行时间，这个值当然是希望越少越好。

其中有3个executionTimeMillis，分别是：

executionStats.executionTimeMillis: 该query的整体查询时间。

executionStats.executionStages.executionTimeMillisEstimate: 该查询根据index去检索document获得2001条数据的时间。

executionStats.executionStages.inputStage.executionTimeMillisEstimate: 该查询扫描2001行index所用时间。

第二层，index与document扫描数与查询返回条目数

  1. 这个主要讨论3个返回项，**nReturned、totalKeysExamined、totalDocsExamined，**
  3. 分别代表该条**查询返回的条目、索引扫描条目、文档扫描条目。**
  5. 这些都是直观地影响到 executionTimeMillis，我们需要扫描的越少速度越快。
  7. 对于一个查询，我们最理想的状态是：
  9. nReturned=totalKeysExamined=totalDocsExamined

第三层，stage状态分析

那么又是什么影响到了totalKeysExamined和totalDocsExamined？是stage的类型。类型列举如下：

COLLSCAN：全表扫描

IXSCAN：索引扫描

FETCH：根据索引去检索指定document

SHARD_MERGE：将各个分片返回数据进行merge

SORT：表明在内存中进行了排序

LIMIT：使用limit限制返回数

SKIP：使用skip进行跳过

IDHACK：针对_id进行查询

SHARDING_FILTER：通过mongos对分片数据进行查询

COUNT：利用db.coll.explain().count()之类进行count运算

COUNTSCAN： count不使用Index进行count时的stage返回

COUNT_SCAN： count使用了Index进行count时的stage返回

SUBPLA：未使用到索引的$or查询的stage返回

TEXT：使用全文索引进行查询时候的stage返回

PROJECTION：限定返回字段时候stage的返回

对于普通查询，我希望看到stage的组合(查询的时候尽可能用上索引)：

Fetch+IDHACK

Fetch+ixscan

Limit+（Fetch+ixscan）

PROJECTION+ixscan

SHARDING_FITER+ixscan

COUNT_SCAN

不希望看到包含如下的stage：

COLLSCAN(全表扫描)

SORT(使用sort但是无index)

不合理的SKIP

SUBPLA(未用到index的$or)

COUNTSCAN(不使用index进行count)