MongoDB Indexes

索引属性

唯一索引

索引的惟一属性会导致MongoDB拒绝索引字段的重复值。除了唯一的约束之外，独特的索引与其他MongoDB索引在功能上是可互换的。

部分索引

部分索引只在满足指定筛选器表达式的集合中索引文档。通过对集合中的文档子集进行索引，部分索引具有较低的存储需求，并降低了索引创建和维护的性能成本。部分索引提供了稀疏索引功能的超集，优于稀疏索引。

稀疏索引

索引的稀疏属性确保索引只包含有索引字段的文档的条目。索引跳过没有索引字段的文档。您可以将稀疏索引选项与惟一索引选项组合起来，以拒绝对字段具有重复值的文档，而忽略没有索引键的文档

TTL索引

TTL索引是MongoDB可以用来在一定时间后自动从集合中删除文档的特殊索引。这对于某些类型的信息非常理想，比如机器生成的事件数据、日志和会话信息，这些信息只需要在数据库中保存有限的时间。

索引的种类和使用

很多时候,数据库性能变差,查询变慢,都与索引有密切的关系.如何建立适当的索引对于查询优化至关重要.

• 数据量很大时，查询使用索引可大幅度提高效率
• 如果 数据量非常大，创建索引需要消耗一定的时间，这时需要在使用数据库之前就将索引创建完毕，否则会对数据库性能造成较大影响

相关操作

其他参考这里

ensureIndex参数

后台创建索引

db.values.ensureIndex({open: 1, close: 1}, {background: true})

通过在创建索引时加background:true 的选项，让创建工作在后台执行

创建TTL索引

> db.indexes.getIndexes()
[ ]
> db.indexes.ensureIndex({ time:1 },{ expireAfterSeconds:30 })
{
    "createdCollectionAutomatically" : true,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.indexes.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "whoami.indexes"
    },
    {
        "v" : 2,
        "key" : {
            "time" : 1
        },
        "name" : "time_1",
        "ns" : "whoami.indexes",
        "expireAfterSeconds" : 30
    }
]
> new Date()
ISODate("2018-02-07T12:48:54.955Z")
> db.indexes.insert({ time: new Date() });
WriteResult({ "nInserted" : 1 })
> db.indexes.find()
{ "_id" : ObjectId("5a7af5e8bba5630ed0ccc0cf"), "time" : ISODate("2018-02-07T12:49:44.309Z") }
> db.indexes.find()
{ "_id" : ObjectId("5a7af5e8bba5630ed0ccc0cf"), "time" : ISODate("2018-02-07T12:49:44.309Z") }
> new Date()
ISODate("2018-02-07T12:51:10.233Z")
> db.indexes.find()
>

• 在索引过期后，相应的数据会删除（不仅仅是索引删除，还有数据）

• 适用场景：在一段时间之后会时效的数据，比如用户的登陆信息、存储的日志

• 存储在过期索引字段的值必须是指定的时间类型

  说明：必须是ISOData或者ISOData数组，不能使用时间戳，否则不能自动删除

• 如果指定的是ISOData数组，则按照数组中最小的数值计算删除

• 过期索引不能是复合索引

• 删除时间不是精确,在文档不多时无论设置多长时间都是60秒内删除

命名索引

MongoDB会自动的创建，规则是

• key_1 或者 key_-1 1或者-1代表排序方向，一般影响不大，
• 全文索引可能为key_text
• 长度一般有限制125字节

为了见名知意我们可以自己来命名

> db.articles.getIndexes()
[
    ...
        "name" : "article_text",
    ...
]
> db.articles.dropIndex("article_text")
{ "nIndexesWas" : 2, "ok" : 1 }
> db.articles.ensureIndex( { "article":"text" },{ name: "atext" })
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.articles.getIndexes()
[
    ...
        "name" : "atext",
    ...
]
>

唯一索引

建立索引时不允许存在相同的键值

> db.uniqueTest.find({},{ _id:0, x:1, y:1, z:1 })
{ "x" : 3, "y" : 4, "z" : 5 }
{ "x" : 3, "y" : 4 }
{ "x" : 3 }
> db.uniqueTest.ensureIndex({ x:1 },{ unique:true })
{
    "ok" : 0,
    "errmsg" : "E11000 duplicate key error collection: whoami.uniqueTest index: x_1 dup key: { : 3.0 }",
    "code" : 11000,
    "codeName" : "DuplicateKey"
}
> db.uniqueTest.remove({ x:3, y:4, z:5 })
WriteResult({ "nRemoved" : 1 })
> db.uniqueTest.remove({ x:3, y:4 })
WriteResult({ "nRemoved" : 1 })
> db.uniqueTest.ensureIndex({ x:1 },{ unique:true })
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.uniqueTest.insert({ x:6, y:8, z:10 })
WriteResult({ "nInserted" : 1 })
>

稀疏索引

> db.sparseTest.find()
{ "_id" : ObjectId("5a7b94aa940ce42ef05591f6"), "m" : 1 }
{ "_id" : ObjectId("5a7b94b9940ce42ef05591f7"), "n" : 1 }

通过$exists可以判断字段是否存在，如

> db.sparseTest.find({ m:{ $exists:true } })
{ "_id" : ObjectId("5a7b94aa940ce42ef05591f6"), "m" : 1 }

创建一个稀疏索引

> db.sparseTest.ensureIndex({ m:1 },{ sparse:true })
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
>

第二条文档不存在m字段，所以不会创建这个索引,如果使用稀疏索引查找不存在稀疏索引字段的文档，mongodb则不会使用这个索引查找
例如：

> db.sparseTest.find({ m:{ $exists:false } })
{ "_id" : ObjectId("5a7b94b9940ce42ef05591f7"), "n" : 1 }

但如果我们通过hint强制使用索引，就不会查到数据了

> db.sparseTest.getIndexes()
[
    ...
    {
        "v" : 2,
        "key" : {
            "m" : 1
        },
    ...
]
> db.sparseTest.find({m:{$exists:false}}).hint("m_1")
>

_id索引

MongoDB在创建集合时在 _id 字段上创建一个惟一的索引。_id索引阻止客户机插入两个具有相同值的 _id 字段的文档。不能在 _id 字段上删除该索引。

在分片集群中，如果您不使用_id字段作为分片键，那么您的应用程序必须确保_id字段中值的惟一性，以防止出现错误。这通常是使用标准自动生成的ObjectId完成的。

> db.indexes.insert({ x:1 })
WriteResult({ "nInserted" : 1 })
> db.indexes.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "whoami.indexes"
    }
]
>

单键索引(Single Field)

除了MongoDB定义的_id索引之外，MongoDB还支持在文档的单个字段上创建用户定义的提升/下降索引。

特点:

1. 单键索引是最普通的索引
2. 与_id索引不同，单键索引不会自动创建

> for(i = 0; i < 100;  i++)db.indexes.insert({x:i})
WriteResult({ "nInserted" : 1 })
> db.indexes.ensureIndex({ x:1 })
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.indexes.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "whoami.indexes"
    },
    {
        "v" : 2,
        "key" : {
            "x" : 1
        },
        "name" : "x_1",
        "ns" : "whoami.indexes"
    }
]
> db.indexes.ensureIndex({ x:-1 })
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 2,
    "numIndexesAfter" : 3,
    "ok" : 1
}
> db.indexes.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "whoami.indexes"
    },
    {
        "v" : 2,
        "key" : {
            "x" : 1
        },
        "name" : "x_1",
        "ns" : "whoami.indexes"
    },
    {
        "v" : 2,
        "key" : {
            "x" : -1
        },
        "name" : "x_-1",
        "ns" : "whoami.indexes"
    }
]
> db.indexes.ensureIndex({ x:-1 })
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 3,
    "numIndexesAfter" : 3,
    "note" : "all indexes already exist",
    "ok" : 1
}
> db.indexes.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "whoami.indexes"
    },
    {
        "v" : 2,
        "key" : {
            "x" : 1
        },
        "name" : "x_1",
        "ns" : "whoami.indexes"
    },
    {
        "v" : 2,
        "key" : {
            "x" : -1
        },
        "name" : "x_-1",
        "ns" : "whoami.indexes"
    }
]
> 

可见对于同一个字段所创建的dec与asc索引也是不一样的.也可以重复创建索引,不会报错.

多键索引(Multikey Index)

MongoDB使用多索引索引来索引存储在数组中的内容。如果索引一个包含数组值的字段，MongoDB将为数组的每个元素创建单独的索引条目。这些多键索引允许查询通过匹配数组的元素或元素来选择包含数组的文档。MongoDB自动决定是否创建索引域包含数组值的multikey索引;不需要显式地指定多键类型。与单键索引创建形式相同，区别在于字段的值

• 单键索引：值为一个单一的值，例如字符串，数字或者日期
• 多键索引：值具有多个记录，例如数组

使用语句插入数组时系统默认创建多键索引

> db.indexes.insert({x:[1,2,3,4,5]});

这样的多键索引是看不到的

复合索引(Compound Index)

MongoDB还支持多个字段的用户定义索引，即复合索引。

复合索引中列出的字段顺序具有重要意义。例如，如果一个复合索引包含{userid: 1, score: -1}，索引排序首先是userid，然后在每个userid值中按分数排序。

> db.indexes.insert({ x:[1,2,3,4,5], y:66 });
WriteResult({ "nInserted" : 1 })
> db.indexes.ensureIndex({ x:-1, y:1 })
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 2,
    "numIndexesAfter" : 3,
    "ok" : 1
}
> db.indexes.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "whoami.indexes"
    },
    {
        "v" : 2,
        "key" : {
            "x" : -1
        },
        "name" : "x_-1",
        "ns" : "whoami.indexes"
    },
    {
        "v" : 2,
        "key" : {
            "x" : -1,
            "y" : 1
        },
        "name" : "x_-1_y_1",
        "ns" : "whoami.indexes"
    }
]
> 

全文索引(Text Indexes)

MongoDB提供了一个文本索引类型，支持在集合中搜索字符串内容。这些文本索引不存储特定于语言的stop单词(例如，“the”、“a”、“or”)，并将这些单词放在一个集合中，只存储根单词。

支持的语言在这里

全文索引创建方法：与创建单键索引，复合索引类似。value换成‘text‘，$**匹配集合下所有

db.articles.ensureIndex({key:"text"})                       # 设置单键的全文索引
db.articles.ensureIndex({key_1:"text"},{key_2:"text"})      # 设置多键全文索引索引
db.articles.ensureIndex({"$**":"text"})                     # 为所有的字段设置全文索引

实践如下

> use whoami
switched to db whoami
> db.articles.ensureIndex({"article":"text"})
{
    "createdCollectionAutomatically" : true,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.articles.insert({"article":"aa bb cc rr hh asdfasdf dd"})
WriteResult({ "nInserted" : 1 })
> db.articles.insert({"article":"cc"})
WriteResult({ "nInserted" : 1 })
> db.articles.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "whoami.articles"
    },
    {
        "v" : 2,
        "key" : {
            "_fts" : "text",
            "_ftsx" : 1
        },
        "name" : "article_text",
        "ns" : "whoami.articles",
        "weights" : {
            "article" : 1
        },
        "default_language" : "english",
        "language_override" : "language",
        "textIndexVersion" : 3
    }
]
>

相应的查询

//只有一个全文索引，或查询
> db.articles.find({$text:{$search:"aa bb cc"}})
{ "_id" : xxx, "article" : "cc" }
{ "_id" : xxx, "article" : "aa bb cc rr hh asdfasdf dd" }
> db.articles.find({$text:{$search:"cc"}})
{ "_id" : xxx, "article" : "aa bb cc rr hh asdfasdf dd" }
{ "_id" : xxx, "article" : "cc" }
// - 代表不包含 cc 字符串
> db.articles.find({$text:{$search:"-cc aa"}}) 
>
//与查询要将查找值用双引号包含起来，\对引号转义
> db.articles.insert({"article":"\"aa\" bb cc rr hh asdfasdf dd"})
WriteResult({ "nInserted" : 1 })
> db.articles.find({$text:{$search:" \"aa\" \"cc\"  \"bb\" "}})
{ "_id" : xxx, "article" : "aa bb cc rr hh asdfasdf dd" }
{ "_id" : xxx, "article" : "\"aa\" bb cc rr hh asdfasdf dd" }

全文索引相似度

$meta操作符：{score：{$meta:"textScore"}}查询条件之后可以返回返回结果的相似度,与 sort 一起使用可以达到很好的使用效果.为了达到在搜索后能够根据内容与搜索条件的相似度进行排序，越相似越前，可以在建立全文索引后使用$meta操作符：

> db.articles.find({},{ _id:0,article:1 })
{ "article" : "aa bb cc rr hh asdfasdf dd" }
{ "article" : "cc" }
{ "article" : "\"aa\" bb cc rr hh asdfasdf dd" }
{ "article" : "\"aa\" bb cc rr hh asdfasdf" }
{ "article" : "\"aa\" bb cc rr hh" }
{ "article" : "\"aa\" bb cc rr" }
{ "article" : "\"aa\" bb cc" }
{ "article" : "\"aa\" bb" }
{ "article" : "\"aa\"" }
> db.articles.find(
... {$text:{$search:"aa bb"}},
... {score:{$meta:"textScore"}}
... ).sort({score:{$meta:"textScore"}});
{ xxx, "article" : "\"aa\" bb", "score" : 1.5 }
{ xxx, "article" : "\"aa\" bb cc", "score" : 1.3333333333333333 }
{ xxx, "article" : "\"aa\" bb cc rr", "score" : 1.25 }
{ xxx, "article" : "\"aa\" bb cc rr hh", "score" : 1.2 }
{ xxx, "article" : "\"aa\" bb cc rr hh asdfasdf", "score" : 1.1666666666666667 }
{ xxx, "article" : "aa bb cc rr hh asdfasdf dd", "score" : 1.1428571428571428 }
{ xxx, "article" : "\"aa\" bb cc rr hh asdfasdf dd", "score" : 1.1428571428571428 }
{ xxx, "article" : "\"aa\"", "score" : 1 }

全局索引的限制：

1. 每次查询，只能指定一个$text查询
2. $text查询不能出现在$nor查询中
3. 查询中如果包含了$text, hint不再起作用
4. MongoDB全文索引还不支持中文
5. 全文索引一个集合里面只能有一个

地理位置索引(Geospatial Inde)

为了支持地理空间坐标数据的高效查询，MongoDB提供了两个特殊的索引:在返回结果时使用平面几何的2d索引和使用球面几何返回结果的2dsphere索引。

数据范围

• 位置表示方式：经纬度[经度,纬度]
• 取值范围：经度[-180,180]，纬度[-90,90]
• 超过经度一般会报错,而纬度可能不会,但是带来查询上的不方便.

2d

用于存储和查找平面上的点

格式:

db.mycoll.ensureIndex({w:"2d"})

查找方式：

1. 查找距离某个点一定一定距离内的点
2. 查找包含在某个区域内的点

查询方式：

• $near: 查询距离某个点最近的点
• $goWithin: 查询某个形状内的点

$near查询

形状的表示

1. $box:矩形，使用

{$box:[[<x1>,<y1>],[<x2>,<y2>]]}

1. $center:圆形，使用

{$center:[[<x1>,<y1>],r]}

1. $polygon:多边形，使用

{$polygon:[[<x1>,<y1>],[<x2>,<y2>],[<x3>,<y3>]]}

例子：

db.mycoll.find({w:{$near:[1,1]}})
查找距离[1,1]最大距离为10的点
db.mycoll.find({w:{$near:[1,1], $maxDistance:10}})
查找在矩形[0,0][3,3]范围内的点
db.mycoll.find({w:{$geoWithin:{$box:[[0,0],[3,3]]}}})
查找以[0,0]为圆心半径为5的园内的点
db.mycoll.find({w:{$geoWithin:{$center:[[0,0],5]}}})
查找以[0,0],[1,1],[4,5],[6,6]为多边形内的点
db.mycoll.find({w:{$geoWithin:{$polygon:[[0,0],[1,1],[4,5],[6,6]]}}}) 

实例

> db.locations.ensureIndex({ w:'2d' })
{
    "createdCollectionAutomatically" : true,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.locations.insert({ w:[1,1] })
WriteResult({ "nInserted" : 1 })
> db.locations.insert({ w:[1,2] })
WriteResult({ "nInserted" : 1 })
> db.locations.insert({ w:[3,2] })
WriteResult({ "nInserted" : 1 })
> db.locations.insert({ w:[3,4] })
WriteResult({ "nInserted" : 1 })
> db.locations.insert({ w:[5,4] })
WriteResult({ "nInserted" : 1 })
> db.locations.insert({ w:[100,4] })
WriteResult({ "nInserted" : 1 })
> db.locations.insert({ w:[100,100] })
WriteResult({ "nInserted" : 1 })
> db.locations.insert({ w:[200,100] })
WriteResult({
    "nInserted" : 0,
    "writeError" : {
        "code" : 13027,
        "errmsg" : "point not in interval of [ -180, 180 ] :: caused by :: { _id: ObjectId('5a7b162cbba5630ed0ccc0d7'), w: [ 200.0, 100.0 ] }"
    }
})
>

$geoNear查询

格式

db.runCommand({
        geoNear:mycoll,
        near:[x, y],
        minDistance: (对2d索引无效)
        maxDistance:
        num:
    })

查询返回结果

{
    "results":[                 //查询的结果
        {
            "dis":              //查找到的数据与所指定查找的数据之间的距离
            "obj":{}            //查找到的数据
            }
            ],
            "stats":{           //查询的参数
            "nscanned":         //扫描了哪些数据
            "objectsloaded":
            "avgDistance":      //平均距离
            "maxDistance":      //最大的距离
            "time":             //花费的时间
        },
    "ok":
    }

2dsphere

格式:

db.mycoll.ensureIndex({w:"2dsphere"})

位置表示方式：

GeoJSON：描述一个点，一条直线，多边形等形状。
格式：

{type:'', coordinates:[list]}

GeoJSON查询可支持多边形交叉点等，支持MaxDistance 和 MinDistance

MongoDB 索引限制

额外开销

每个索引占据一定的存储空间，在进行插入，更新和删除操作时也需要对索引进行操作。所以，如果你很少对集合进行读取操作，建议不使用索引。

内存(RAM)使用

由于索引是存储在内存(RAM)中,你应该确保该索引的大小不超过内存的限制。

如果索引的大小大于内存的限制，MongoDB会删除一些索引，这将导致性能下降。

查询限制

索引不能被以下的查询使用：

• 正则表达式及非操作符，如 $nin, $not, 等。
• 算术运算符，如 $mod, 等。
• $where 子句

所以，检测你的语句是否使用索引是一个好的习惯，可以用explain来查看。

索引键限制

从2.6版本开始，如果现有的索引字段的值超过索引键的限制，MongoDB中不会创建索引。

插入文档超过索引键限制

如果文档的索引字段值超过了索引键的限制，MongoDB不会将任何文档转换成索引的集合。与mongorestore和mongoimport工具类似。

最大范围

• 集合中索引不能超过64个
• 索引名的长度不能超过128个字符
• 一个复合索引最多可以有31个字段

索引构建情况分析

mongostat工具

输出部分字段的含义

profile集合

• 查看当前数据库的profile状态

  > db.getProfilingStatus()
  { "was" : 0, "slowms" : 100 }

  • was--profile记录级别，0关闭，1记录所有慢查询，2记录所有操作
  • slowms--慢查询阀值

• 设置当前数据库的profile记录级别

  db.setProfilingLevel(0|1|2)

• 查看profile文件

  db.system.profile.find()
  
      { 
          "op" : "query",--操作类型
          "ns" : "dbname.system.profile", --查询的命名空间，;dbname.mycoll
          "query" : { "query" : {  }, --查询条件
          "orderby" : { "$natural" : -1 } }, --约束条件
          "ntoreturn" : 1, --返回数据条目
          "ntoskip" : 0,  --跳过的条目
          "nscanned" : 1, --扫描的数目含索引
          "nscannedObjects" : 1, --扫描的数据数目
          "keyUpdates" : 0,  --
          "numYield" : 0, --其他情况
          "lockStats" : {  --锁状态
          "timeLockedMicros" : { --锁占用时间（毫秒）
              "r" : NumberLong(82), --读锁
              "w" : NumberLong(0)   --写锁
                       },
          "timeAcquiringMicros" : {
               "r" : NumberLong(2), "w" : NumberLong(2)
                      }
                 },
          "nreturned" : 1,
          "responseLength" : 651,   --返回长度
          "millis" : 0, --查询时间
  }

日志

可以在服务启动文件指定选项vebose

verbose = vvvvv     # v 代表一个等级

explain分析

db.colltction.find({x:1}).explain()
{
        "cursor" : "BasicCursor",   --使用的游标
        "isMultiKey" : false,
        "n" : 1,
        "nscannedObjects" : 100000,  --扫描的数据量
        "nscanned" : 100000,         --包含索引的扫描量
        "nscannedObjectsAllPlans" : 100000,
        "nscannedAllPlans" : 100000,
        "scanAndOrder" : false,
        "indexOnly" : false,
        "nYields" : 781,
        "nChunkSkips" : 0,
        "millis" : 25,              --查询消耗时间（毫秒）可以比较一下索引建立前后的变化
        "server" : "XXX",
        "filterSet" : false
}