mongodb索引

索引Index:

索引就是用来加速的，特殊数据结构，存在磁盘上(缓存在内存中)，保存存储表数据的一小部分数据，可以帮助我们快速查找数据，索引中的数据，会有一个指针指向数据行所在磁盘的真正BLOCK位置

优点：
1、大大减少了服务器需要扫描的数据量
2、索引可以帮助服务器减少排序或临时表的使用，(已经排好序的索引)
3、索引可以将随机I/O转换成顺序I/O

三星索引：
一星：索引如果能将相关的记录放置在一起
二星：索引中数据的存储顺序与查找标准中顺序一致
三星：如果索引中包含查询中所需要的全部数据(覆盖索引)

索引类型：

B+Tree 平衡树索引：每叶子节点到树根的距离是相同的，顺序索引
Hash索引：hash桶算法，散列索引
空间(R-Tree)索引：地理空间数据索引
全文(Full-text)索引：全文检索

顺序索引：
    全值精确匹配：name="neo"
    匹配最左前缀：name like "neo%",无效：name like "%neo%",
    匹配列前缀
    匹配范围值
    精确匹配某一列并范围匹配另外一列：name="neo" and age > 25
    只访问索引的查询
    {聚簇索引：索引与数据挨着放，索引后续的指针其实就是数据，记录文件中的记录顺序与索引顺序排序，聚簇索引也称为主索引，其他索引为辅助索引}
    {非聚簇索引：索引中指定的次序与记录文件中的记录次序不一致}
散列索引：
    散列函数：分布随机，分布均匀

mysql索引：根据存储引擎的不同支持的索引类型也不同

Myisam存储引擎：索引文件是{.MYI}，
InnoDB存储引擎：索引是表空间的组成部分，{.ibd}，主要是B+Tree索引

建立索引需要考虑的问题：

1、会做什么样的查询？其中哪些键需要索引？
2、每个键的索引方向是怎么样的？
3、如何应对扩展？有没有种不同的键的排列可以使常用数据更多地保留在内存中？

Mongodb索引：几乎与关系型数据库支持的索引类型一模一样

单字段索引，组合索引，多键索引，空间索引，文本索引，hash索引

db.mycoll.ensureIndex(field[,options])
  name,unique,dropDups,sparse
db.mycoll.dropIndex(index_name)
db.mycoll.dropIndexes()
db.mycoll.getIndexes()
db.mycoll.reIndex()

mongodb索引创建：

唯一键索引：{"unique":true}
消除重复索引：{"dropDups":true}
索引测试：explain()
指定索引查询:hint(INDEX_NAME)
索引后台创建:{"background":true}  #默认阻塞建立索引期间的所有请求

mongodb索引管理：system.indexes
索引只能通过ensureIndex,dropIndexes进行system.indexes操作

例子：

# 创建测试文档数据
# for(i=1;i<=100;i++) db.testcoll.insert({name:"user"+i,age:(i%150),address:"#"+i+"tianzhong,shenzhen,china",prefrebooks:["book"+i,"helloworld"]})
# 查看集合所有索引，默认情况下，只会以"_id"作为键来创建索引
> db.system.indexes.findOne()
{
    "v" : 1,
    "key" : {
        "_id" : 1
    },
    "name" : "_id_",
    "ns" : "testdb.testcoll"
}
# 查询数据，使用默认索引
> db.testcoll.find({name:"user58"}).explain()
{
    "cursor" : "BasicCursor",               # 表示没有使用索引
    "isMultiKey" : false,                   
    "n" : 1,                                # 查询返回数据的文档数
    "nscannedObjects" : 100,                # 扫描objects数
    "nscanned" : 100,                       # 三秒文档数
    "nscannedObjectsAllPlans" : 100,
    "nscannedAllPlans" : 100,
    "scanAndOrder" : false,
    "indexOnly" : false,
    "nYields" : 0,
    "nChunkSkips" : 0,
    "millis" : 0,                           # 花费时间
    "server" : "node1:27017",
    "filterSet" : false
}
# 创建索引
> db.testcoll.ensureIndex({name:1})         # 创建以name键为索引
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
# 查看创建的索引
> db.testcoll.getIndexes()
[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "testdb.testcoll"
    },
    {
        "v" : 1,
        "key" : {
            "name" : 1
        },
        "name" : "name_1",              # 索引名字
        "ns" : "testdb.testcoll"        # 索引的位置，在数据库集合上
    }
]
# 在此执行查询
> db.testcoll.find({name:"user11"}).explain()
{
    "cursor" : "BtreeCursor name_1",        # 使用name_1索引
    "isMultiKey" : false,
    "n" : 1,
    "nscannedObjects" : 1,                  # 扫描的数据为1个文档
    "nscanned" : 1,
    "nscannedObjectsAllPlans" : 1,
    "nscannedAllPlans" : 1,
    "scanAndOrder" : false,
    "indexOnly" : false,
    "nYields" : 0,
    "nChunkSkips" : 0,
    "millis" : 0,
    "indexBounds" : {
        "name" : [
            [
                "user11",
                "user11"
            ]
        ]
    },
    "server" : "node1:27017",
    "filterSet" : false
}
# 最左前缀匹配测试，创建以姓名和年龄的索引
db.testcoll.ensureIndex({name:1,age:1}) 
# 以年龄查询
> db.testcoll.find({age:{$gt:34,$lt:50}}).explain()
{
    "cursor" : "BasicCursor",     # 没有使用任何索引
    "isMultiKey" : false,
    "n" : 15,
    "nscannedObjects" : 100,
    "nscanned" : 100,
    "nscannedObjectsAllPlans" : 100,
    "nscannedAllPlans" : 100,
    "scanAndOrder" : false,
    "indexOnly" : false,
    "nYields" : 0,
    "nChunkSkips" : 0,
    "millis" : 0,
    "server" : "node1:27017",
    "filterSet" : false
}
# 创建以年龄和姓名的索引
db.testcoll.ensureIndex({age:1,name:1})
# 在次查询年龄
> db.testcoll.find({age:{$gt:34,$lt:50}}).explain()
{
    "cursor" : "BtreeCursor age_1_name_1",          #
    "isMultiKey" : false,
    "n" : 15,
    "nscannedObjects" : 15,
    "nscanned" : 15,
    "nscannedObjectsAllPlans" : 15,
    "nscannedAllPlans" : 15,
    "scanAndOrder" : false,
    "indexOnly" : false,
    "nYields" : 0,
    "nChunkSkips" : 0,
    "millis" : 0,
    "indexBounds" : {
        "age" : [
            [
                34,
                50
            ]
        ],
        "name" : [
            [
                {
                    "$minElement" : 1
                },
                {
                    "$maxElement" : 1
                }
            ]
        ]
    },
    "server" : "node1:27017",
    "filterSet" : false
}
# mongodb是自动匹配最佳索引，进行搜索
# hint使用
> db.testcoll.find({name:"user12"}).hint("name_1_age_1").explain()
{
    "cursor" : "BtreeCursor name_1_age_1",          # 根据指定的索引名称进行搜索
    "isMultiKey" : false,
    "n" : 1,
    "nscannedObjects" : 1,
    "nscanned" : 1,
    "nscannedObjectsAllPlans" : 1,
    "nscannedAllPlans" : 1,
    "scanAndOrder" : false,
    "indexOnly" : false,
    "nYields" : 0,
    "nChunkSkips" : 0,
    "millis" : 0,
    "indexBounds" : {
        "name" : [
            [
                "user12",
                "user12"
            ]
        ],
        "age" : [
            [
                {
                    "$minElement" : 1
                },
                {
                    "$maxElement" : 1
                }
            ]
        ]
    },
    "server" : "node1:27017",
    "filterSet" : false
}
# 问题来了，在业务逻辑上是常使用以name，或者有时候采用name+age的方式进行搜索，name_1_age_1这个所以符合两个需求
# 那么name_1这个索引就是累赘，舒服重复索引，age_1_name_1，不匹配最左前缀索引的使用法则，也是无用的。

mongodb的聚合函数：

count:返回集合中的文档数量
# db.testcoll.find().count()
distinct:找出给定键的所有不同的值，使用时必须指定集合和键
group:类似SQL中的group by
mapreduce