MongoDB之索引(十)

最新推荐文章于 2024-04-16 09:00:00 发布
最新推荐文章于 2024-04-16 09:00:00 发布
阅读量393 收藏
点赞数
分类专栏： # MongoDB
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43113679/article/details/92852043
版权

如果学过关系型数据库比如MySQL那你就应该明白索引的好处，尤其是对于数据量非常大的数据集特别明显

下面的所有的first 代表的是集合
准备数据

>for(i=0;i<10000;i++){db.first.insert({title:"标题"+i})}  //可以直接用命令行for循环添加数据

我就不全显示了，太多了，就显示数量

> db.first.find().count()
10000

利用explain进行分析查询语句，为了显示时间长点，就搜索最后的文档

db.first.find({title:"标题9999"}).explain("executionStats")  
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.first",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "title" : {
                                "$eq" : "标题9999"
                        }
                },
                "winningPlan" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "title" : {
                                        "$eq" : "标题9999"
                                }
                        },
                        "direction" : "forward"
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 1,
                "executionTimeMillis" : 14,       //主要是这个，显示时间用了多少，单位是ms
                "totalKeysExamined" : 0,
                "totalDocsExamined" : 10000,
                "executionStages" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "title" : {
                                        "$eq" : "标题9999"
                                }
                        },
                        "nReturned" : 1,
                        "executionTimeMillisEstimate" : 10,
                        "works" : 10002,
                        "advanced" : 1,
                        "needTime" : 10000,
                        "needYield" : 0,
                        "saveState" : 78,
                        "restoreState" : 78,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "direction" : "forward",
                        "docsExamined" : 10000
                }
        },
        "serverInfo" : {
                "host" : "LAPTOP-H3U7J3BH",
                "port" : 27017,
                "version" : "4.0.10",
                "gitVersion" : "c389e7f69f637f7a1ac3cc9fae843b635f20b766"
        },
        "ok" : 1
}

“executionTimeMillis” : 14 显示用时14ms ，记住这个时间，下面用索引来比较时间效率

1、创建索引

语法

db.collection.ensureIndex({索引的字段:1})

1为指定按升序创建索引，如果你想按降序来创建索引指定为**-1**即可。

多个索引字段：

一个索引有时候不能满足所需，所以要创建多个，像关系型数据库中的复合索引

db.collection.ensureIndex({索引的字段1:1,索引的字段2:1,索引的字段3:1})
ensureIndex()还可接受其他的参数
ParameterTypeDescription
backgroundBoolean建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引，即增加 “background” 可选参数。 “background” 默认值为false
uniqueBoolean建立的索引是否唯一。指定为true创建唯一索引。默认值为false
namestring索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成一个索引名称
dropDupsBoolean在建立唯一索引时是否删除重复记录,指定 true 创建唯一索引。默认值为 false
sparseBoolean对文档中不存在的字段数据不启用索引；这个参数需要特别注意，如果设置为true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 false
expireAfterSecondsinteger指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间
vindex version索引的版本号。默认的索引版本取决于mongod创建索引时运行的版本
weightsdocument索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得分权重
default_languagestring对于文本索引，该参数决定了停用词及词干和词器的规则的列表。 默认为英语
language_overridestring对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language，默认值为 language

2、显示所有索引

语法db.collection.getIndexes()

> db.first.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "test.first"
        },
        {
                "v" : 2,
                "key" : {
                        "title" : 1
                },
                "name" : "title_1",
                "ns" : "test.first"
        },
        {
                "v" : 2,
                "key" : {
                        "title" : -1
                },
                "name" : "title_-1",
                "ns" : "test.first"
        }
]

3、删除指定索引

语法db.collection.dropIndex(key)
key是上面的name，比如你创建某个字段的索引，就会生成name为：某字段_1/-1,删除字段根据name开删除

> db.first.dropIndex("title_1")
{ "nIndexesWas" : 3, "ok" : 1 }

测试效率

添加升序索引字段

> db.first.ensureIndex({title:1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}

再次用explain来分析查询语句

db.first.find({title:"标题9999"}).explain("executionStats")
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.first",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "title" : {
                                "$eq" : "标题9999"
                        }
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "title" : 1
                                },
                                "indexName" : "title_1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "title" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "title" : [
                                                "[\"标题9999\", \"标题9999\"]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 1,
                "executionTimeMillis" : 1,    //搜索时间为1
                "totalKeysExamined" : 1,
                "totalDocsExamined" : 1,
                "executionStages" : {
                        "stage" : "FETCH",
                        "nReturned" : 1,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 2,
                        "advanced" : 1,
                        "needTime" : 0,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "docsExamined" : 1,
                        "alreadyHasObj" : 0,
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "nReturned" : 1,
                                "executionTimeMillisEstimate" : 0,
                                "works" : 2,
                                "advanced" : 1,
                                "needTime" : 0,
                                "needYield" : 0,
                                "saveState" : 0,
                                "restoreState" : 0,
                                "isEOF" : 1,
                                "invalidates" : 0,
                                "keyPattern" : {
                                        "title" : 1
                                },
                                "indexName" : "title_1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "title" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "title" : [
                                                "[\"标题9999\", \"标题9999\"]"
                                        ]
                                },
                                "keysExamined" : 1,
                                "seeks" : 1,
                                "dupsTested" : 0,
                                "dupsDropped" : 0,
                                "seenInvalidated" : 0
                        }
                }
        },
        "serverInfo" : {
                "host" : "LAPTOP-H3U7J3BH",
                "port" : 27017,
                "version" : "4.0.10",
                "gitVersion" : "c389e7f69f637f7a1ac3cc9fae843b635f20b766"
        },
        "ok" : 1
}

上面经过创建索引后再进行搜索时间明显减少，为1ms，后面再经过测试，也就是经过第二次，第三次进行搜索，时间减到了0
下面先删除升序索引，创建降序索引：

> db.first.dropIndex("title_1")
{ "nIndexesWas" : 2, "ok" : 1 }
> db.first.ensureIndex({title:-1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
> db.first.find({title:"标题9999"}).explain("executionStats")
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.first",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "title" : {
                                "$eq" : "标题9999"
                        }
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "title" : -1
                                },
                                "indexName" : "title_-1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "title" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "title" : [
                                                "[\"标题9999\", \"标题9999\"]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 1,
                "executionTimeMillis" : 1,
                "totalKeysExamined" : 1,
                "totalDocsExamined" : 1,
                "executionStages" : {
                        "stage" : "FETCH",
                        "nReturned" : 1,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 2,
                        "advanced" : 1,
                        "needTime" : 0,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "docsExamined" : 1,
                        "alreadyHasObj" : 0,
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "nReturned" : 1,
                                "executionTimeMillisEstimate" : 0,
                                "works" : 2,
                                "advanced" : 1,
                                "needTime" : 0,
                                "needYield" : 0,
                                "saveState" : 0,
                                "restoreState" : 0,
                                "isEOF" : 1,
                                "invalidates" : 0,
                                "keyPattern" : {
                                        "title" : -1
                                },
                                "indexName" : "title_-1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "title" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "title" : [
                                                "[\"标题9999\", \"标题9999\"]"
                                        ]
                                },
                                "keysExamined" : 1,
                                "seeks" : 1,
                                "dupsTested" : 0,
                                "dupsDropped" : 0,
                                "seenInvalidated" : 0
                        }
                }
        },
        "serverInfo" : {
                "host" : "LAPTOP-H3U7J3BH",
                "port" : 27017,
                "version" : "4.0.10",
                "gitVersion" : "c389e7f69f637f7a1ac3cc9fae843b635f20b766"
        },
        "ok" : 1
}

这里用降序索引用时也是1ms，和用升序一样的用时，第二次及以后时间也会减少到0，
但是如果不建立索引，虽然也会根据搜索次数的增加而时间减少，但是会有下线，不会减少到0，
刚开始建立索引搜索的时候用时竟然是351ms，比不用索引大了10倍不止，虽然第二次搜索降为了0，但还是挺恐怖的，隔了一天我重新尝试，就是上面的这些了，显示用时才正常起来，索引第一次搜索比不用索引小很多，如果有知道原因的，大家可以评论一下，解决这个小bug

胖墩的IT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MongoDB 覆盖索引查询
12-16
MongoDB 覆盖索引查询 官方的MongoDB的文档中说明，覆盖查询是以下的查询： 所有的查询字段是索引的一部分 所有的查询返回字段在同一个索引中 由于所有出现在查询中的字段是索引的一部分， MongoDB 无需在整个数据...
MongoDB教程之索引介绍
09-10
主要介绍了MongoDB教程之索引介绍,本文讲解了索引基础、唯一索引、使用explain、索引管理等内容,需要的朋友可以参考下
MongoDB之索引
热门推荐
ntzzzsj的博客
06-22 1万+
数据库索引类似于图书索引。有了索引便不需要浏览整本书，而是可以采取一种快捷方式，只查看一个有内容引用的有序列表。这使得 MongoDB 的查找速度提高了好几个数量级。
MongoDB索引
qq15035899256的博客
05-08 2210
本文是对MongoDB的学习，先认识了MongoDB的数据存储结构和索引数据结构，又学习了如何创建、查看、删除索引，最后深入学习了索引的多种类型和属性。之后的学习内容将持续更新！！！
MongoDB 索引全攻略
我是一名热爱编程和分享知识的技术作者，在金融和教育领域有多年的研发管理经验，感谢您访问我的博客，一定会为您带来不一样的收货！
04-16 1124
任何数据库都有索引这一核心功能，索引通常能够极大的提高查询效率，如果没有索引，MongoDB 在读取数据时必须扫描集合中的每个文件，并选取那些符合查询条件的记录。这种扫描查询集合的查询方式效率非常低，特别在处理大量数据时。索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构。
MongoDB基础之索引详解
上善若泪
11-05 2286
索引通常能够极大的提高查询的效率，如果没有索引，MongoDB在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构由于索引存在于RAM中，所以覆盖索引 从索引中获取数据比通过扫描文档读取数据要快得多MongoDB在MongoDB。
MongoDB 索引详解（一）
YHJ
05-12 7983
默认_id 索引 创建索引 索引类型 索引属性 索引使用 索引及排序规则 覆盖查询 交叉索引 限制 其他注意事项 索引支持MongoDB中查询的高效执行。如果没有索引，MongoDB必须执行集合扫描，即扫描集合中的每个文档，以选择与查询语句匹配的文档。如果查询存在适当的索引，MongoDB可以使用索引来限制它必须检查的文档数。 索引是特殊的数据结构[1]，它以易于遍历的形式存储部分集合数据集。索引存储特定字段或字段集的值，按字段值排序。索引条目的排序支持高效的等值匹配和基于范围的查询操作
MongoDB文档-进阶使用-MongoDB索引-createindex()与dropindex()-在MongoDB中使用正则表达式来查找
阿丹的博客
08-04 2475
阿丹：之前研究了MongoDB的基础增删改查。在学会基础的数据库增删改查肯定是不够的。这个时候就涉及到了数据库搜索的时候的效率。需要提高数据的搜索效率。
MongoDB的索引
12-16
而有了目录（索引）之后就可以通过它帮我们定位到目标所在的位置，快速的获取我们想要的结果。 2、演示 第一步，向用户集合users中插入100W条数据 var insertUsers = function() { var start = new Date().getTime...
MongoDB学习笔记之索引（一）
yaya_jn的博客
04-25 7879
MongoDB索引 索引是一种用来快速查询数据的数据结构。B+Tree就是一种常见的数据库索引数据结构，MongoDB采用B+Tree做索引，索引创建在collections上。MongoDB不使用索引的查询，先扫描所有的文档，再匹配符合条件的文档。使用索引的查询，通过索引找到文档，使用索引能够极大的提升查询效率。 一、MongoDB索引数据结构 索引数据结构介绍及官方文档 MongoDB索引数据结构具体使用的是B+Tree，因为B+Tree是B-Tree的子集，所以叫B-Tree也对，但是容易混淆
MongoDB索引详解-03
YanQiuXiang
06-17 4092
索引是一种用来快速查询数据的数据结构。B+Tree就是一种常用的数据库索引数据结构，MongoDB采用B+Tree 做索引，索引创建在colletions上。MongoDB不使用索引的查询，先扫描所有的文档，再匹配符合条件的文档。使用索引的查询，通过索引找到文档，使用索引能够极大的提升查询效率。按照索引包含的字段数量，可以分为单键索引和组合索引（或复合索引）。按照索引字段的类型，可以分为主键索引和非主键索引。按照索引节点与物理记录的对应方式来分，可以分为聚簇索引和非聚簇索引，其。
MongoDB索引简介与使用
snow_adfe的博客
06-26 2707
MongoDB索引简介与使用
《MongoDB入门教程》第27篇 创建索引
Tony.Dong的专栏
03-03 1449
本文介绍了 MongoDB 索引的概念，索引提高了文件的检索性能，但是需要以额外的写入和存储空间为代价。本文还涉及了如何利用 createIndex() 方法创建索引，利用 getIndexes() 查看索引，以及 explain() 查看执行计划的统计信息。
《MongoDB入门教程》第28篇 删除索引
Tony.Dong的专栏
03-13 1698
本文介绍了删除 MongoDB 索引的 dropIndex() 和 dropIndexes() 方法，主键（_id）索引无法被删除。
【MongoDB】索引
qq_61903414的博客
08-08 1011
索引支持在MongoDB中高效地执行查询。如果没有索引，MongoDB必须执行全集合扫描，也就是扫描集合中的每一个文档，以选择与查询语句匹配的文档。这种扫描全集和的查询效率是非常低的，特别是在处理大量的数据时，查询可能要花费几十秒甚至几分钟，这对服务器的性能是非常致命的。如果查询存在适当的索引，就可以使用该索引限制必须检查的文档数。索引是特殊的数据结构，他以易于遍历的形式存储集合数据集的一小部分。索引存储特点的字段或一组字段的值，按字段值排序。索引项的排序支持有效的相等匹配和基于范围的查询操作。
6.MongoDB之索引
mijichui2153的博客
02-18 4936
关于索引举个日常生活中的例子。拿到一本书想查阅某知识的时候我们一般都会先去看目录，找到相关的章节后直接翻到对应的页码然后在这里小章节里面进一步定位我们想要的内容；这就是目录索引，能够帮助读者快读的找到想要找的内容。(一个更好的例子应该是英汉词典了，当我们查询单词的时候我们不会一页一页的去遍历整个词典，而是现根据首字母快读定位到对应章节然后再根据次字母进一步缩小查询范围，知道最终找到对应单词。) 其实在数据库中也一样，索引能够极大的提高查询效率。如果没有索引mongodb在读取数据的时候必须扫描集合中的每个.
MongoDB教程：索引createIndex与dropindex
学亮编程手记
08-24 604
索引在任何数据库中都非常重要，对于MongoDB也是一样，索引并没有什么不同。使用索引，在MongoDB中执行查询变得更加高效。如果有一个包含成千上万个没有索引的文档的集合，查询出某些文档，在这种情况下，MongoDB将需要扫描整个集合以找到这些文档。但是，如果有索引，MongoDB将使用这些索引来限制必须在集合中搜索的文档数。索引是特殊数据集，用于存储集合数据的一部分。由于数据是部分数据，因此读取该数据变得更加容易。此部分集存储特定字段的值或按字段值排序的一组字段。我们将学习——
mongodb: 索引
qq_39198749的博客
05-22 268
索引是对数据库表中一列或多列的值进行排序的一种结构，可以极大的提高查询效率。
MongoDB内容分享（三）：MongoDB 索引-Index、集群、安全
之乎者也·的博客
12-08 1029
索引支持在MongoDB中高效地执行查询。如果没有索引，MongoDB必须执行全集合扫描，即扫描集合中的每个文档，以选择与查询语句匹配的文档。这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。如果查询存在适当的索引，MongoDB可以使用该索引限制必须检查的文档数。索引是特殊的数据结构，它以易于遍历的形式存储集合数据集的一小部分。索引存储特定字段或一组字段的值，按字段值排序。索引项的排序支持有效的相等匹配和基于范围的查询操作。
mongodb的索引
最新发布
04-24
MongoDB的索引是一种用于提高查询性能的数据结构。它可以帮助MongoDB在查询数据时更快地定位到所需的文档。 MongoDB支持多种类型的索引，包括： 1. 单字段索引：最简单的索引类型，基于单个字段创建。它可以加速对...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值