详解 MongoDB 索引优化

淡淡的烟草味﹌ 2023-09-26 11:05 60阅读 0赞

## 一、索引简介 ##

索引通常能够极大的提高查询的效率，如果没有索引，MongoDB 在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。

### 1.1 概念 ###

索引最常用的比喻就是书籍的目录，查询索引就像查询一本书的目录。本质上目录是将书中一小部分内容信息（比如题目）和内容的位置信息（页码）共同构成，而由于信息量小（只有题目），所以我们可以很快找到我们想要的信息片段，再根据页码找到相应的内容。同样索引也是只保留某个域的一部分信息（建立了索引的 field 的信息），以及对应的文档的位置信息。

> 假设我们有如下文档（每行的数据在 MongoDB 中是存在于一个 Document 当中）

<table> 
 <thead> 
  <tr> 
   <th>姓名</th> 
   <th>id</th> 
   <th>部门</th> 
   <th>city</th> 
   <th>score</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>张三</td> 
   <td>2</td> 
   <td>开发部</td> 
   <td>北京</td> 
   <td>90</td> 
  </tr> 
  <tr> 
   <td>李四</td> 
   <td>1</td> 
   <td>测试部</td> 
   <td>上海</td> 
   <td>70</td> 
  </tr> 
  <tr> 
   <td>王五</td> 
   <td>3</td> 
   <td>运维部</td> 
   <td>河北</td> 
   <td>60</td> 
  </tr> 
 </tbody> 
</table>

### 1.2 索引的作用 ###

假如我们想找 id 为 2 的 document (即张三的记录)，如果没有索引，我们就需要扫描整个数据表，然后找出所有 id 为 2 的 document。当数据表中有大量 documents 的时候，这个查询时间就会很长（从磁盘上查找数据还涉及大量的 IO 操作)。

此时建立索引后会有什么变化呢？MongoDB 会将 id 数据拿出来建立索引数据，如下：

此时，即可根据索引值快速得到原始数据的具体位置，从而获取完整的原始数据。

### 1.3 索引的工作原理 ###

这样我们就可以通过扫描这个小表找到 document 对应的位置。

查找过程示意图如下：

索引为什么这么快：

> 为什么这样速度会快呢？这主要有几方面的因素

1.  索引数据通过 B 树来存储，从而使得搜索的时间复杂度为 O (logdN) 级别的 (d 是 B 树的度，通常 d 的值比较大，比如大于 100)，比原先 O (N) 的复杂度大幅下降。这个差距是惊人的。
2.  索引本身是在高速缓存当中，相比磁盘 IO 操作会有大幅的性能提升。（需要注意的是，有的时候数据量非常大的时候，索引数据也会非常大，当大到超出内存容量的时候，会导致部分索引数据存储在磁盘上，这会导致磁盘 IO 的开销大幅增加，从而影响性能，所以务必要保证有足够的内存能容下所有的索引数据）

当然，事物总有其两面性，在提升查询速度的同时，由于要建立索引，所以写入操作时就需要额外的添加索引的操作，这必然会影响写入的性能，所以当有大量写操作而读操作比较少的时候，且对读操作性能不需要考虑的时候，就不适合建立索引。当然，目前大多数互联网应用都是读操作远大于写操作，因此建立索引很多时候是非常划算和必要的操作。

## 二、索引的优化 ##

### 2.1 执行计划 ###

> MongoDB 中的 `explain()` 函数可以帮助我们查看查询相关的信息，这有助于我们快速查找到搜索瓶颈进而解决它，我们接下来就看看 `explain()` 的一些用法及其查询结果的含义。

2.1.1 基本用法

> 先来看一个基本用法：

db.zips.find({"pop":99999}).explain()
    复制代码

直接跟在 `find()` 函数后面，表示查看 `find()` 函数的执行计划，结果如下：

{
            "queryPlanner" : {
                    "plannerVersion" : 1,
                    "namespace" : "zips-db.zips",
                    "indexFilterSet" : false,
                    "parsedQuery" : {
                            "pop" : {
                                    "$eq" : 99999
                            }
                    },
                    "queryHash" : "891A44E4",
                    "planCacheKey" : "2D13A19E",
                    "winningPlan" : {
                            "stage" : "FETCH",
                            "inputStage" : {
                                    "stage" : "IXSCAN",
                                    "keyPattern" : {
                                            "pop" : 1
                                    },
                                    "indexName" : "pop_1",
                                    "isMultiKey" : false,
                                    "multiKeyPaths" : {
                                            "pop" : [ ]
                                    },
                                    "isUnique" : false,
                                    "isSparse" : false,
                                    "isPartial" : true,
                                    "indexVersion" : 2,
                                    "direction" : "forward",
                                    "indexBounds" : {
                                            "pop" : [
                                                    "[99999.0, 99999.0]"
                                            ]
                                    }
                            }
                    },
                    "rejectedPlans" : [ ]
            },
            "serverInfo" : {
                    "host" : "linux30",
                    "port" : 27017,
                    "version" : "4.4.12",
                    "gitVersion" : "51475a8c4d9856eb1461137e7539a0a763cc85dc"
            },
            "ok" : 1
    }
    复制代码

返回结果包含两大块信息，一个是 queryPlanner，即查询计划，还有一个是 serverInfo，即 MongoDB 服务的一些信息。

2.1.2 参数解释

> 那么这里涉及到的参数比较多，我们来一一看一下：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>plannerVersion</td> 
   <td>查询计划版本</td> 
  </tr> 
  <tr> 
   <td>namespace</td> 
   <td>要查询的集合</td> 
  </tr> 
  <tr> 
   <td>indexFilterSet</td> 
   <td>是否使用索引</td> 
  </tr> 
  <tr> 
   <td>parsedQuery</td> 
   <td>查询条件，此处为 x=1</td> 
  </tr> 
  <tr> 
   <td>winningPlan</td> 
   <td>最佳执行计划</td> 
  </tr> 
  <tr> 
   <td>stage</td> 
   <td>查询方式，常见的有 COLLSCAN / 全表扫描、IXSCAN / 索引扫描、FETCH / 根据索引去检索文档、SHARD_MERGE / 合并分片结果、IDHACK / 针对_id 进行查询</td> 
  </tr> 
  <tr> 
   <td>filter</td> 
   <td>过滤条件</td> 
  </tr> 
  <tr> 
   <td>direction</td> 
   <td>搜索方向</td> 
  </tr> 
  <tr> 
   <td>rejectedPlans</td> 
   <td>拒绝的执行计划</td> 
  </tr> 
  <tr> 
   <td>serverInfo</td> 
   <td>MongoDB 服务器信息</td> 
  </tr> 
 </tbody> 
</table>

2.1.3 添加参数

> `explain()` 也接收不同的参数，通过设置不同参数我们可以查看更详细的查询计划。

*  queryPlanner

> 是默认参数，添加 queryPlanner 参数的查询结果就是我们上文看到的查询结果，这里不再赘述。

*  executionStats

> 会返回最佳执行计划的一些统计信息，如下：

db.zips.find({"pop":99999}).explain("executionStats")
    复制代码

我们发现增加了一个 `executionStats` 的字段列的信息

{
            "queryPlanner" : {
                    "plannerVersion" : 1,
                    "namespace" : "zips-db.zips",
                    "indexFilterSet" : false,
                    "parsedQuery" : {
                            "pop" : {
                                    "$eq" : 99999
                            }
                    },
                    "winningPlan" : {
                            "stage" : "FETCH",
                            "inputStage" : {
                                    "stage" : "IXSCAN",
                                    "keyPattern" : {
                                            "pop" : 1
                                    },
                                    "indexName" : "pop_1",
                                    "isMultiKey" : false,
                                    "multiKeyPaths" : {
                                            "pop" : [ ]
                                    },
                                    "isUnique" : false,
                                    "isSparse" : false,
                                    "isPartial" : true,
                                    "indexVersion" : 2,
                                    "direction" : "forward",
                                    "indexBounds" : {
                                            "pop" : [
                                                    "[99999.0, 99999.0]"
                                            ]
                                    }
                            }
                    },
                    "rejectedPlans" : [ ]
            },
            "executionStats" : {
                    "executionSuccess" : true,
                    "nReturned" : 0,
                    "executionTimeMillis" : 1,
                    "totalKeysExamined" : 0,
                    "totalDocsExamined" : 0,
                    "executionStages" : {
                            "stage" : "FETCH",
                            "nReturned" : 0,
                            "executionTimeMillisEstimate" : 0,
                            "works" : 1,
                            "advanced" : 0,
                            "needTime" : 0,
                            "needYield" : 0,
                            "saveState" : 0,
                            "restoreState" : 0,
                            "isEOF" : 1,
                            "docsExamined" : 0,
                            "alreadyHasObj" : 0,
                            "inputStage" : {
                                    "stage" : "IXSCAN",
                                    "nReturned" : 0,
                                    "executionTimeMillisEstimate" : 0,
                                    "works" : 1,
                                    "advanced" : 0,
                                    "needTime" : 0,
                                    "needYield" : 0,
                                    "saveState" : 0,
                                    "restoreState" : 0,
                                    "isEOF" : 1,
                                    "keyPattern" : {
                                            "pop" : 1
                                    },
                                    "indexName" : "pop_1",
                                    "isMultiKey" : false,
                                    "multiKeyPaths" : {
                                            "pop" : [ ]
                                    },
                                    "isUnique" : false,
                                    "isSparse" : false,
                                    "isPartial" : true,
                                    "indexVersion" : 2,
                                    "direction" : "forward",
                                    "indexBounds" : {
                                            "pop" : [
                                                    "[99999.0, 99999.0]"
                                            ]
                                    },
                                    "keysExamined" : 0,
                                    "seeks" : 1,
                                    "dupsTested" : 0,
                                    "dupsDropped" : 0
                            }
                    }
            },
            "serverInfo" : {
                    "host" : "linux30",
                    "port" : 27017,
                    "version" : "4.4.12",
                    "gitVersion" : "51475a8c4d9856eb1461137e7539a0a763cc85dc"
            },
            "ok" : 1
    }
    复制代码

这里除了我们上文介绍到的一些参数之外，还多了 executionStats 参数，含义如下：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>executionSuccess</td> 
   <td>是否执行成功</td> 
  </tr> 
  <tr> 
   <td>nReturned</td> 
   <td>返回的结果数</td> 
  </tr> 
  <tr> 
   <td>executionTimeMillis</td> 
   <td>执行耗时</td> 
  </tr> 
  <tr> 
   <td>totalKeysExamined</td> 
   <td>索引扫描次数</td> 
  </tr> 
  <tr> 
   <td>totalDocsExamined</td> 
   <td>文档扫描次数</td> 
  </tr> 
  <tr> 
   <td>executionStages</td> 
   <td>这个分类下描述执行的状态</td> 
  </tr> 
  <tr> 
   <td>stage</td> 
   <td>扫描方式，具体可选值与上文的相同</td> 
  </tr> 
  <tr> 
   <td>nReturned</td> 
   <td>查询结果数量</td> 
  </tr> 
  <tr> 
   <td>executionTimeMillisEstimate</td> 
   <td>预估耗时</td> 
  </tr> 
  <tr> 
   <td>works</td> 
   <td>工作单元数，一个查询会分解成小的工作单元</td> 
  </tr> 
  <tr> 
   <td>advanced</td> 
   <td>优先返回的结果数</td> 
  </tr> 
  <tr> 
   <td>docsExamined</td> 
   <td>文档检查数目，与 totalDocsExamined 一致</td> 
  </tr> 
 </tbody> 
</table>

allPlansExecution：用来获取所有执行计划，结果参数基本与上文相同。

### 2.2 慢查询 ###

在 MySQL 中，慢查询日志是经常作为我们优化查询的依据，那在 MongoDB 中是否有类似的功能呢？答案是肯定的，那就是开启 Profiling 功能。该工具在运行的实例上收集有关 MongoDB 的写操作，游标，数据库命令等，可以在数据库级别开启该工具，也可以在实例级别开启。该工具会把收集到的所有都写入到 [system.profile][]集合中，该集合是一个 [capped collection][]。

2.2.1 慢查询分析流程

慢查询日志一般作为优化步骤里的第一步。通过慢查询日志，定位每一条语句的查询时间。比如超过了 200ms，那么查询超过 200ms 的语句需要优化。然后它通过 explain () 解析影响行数是不是过大，所以导致查询语句超过 200ms。

> 所以优化步骤一般就是：

1.  用慢查询日志（system.profile）找到超过 200ms 的语句
2.  然后再通过 explain () 解析影响行数，分析为什么超过 200ms
3.  决定是不是需要添加索引

2.2.2 开启慢查询

Profiling 级别

0：关闭，不收集任何数据。
    1：收集慢查询数据，默认是100毫秒。
    2：收集所有数据
    复制代码

数据库设置

> 登录需要开启慢查询的数据库

use zips-db
    复制代码

> 查看慢查询状态

db.getProfilingStatus()
    复制代码

> 设置慢查询级别

db.setProfilingLevel(2)
    复制代码

> 如果不需要收集所有慢日志，只需要收集小于 100ms 的慢日志可以使用如下命令

db.setProfilingLevel(1,200)
    复制代码

注意：

*  以上操作要是在 test 集合下面的话，只对该集合里的操作有效，要是需要对整个实例有效，则需要在所有的集合下设置或在开启的时候开启参数。
 *  每次设置之后返回给你的结果是修改之前的状态（包括级别、时间参数）。

全局设置

> 在 mongoDB 启动的时候加入如下参数

mongod --profile=1  --slowms=200
    复制代码

> 或在配置文件里添加 2 行：

profile = 1
    slowms = 200
    复制代码

> 这样就可以针对所有数据库进行监控慢日志了

关闭 Profiling

> 使用如下命令可以关闭慢日志

db.setProfilingLevel(0)
    复制代码

2.2.3 Profile 效率

Profiling 功能肯定是会影响效率的，但是不太严重，原因是其使用的 system.profile 来记录，而 system.profile 是一个 capped collection， 这种 collection 在操作上有一些限制和特点，但是效率更高。

2.2.4 慢查询分析

> 通过 db.system.profile.find () 查看当前所有的慢查询日志

db.system.profile.find()
    复制代码

参数含义：

{
        "op" : "query",  #操作类型，有insert、query、update、remove、getmore、command   
        "ns" : "onroad.route_model", #操作的集合
        "query" : {
            "$query" : {
                "user_id" : 314436841,
                "data_time" : {
                    "$gte" : 1436198400
                }
    		},
            "$orderby" : {
                "data_time" : 1
            }
    	},
        "ntoskip" : 0, #指定跳过skip()方法 的文档的数量。
        "nscanned" : 2, #为了执行该操作，MongoDB在 index 中浏览的文档数。 一般来说，如果 nscanned 值高于 nreturned 的值，说明数据库为了找到目标文档扫描了很多文档。这时可以考虑创建索引来提高效率。
        "nscannedObjects" : 1,  #为了执行该操作，MongoDB在 collection中浏览的文档数。
        "keyUpdates" : 0, #索引更新的数量，改变一个索引键带有一个小的性能开销，因为数据库必须删除旧的key，并插入一个新的key到B-树索引
        "numYield" : 1,  #该操作为了使其他操作完成而放弃的次数。通常来说，当他们需要访问还没有完全读入内存中的数据时，操作将放弃。这使得在MongoDB为了放弃操作进行数据读取的同时，还有数据在内存中的其他操作可以完成
        "lockStats" : {  #锁信息，R：全局读锁；W：全局写锁；r：特定数据库的读锁；w：特定数据库的写锁
            "timeLockedMicros" : {  #该操作获取一个级锁花费的时间。对于请求多个锁的操作，比如对 local 数据库锁来更新 oplog ，该值比该操作的总长要长（即 millis ）
                "r" : NumberLong(1089485),
                "w" : NumberLong(0)
            },
            "timeAcquiringMicros" : {  #该操作等待获取一个级锁花费的时间。
                "r" : NumberLong(102),
                "w" : NumberLong(2)
            }
        },
        "nreturned" : 1,  // 返回的文档数量
        "responseLength" : 1669, // 返回字节长度，如果这个数字很大，考虑值返回所需字段
        "millis" : 544, #消耗的时间（毫秒）
        "execStats" : {  #一个文档,其中包含执行 查询 的操作，对于其他操作,这个值是一个空文件， system.profile.execStats 显示了就像树一样的统计结构，每个节点提供了在执行阶段的查询操作情况。
            "type" : "LIMIT", ##使用limit限制返回数  
            "works" : 2,
            "yields" : 1,
            "unyields" : 1,
            "invalidates" : 0,
            "advanced" : 1,
            "needTime" : 0,
            "needFetch" : 0,
            "isEOF" : 1,  #是否为文件结束符
            "children" : [
                {
                    "type" : "FETCH",  #根据索引去检索指定document
                    "works" : 1,
                    "yields" : 1,
                    "unyields" : 1,
                    "invalidates" : 0,
                    "advanced" : 1,
                    "needTime" : 0,
                    "needFetch" : 0,
                    "isEOF" : 0,
                    "alreadyHasObj" : 0,
                    "forcedFetches" : 0,
                    "matchTested" : 0,
                    "children" : [
                        {
                            "type" : "IXSCAN", #扫描索引键
                            "works" : 1,
                            "yields" : 1,
                            "unyields" : 1,
                            "invalidates" : 0,
                            "advanced" : 1,
                            "needTime" : 0,
                            "needFetch" : 0,
                            "isEOF" : 0,
                            "keyPattern" : "{ user_id: 1.0, data_time: -1.0 }",
                            "boundsVerbose" : "field #0['user_id']: [314436841, 314436841], field #1['data_time']: [1436198400, inf.0]",
                            "isMultiKey" : 0,
                            "yieldMovedCursor" : 0,
                            "dupsTested" : 0,
                            "dupsDropped" : 0,
                            "seenInvalidated" : 0,
                            "matchTested" : 0,
                            "keysExamined" : 2,
                            "children" : [ ]
                        }
                    ]
                }
            ]
        },
        "ts" : ISODate("2015-10-15T07:41:03.061Z"), #该命令在何时执行
        "client" : "10.10.86.171", #链接ip或则主机
        "allUsers" : [
            {
                "user" : "martin_v8",
                "db" : "onroad"
            }
        ],
        "user" : "martin_v8@onroad"
    }
    复制代码

分析:

> 如果发现 millis 值比较大，那么就需要作优化。

1.  如果 nscanned 数很大，或者接近记录总数（文档数），那么可能没有用到索引查询，而是全表扫描。
2.  如果 nscanned 值高于 nreturned 的值，说明数据库为了找到目标文档扫描了很多文档。这时可以考虑创建索引来提高效率。

system.profile 补充:

> ‘type’的返回参数说明

COLLSCAN #全表扫描
    IXSCAN #索引扫描
    FETCH #根据索引去检索指定document
    SHARD_MERGE #将各个分片返回数据进行merge
    SORT #表明在内存中进行了排序（与老版本的scanAndOrder:true一致）
    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的返回
    复制代码

> 对于普通查询，我们最希望看到的组合有这些

Fetch+IDHACK
    Fetch+ixscan
    Limit+（Fetch+ixscan）
    PROJECTION+ixscan
    SHARDING_FILTER+ixscan
    复制代码

> 不希望看到包含如下的 type

COLLSCAN（全表扫），SORT（使用sort但是无index），不合理的SKIP，SUBPLA（未用到index的$or）

[system.profile]: https://link.juejin.cn?target=https%3A%2F%2Fwww.oschina.net%2Faction%2FGoToLink%3Furl%3Dhttp%253A%252F%252Fdocs.mongodb.org%252Fmanual%252Freference%252Fsystem-collections%252F%2523.system.profile
[capped collection]: https://link.juejin.cn?target=https%3A%2F%2Fwww.oschina.net%2Faction%2FGoToLink%3Furl%3Dhttp%253A%252F%252Fdocs.mongodb.org%252Fmanual%252Fcore%252Fcapped-collections%252F