Mongodb索引和执行计划 hint 慢查询

Posted 2020-09-30 张小贱1987

查询索引

1. 索引存放在system.indexes集合中
2. > show tables
3. address
4. data
5. person
6. system.indexes
7. 默认会为所有的ID建上索引 而且无法删除
8. > db.system.indexes.find()
9. { "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.person" }
10. { "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.address" }
11. { "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.data" }
12. 单独查询一个集合的索引
13. > db.person.getIndexes();
14. [
15.    {
16.       "v" : 1,
17.       "key" : {
18.          "_id" : 1
19.       },
20.       "name" : "_id_",
21.       "ns" : "mydb.person"
22.    }
23. ]
24. >

创建索引

 

1. > db.person.find();
2. { "_id" : ObjectId("593011c8a92497992cdfac10"), "name" : "xhj", "age" : 30, "address" : DBRef("address", ObjectId("59314b07e693aae7a5eb72ab")) }
3. { "_id" : ObjectId("59301270a92497992cdfac11"), "name" : "zzj", "age" : 2 }
4. { "_id" : ObjectId("593015fda92497992cdfac12"), "name" : "my second child", "age" : "i do not know" }
5. { "_id" : ObjectId("592ffd872108e8e79ea902b0"), "name" : "zjf", "age" : 30, "address" : { "province" : "河南省", "city" : "南阳市", "building" : "桐柏县" } }
6. 1升序 -1降序
7. > db.person.ensureIndex({age:1});
8. {
9.    "createdCollectionAutomatically" : false,
10.    "numIndexesBefore" : 1,
11.    "numIndexesAfter" : 2,
12.    "ok" : 1
13. }
14. 可以在集合上创建索引
15. > db.person.ensureIndex({address:1});
16. {
17.    "createdCollectionAutomatically" : false,
18.    "numIndexesBefore" : 2,
19.    "numIndexesAfter" : 3,
20.    "ok" : 1
21. }
22. 复合索引
23. > db.person.ensureIndex({name:1,address:1});
24. {
25.    "createdCollectionAutomatically" : false,
26.    "numIndexesBefore" : 3,
27.    "numIndexesAfter" : 4,
28.    "ok" : 1
29. }
30. 唯一索引：
31. > db.person.ensureIndex({name:1},{unique:true});
32. {
33.    "createdCollectionAutomatically" : false,
34.    "numIndexesBefore" : 4,
35.    "numIndexesAfter" : 5,
36.    "ok" : 1
37. }

复合索引使用前缀匹配，所以创建复合索引的时候，要把经常会有的部分查询作为前缀。

删除索引：

1. 删除一个索引
2. > db.person.dropIndex({name:1});
3. { "nIndexesWas" : 5, "ok" : 1 }
4. 删除所有索引
5. > db.person.dropIndexes();
6. {
7.    "nIndexesWas" : 4,
8.    "msg" : "non-_id indexes dropped for collection",
9.    "ok" : 1
10. }

 

查看执行计划的方法：explain （）

winningPlan是最终的执行计划 其中的indexBounds索引计划

1. 在age上建立索引
2. > db.person.ensureIndex({age:1});
3. {
4.    "createdCollectionAutomatically" : false,
5.    "numIndexesBefore" : 1,
6.    "numIndexesAfter" : 2,
7.    "ok" : 1
8. }
9. > db.person.getIndexes();
10. [
11.    {
12.       "v" : 1,
13.       "key" : {
14.          "_id" : 1
15.       },
16.       "name" : "_id_",
17.       "ns" : "mydb.person"
18.    },
19.    {
20.       "v" : 1,
21.       "key" : {
22.          "age" : 1
23.       },
24.       "name" : "age_1",
25.       "ns" : "mydb.person"
26.    }
27. ]
28. 查看执行计划 indexBounds可以看到走了age的索引
29. > db.person.find({age:30}).explain();
30. {
31.    "queryPlanner" : {
32.       "plannerVersion" : 1,
33.       "namespace" : "mydb.person",
34.       "indexFilterSet" : false,
35.       "parsedQuery" : {
36.          "age" : {
37.             "$eq" : 30
38.          }
39.       },
40.       "winningPlan" : {
41.          "stage" : "FETCH",
42.          "inputStage" : {
43.             "stage" : "IXSCAN",
44.             "keyPattern" : {
45.                "age" : 1
46.             },
47.             "indexName" : "age_1",
48.             "isMultiKey" : false,
49.             "direction" : "forward",
50.             "indexBounds" : {
51.                "age" : [
52.                   "[30.0, 30.0]"
53.                ]
54.             }
55.          }
56.       },
57.       "rejectedPlans" : [ ]
58.    },
59.    "serverInfo" : {
60.       "host" : "localhost.localdomain",
61.       "port" : 27017,
62.       "version" : "3.0.6",
63.       "gitVersion" : "1ef45a23a4c5e3480ac919b28afcba3c615488f2"
64.    },
65.    "ok" : 1
66. }
67. 没有走索引的计划是这样的
68. > db.person.find({name:‘zjf‘}).explain();
69. {
70.    "queryPlanner" : {
71.       "plannerVersion" : 1,
72.       "namespace" : "mydb.person",
73.       "indexFilterSet" : false,
74.       "parsedQuery" : {
75.          "name" : {
76.             "$eq" : "zjf"
77.          }
78.       },
79.       "winningPlan" : {
80.          "stage" : "COLLSCAN",
81.          "filter" : {
82.             "name" : {
83.                "$eq" : "zjf"
84.             }
85.          },
86.          "direction" : "forward"
87.       },
88.       "rejectedPlans" : [ ]
89.    },
90.    "serverInfo" : {
91.       "host" : "localhost.localdomain",
92.       "port" : 27017,
93.       "version" : "3.0.6",
94.       "gitVersion" : "1ef45a23a4c5e3480ac919b28afcba3c615488f2"
95.    },
96.    "ok" : 1
97. }

强制索引 hint()方法：

1. > db.person.ensureIndex({name:1,age:1});
2. {
3.    "createdCollectionAutomatically" : false,
4.    "numIndexesBefore" : 3,
5.    "numIndexesAfter" : 4,
6.    "ok" : 1
7. }
8. > db.person.getIndexes();
9. [
10.    {
11.       "v" : 1,
12.       "key" : {
13.          "_id" : 1
14.       },
15.       "name" : "_id_",
16.       "ns" : "mydb.person"
17.    },
18.    {
19.       "v" : 1,
20.       "key" : {
21.          "age" : 1
22.       },
23.       "name" : "age_1",
24.       "ns" : "mydb.person"
25.    },
26.    {
27.       "v" : 1,
28.       "key" : {
29.          "name" : 1
30.       },
31.       "name" : "name_1",
32.       "ns" : "mydb.person"
33.    },
34.    {
35.       "v" : 1,
36.       "key" : {
37.          "name" : 1,
38.          "age" : 1
39.       },
40.       "name" : "name_1_age_1",
41.       "ns" : "mydb.person"
42.    }
43. ]
44. //如果不加hint 默认走age上的索引。
45. > db.person.find({age:{$gt:0}}).explain();
46. {
47.    "queryPlanner" : {
48.       "plannerVersion" : 1,
49.       "namespace" : "mydb.person",
50.       "indexFilterSet" : false,
51.       "parsedQuery" : {
52.          "age" : {
53.             "$gt" : 0
54.          }
55.       },
56.       "winningPlan" : {
57.          "stage" : "FETCH",
58.          "inputStage" : {
59.             "stage" : "IXSCAN",
60.             "keyPattern" : {
61.                "age" : 1
62.             },
63.             "indexName" : "age_1",
64.             "isMultiKey" : false,
65.             "direction" : "forward",
66.             "indexBounds" : {
67.                "age" : [
68.                   "(0.0, inf.0]"
69.                ]
70.             }
71.          }
72.       },
73.       "rejectedPlans" : [ ]
74.    },
75.    "serverInfo" : {
76.       "host" : "localhost.localdomain",
77.       "port" : 27017,
78.       "version" : "3.0.6",
79.       "gitVersion" : "1ef45a23a4c5e3480ac919b28afcba3c615488f2"
80.    },
81.    "ok" : 1
82. }
83. //使用hint
84. > db.person.find({age:{$gt:0}}).hint({name:1,age:1}).explain();
85. {
86.    "queryPlanner" : {
87.       "plannerVersion" : 1,
88.       "namespace" : "mydb.person",
89.       "indexFilterSet" : false,
90.       "parsedQuery" : {
91.          "age" : {
92.             "$gt" : 0
93.          }
94.       },
95.       "winningPlan" : {
96.          "stage" : "KEEP_MUTATIONS",
97.          "inputStage" : {
98.             "stage" : "FETCH",
99.             "filter" : {
100.                "age" : {
101.                   "$gt" : 0
102.                }
103.             },
104.             "inputStage" : {
105.                "stage" : "IXSCAN",
106.                "keyPattern" : {
107.                   "name" : 1,
108.                   "age" : 1
109.                },
110.                "indexName" : "name_1_age_1",
111.                "isMultiKey" : false,
112.                "direction" : "forward",
113.                "indexBounds" : {
114.                   "name" : [
115.                      "[MinKey, MaxKey]"
116.                   ],
117.                   "age" : [
118.                      "[MinKey, MaxKey]"
119.                   ]
120.                }
121.             }
122.          }
123.       },
124.       "rejectedPlans" : [ ]
125.    },
126.    "serverInfo" : {
127.       "host" : "localhost.localdomain",
128.       "port" : 27017,
129.       "version" : "3.0.6",
130.       "gitVersion" : "1ef45a23a4c5e3480ac919b28afcba3c615488f2"
131.    },
132.    "ok" : 1
133. }

查看执行情况：

1. db.person.find({name:‘zjf‘}).explain(‘executionStats‘);
2. {
3.    "queryPlanner" : {
4.       "plannerVersion" : 1,
5.       "namespace" : "mydb.person",
6.       "indexFilterSet" : false,
7.       "parsedQuery" : {
8.          "name" : {
9.             "$eq" : "zjf"
10.          }
11.       },
12.       "winningPlan" : {
13.          "stage" : "FETCH",
14.          "inputStage" : {
15.             "stage" : "IXSCAN",
16.             "keyPattern" : {
17.                "name" : 1
18.             },
19.             "indexName" : "name_1",
20.             "isMultiKey" : false,
21.             "direction" : "forward",
22.             "indexBounds" : {
23.                "name" : [
24.                   "[\"zjf\", \"zjf\"]"
25.                ]
26.             }
27.          }
28.       },
29.       "rejectedPlans" : [
30.          {
31.             "stage" : "FETCH",
32.             "inputStage" : {
33.                "stage" : "IXSCAN",
34.                "keyPattern" : {
35.                   "name" : 1,
36.                   "age" : 1
37.                },
38.                "indexName" : "name_1_age_1",
39.                "isMultiKey" : false,
40.                "direction" : "forward",
41.                "indexBounds" : {
42.                   "name" : [
43.                      "[\"zjf\", \"zjf\"]"
44.                   ],
45.                   "age" : [
46.                      "[MinKey, MaxKey]"
47.                   ]
48.                }
49.             }
50.          }
51.       ]
52.    },
53.    "executionStats" : {
54.       "executionSuccess" : true,
55.       "nReturned" : 1,
56.       "executionTimeMillis" : 0,
57.       "totalKeysExamined" : 1,
58.       "totalDocsExamined" : 1,
59.       "executionStages" : {
60.          "stage" : "FETCH",
61.          "nReturned" : 1,
62.          "executionTimeMillisEstimate" : 0,
63.          "works" : 3,
64.          "advanced" : 1,
65.          "needTime" : 0,
66.          "needFetch" : 0,
67.          "saveState" : 0,
68.          "restoreState" : 0,
69.          "isEOF" : 1,
70.          "invalidates" : 0,
71.          "docsExamined" : 1,
72.          "alreadyHasObj" : 0,
73.          "inputStage" : {
74.             "stage" : "IXSCAN",
75.             "nReturned" : 1,
76.             "executionTimeMillisEstimate" : 0,
77.             "works" : 2,
78.             "advanced" : 1,
79.             "needTime" : 0,
80.             "needFetch" : 0,
81.             "saveState" : 0,
82.             "restoreState" : 0,
83.             "isEOF" : 1,
84.             "invalidates" : 0,
85.             "keyPattern" : {
86.                "name" : 1
87.             },
88.             "indexName" : "name_1",
89.             "isMultiKey" : false,
90.             "direction" : "forward",
91.             "indexBounds" : {
92.                "name" : [
93.                   "[\"zjf\", \"zjf\"]"
94.                ]
95.             },
96.             "keysExamined" : 1,
97.             "dupsTested" : 0,
98.             "dupsDropped" : 0,
99.             "seenInvalidated" : 0,
100.             "matchTested" : 0
101.          }
102.       }
103.    },
104.    "serverInfo" : {
105.       "host" : "localhost.localdomain",
106.       "port" : 27017,
107.       "version" : "3.0.6",
108.       "gitVersion" : "1ef45a23a4c5e3480ac919b28afcba3c615488f2"
109.    },
110.    "ok" : 1
111. }

 

Mongodb的索引使用的是B-树。

hash索引：

散列索引使用索引字段的值的散列值来维护条目。

散列索引的重要特征是hash后的键值是均匀分布的，索引最适合的是做分片键。

db.collection.createIndex( { _id: "hashed" } )

MongoDB支持任何单个字段的散列索引。 散列函数折叠嵌入文档并计算整个值的散列值，但不支持多键（即数组）索引。

您不得创建具有散列索引字段或在散列索引上指定唯一约束的复合索引; 但是，您可以在同一字段上创建散列索引和升序/降序（即非散列）索引：MongoDB将使用范围查询的标量索引。

警告

MongoDB散列索引在浮动之前将浮点数截断为64位整数。 例如，散列索引将为保持值为2.3,2.2和2.9的字段存储相同的值。 为了防止冲突，不要使用不能可靠地转换为64位整数（然后返回到浮点）的浮点数的散列索引。 MongoDB散列索引不支持大于253的浮点值。

散列索引支持等值查询。

索引大小

为了达到更快的处理效果，请确保您的索引能完整地和内存相适应，这样可以避免从磁盘上读取索引。

可以使用帮助函数 db.collection.totalIndexSize() 来检查索引的大小，返回的数值单位是字节：

> db.collection.totalIndexSize()

4294976499

上述例子展示了一个几乎4.3GB的索引。为了确保索引与内存相适应，您不仅需要有那么多足够可用的内存用于索引，还要有足够的内存用于剩下的 working set 。

稀疏索引

稀疏索引(或者称间隙索引)就是只包含有索引字段的文档的条目，跳过索引键不存在的文档

创建间隙索引示例：

db.addresses.createIndex( { "xmpp_id": 1 }, { sparse: true } )

这个示例，哪些不包含xmpp_id的键(列)的文档将不会被索引

间隙索引不会被使用到的情形

如果一个间隙索引会导致查询或者排序操作得到一个不完整结果集的时候，MongoDB将不会使用这个索引，hint提示除外

如果集合中有大量的数据都不包含该键值，那么应该使用稀疏索引。

覆盖索引：

整个结果集都是从索引中获取。

慢查询分析：

慢查询分析流程：

1.用慢查询日志（system.profile）找到超过200ms的语句

2.然后再通过.explain()解析影响行数，分析为什么超过200ms 

3.决定是不是需要添加索引

开启慢查询：

db.setProfilingLevel(1,200)

参数：

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

查看结果：

db.system.profile.find()

 

以上是关于Mongodb索引和执行计划 hint 慢查询的主要内容，如果未能解决你的问题，请参考以下文章

MongoDB_09——执行计划

正确使用索引（sql优化），limit分页优化，执行计划，慢日志查询

oracle数据库表频繁插入和删除,会导致用不到索引吗？

通过分析SQL语句的执行计划优化SQL

oracle 的hint有啥用

MySQL---正确使用索引limit分页执行计划慢日志查询