MongoDB：16-MongoDB-索引数组字段和索引子文档字段

1. MongoDB允许深入文档内部，对嵌套字段和数组建立索引；
2. 嵌套对象和数组字段可以和复合索引中的顶级字段一起使用，多数情况下与“正常”索引字段的行为也是一致的。
4. 考虑以下文档集合（user ）:

5. db.user.insertMany(
6. [
7. {
8.   "address": {
9.      "province": "HeNan",
10.      "city": "ZhengZhou",
11.      "pincode": "123"
12.   },
13.   "tags": [
14.      "music",
15.      "cricket",
16.      "blogs"
17.   ],
18.   "name": "fly"
19. },
20. {
21.   "address": {
22.      "province": "HeBei",
23.      "city": "HanDan",
24.      "pincode": "234"
25.   },
26.   "tags": [
27.      "music",
28.      "basket",
29.      "blogs"
30.   ],
31.   "name": "chen"
32. },
33. {
34.   "address": {
35.      "province": "ChongQing",
36.      "city": "ChongQing",
37.      "pincode": "456"
38.   },
39.   "tags": [
40.      "music",
41.      "writing",
42.      "running"
43.   ],
44.   "name": "wang"
45. }
46. ]
47. )

以上文档包含了 address 子文档和 tags 数组。

索引数组字段

• 假设我们基于标签来检索用户，为此我们需要对集合中的数组 tags 建立索引。
  
• 在数组中创建索引，需要对数组中的每个字段依次建立索引。所以在我们为数组 tags 创建索引时，会为 music、cricket、blogs三个值建立单独的索引。
  

• 使用以下命令创建数组索引：

1. db.user.ensureIndex({"tags":1})

• 创建索引后，我们可以这样检索集合的 tags 字段：

1. db.user.find({tags:"music"})

• 为了验证我们使用使用了索引，可以使用 explain 命令：

2. db.user.find({tags:"music"}).explain()
3. 执行结果
4. /* 1 */
5. {
6.    "queryPlanner" : {
7.        "plannerVersion" : 1,
8.        "namespace" : "mongotest.user",
9.        "indexFilterSet" : false,
10.        "parsedQuery" : {
11.            "tags" : {
12.                "$eq" : "music"
13.            }
14.        },
15.        "winningPlan" : {
16.            "stage" : "FETCH",
17.            "inputStage" : {
18.                "stage" : "IXSCAN",
19.                "keyPattern" : {
20.                    "tags" : 1.0
21.                },
22.                "indexName" : "tags_1",
23.                "isMultiKey" : true,
24.                "multiKeyPaths" : {
25.                    "tags" : [
26.                        "tags"
27.                    ]
28.                },
29.                "isUnique" : false,
30.                "isSparse" : false,
31.                "isPartial" : false,
32.                "indexVersion" : 2,
33.                "direction" : "forward",
34.                "indexBounds" : {
35.                    "tags" : [
36.                        "[\"music\", \"music\"]"
37.                    ]
38.                }
39.            }
40.        },
41.        "rejectedPlans" : []
42.    },
43.    "serverInfo" : {
44.        "host" : "kf-PC",
45.        "port" : 27017,
46.        "version" : "3.4.9",
47.        "gitVersion" : "876ebee8c7dd0e2d992f36a848ff4dc50ee6603e"
48.    },
49.    "ok" : 1.0
50. }

• 以上命令执行结果中会显示 "stage":"FETCH",，则表示已经使用了索引。

1. stage的类型的意义
2. mongodb的文档中列出了前4种类型，还有一些没有列出来，但是会比较常见，这里一并解释一下。
4. COLLSCAN ：全表扫描
5. IXSCAN：索引扫描
6. FETCH:：根据索引去检索指定document
7. SHARD_MERGE：各个分片返回数据进行merge
8. SORT：表明在内存中进行了排序（与前期版本的scanAndOrder:true一致）
9. SORT_MERGE：表明在内存中进行了排序后再合并
10. LIMIT：使用limit限制返回数
11. SKIP：使用skip进行跳过
12. IDHACK：针对_id进行查询
13. SHARDING_FILTER：通过mongos对分片数据进行查询
14. COUNT：利用db.coll.count()之类进行count运算
15. COUNTSCAN：count不使用用Index进行count时的stage返回
16. COUNT_SCAN：count使用了Index进行count时的stage返回
17. SUBPLA：未使用到索引的$or查询的stage返回
18. TEXT：使用全文索引进行查询时候的stage返回
20. 附：explain查询结果解析官方文档：
21. https://docs.mongodb.org/v3.0/reference/explain-results/

• 具体参考：http://blog.csdn.net/fly910905/article/details/78184302

1. 数组上的索引
2. （1）可以看得出在数组字段上建立索引的代价比较大，因为每次的删除，更新都会对每一个索引进行刷新，太消耗服务器的资源；
3. （2）可以针对数组字段中的某一个元素做具体的单独索引，减少索引的数量；

• 例如，在数组字段tags中的第1个元素中的music上建立索引：
  

1. db.user.ensureIndex({"tags.0.music":1})

• 同样，只有精确匹配tags.0.music查询，上述索引才会起到索引的作用。
  

2. 多键索引
3. 如果在数组字段上创建索引，那么这个索引称为多键索引（ multikey）。
4. 多键索引用explain函数中可以看到“isMultikey”字段的值为true，多键索引比非多键索引要慢一些；

索引子文档字段

• 假设我们需要通过city、state、pincode字段来检索文档，由于这些字段是子文档的字段，所以我们需要对子文档建立索引。

• 为子文档的三个字段创建索引，命令如下：

1. db.user.ensureIndex({"address.province":1,"address.city":1,"address.pincode":1})
2. 利用这种方式可以建立任意深度的索引，例如可以在X.Y.Z.A.B.C上建立索引。
3. 但是，针对子文档“address”上建立的索引，和建立在子文档的某个字段“address.provincey”上的索引是不同的：
4. （1）对整个子文档上建立的索引，只会提高整个子文档的的查询速度；
5.     也就是说只有在完全匹配子文档的查询（包括字段顺序），子文档索引才会起作用；
6. （2）只有查询address.province字段，索引address.province才会起作用，
7.     其他情况索引address.province不起作用；

• 一旦创建索引，我们可以使用子文档的字段来检索数据：

1. db.user.find({"address.province":"HeNan"})

• 记住查询表达式必须遵循指定的索引的顺序。所以上面创建的索引将支持以下查询：

1. db.user.find({"address.province":"HeNan","address.city":"ZhengZhou"})

• 同样支持以下查询：

2. db.user.find({"address.province":"HeNan","address.city":"ZhengZhou","address.pincode":"123"})
3. 查询分析
4. /* 1 */
5. {
6.    "queryPlanner" : {
7.        "plannerVersion" : 1,
8.        "namespace" : "mongotest.user",
9.        "indexFilterSet" : false,
10.        "parsedQuery" : {
11.            "$and" : [
12.                {
13.                    "address.city" : {
14.                        "$eq" : "ZhengZhou"
15.                    }
16.                },
17.                {
18.                    "address.pincode" : {
19.                        "$eq" : "123"
20.                    }
21.                },
22.                {
23.                    "address.province" : {
24.                        "$eq" : "HeNan"
25.                    }
26.                }
27.            ]
28.        },
29.        "winningPlan" : {
30.            "stage" : "FETCH",
31.            "inputStage" : {
32.                "stage" : "IXSCAN",
33.                "keyPattern" : {
34.                    "address.province" : 1.0,
35.                    "address.city" : 1.0,
36.                    "address.pincode" : 1.0
37.                },
38.                "indexName" : "address.province_1_address.city_1_address.pincode_1",
39.                "isMultiKey" : false,
40.                "multiKeyPaths" : {
41.                    "address.province" : [],
42.                    "address.city" : [],
43.                    "address.pincode" : []
44.                },
45.                "isUnique" : false,
46.                "isSparse" : false,
47.                "isPartial" : false,
48.                "indexVersion" : 2,
49.                "direction" : "forward",
50.                "indexBounds" : {
51.                    "address.province" : [
52.                        "[\"HeNan\", \"HeNan\"]"
53.                    ],
54.                    "address.city" : [
55.                        "[\"ZhengZhou\", \"ZhengZhou\"]"
56.                    ],
57.                    "address.pincode" : [
58.                        "[\"123\", \"123\"]"
59.                    ]
60.                }
61.            }
62.        },
63.        "rejectedPlans" : []
64.    },
65.    "serverInfo" : {
66.        "host" : "kf-PC",
67.        "port" : 27017,
68.        "version" : "3.4.9",
69.        "gitVersion" : "876ebee8c7dd0e2d992f36a848ff4dc50ee6603e"
70.    },
71.    "ok" : 1.0
72. }

参考来源： http://www.runoob.com/mongodb/mongodb-advanced-indexing.html

参考来源：http://281816327.blog.51cto.com/907015/1601473