MongoDB的索引特性

最新推荐文章于 2021-12-11 22:31:08 发布
最新推荐文章于 2021-12-11 22:31:08 发布
阅读量139 收藏
点赞数
分类专栏： MongoDB
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30166729/article/details/103075637
版权

mongoDB中collections中会有默认索引 _id索引，
单键索引

# 在name属性上添加索引
db.student.createIndex({name:1})
# 查看查询学生名为 学生1 的执行计划
db.student.find({name:"学生1"}).explain()
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "kaka.student",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "name" : {
                                "$eq" : "学生1"
                        }
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "name" : 1
                                },
                                "indexName" : "name_1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "name" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "name" : [
                                                "[\"学生1\", \"学生1\"]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "iz8vb4efgq8tzqwlylia5uz",
                "port" : 27017,
                "version" : "4.0.5",
                "gitVersion" : "3739429dd92b92d1b0ab120911a23d50bf03c412"
        },
        "ok" : 1
}

多键索引

# 添加在数据类型为数组上的索引
db.student.createIndex({subject: 1})
# 查看执行计划
db.student.find({"subject": "chinese"}).explain()
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "kaka.student",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "subject" : {
                                "$eq" : "chinese"
                        }
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "subject" : 1
                                },
                                "indexName" : "subject_1",
                                "isMultiKey" : true,
                                "multiKeyPaths" : {
                                        "subject" : [
                                                "subject"
                                        ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "subject" : [
                                                "[\"chinese\", \"chinese\"]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "iz8vb4efgq8tzqwlylia5uz",
                "port" : 27017,
                "version" : "4.0.5",
                "gitVersion" : "3739429dd92b92d1b0ab120911a23d50bf03c412"
        },
        "ok" : 1
}

复合索引

# 多键值
db.student.createIndex({name:1, age: -1})
# 查询
# 查询索引中第一个字段
db.student.find({name:"学生1"}).explain(); # 使用索引
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "kaka.student",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "name" : {
                                "$eq" : "学生1"
                        }
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "name" : 1,
                                        "age" : -1
                                },
                                "indexName" : "name_1_age_-1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "name" : [ ],
                                        "age" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "name" : [
                                                "[\"学生1\", \"学生1\"]"
                                        ],
                                        "age" : [
                                                "[MaxKey, MinKey]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "iz8vb4efgq8tzqwlylia5uz",
                "port" : 27017,
                "version" : "4.0.5",
                "gitVersion" : "3739429dd92b92d1b0ab120911a23d50bf03c412"
        },
        "ok" : 1
}
db.student.find({age:18}).explain() # 不使用索引
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "kaka.student",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "age" : {
                                "$eq" : 18
                        }
                },
                "winningPlan" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "age" : {
                                        "$eq" : 18
                                }
                        },
                        "direction" : "forward"
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "iz8vb4efgq8tzqwlylia5uz",
                "port" : 27017,
                "version" : "4.0.5",
                "gitVersion" : "3739429dd92b92d1b0ab120911a23d50bf03c412"
        },
        "ok" : 1
}
# 按照索引中字段顺序查询  使用索引
db.student.find({name:"学生1", age:{$gt:18}}).explain()
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "kaka.student",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "$and" : [
                                {
                                        "name" : {
                                                "$eq" : "学生1"
                                        }
                                },
                                {
                                        "age" : {
                                                "$gt" : 18
                                        }
                                }
                        ]
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "name" : 1,
                                        "age" : -1
                                },
                                "indexName" : "name_1_age_-1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "name" : [ ],
                                        "age" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "name" : [
                                                "[\"学生1\", \"学生1\"]"
                                        ],
                                        "age" : [
                                                "[inf.0, 18.0)"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "iz8vb4efgq8tzqwlylia5uz",
                "port" : 27017,
                "version" : "4.0.5",
                "gitVersion" : "3739429dd92b92d1b0ab120911a23d50bf03c412"
        },
        "ok" : 1
}
# 调换查询的字段顺序  使用索引
db.student.find({age:{$gt:18},name:"学生1"}).explain()
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "kaka.student",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "$and" : [
                                {
                                        "name" : {
                                                "$eq" : "学生1"
                                        }
                                },
                                {
                                        "age" : {
                                                "$gt" : 18
                                        }
                                }
                        ]
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "name" : 1,
                                        "age" : -1
                                },
                                "indexName" : "name_1_age_-1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "name" : [ ],
                                        "age" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "name" : [
                                                "[\"学生1\", \"学生1\"]"
                                        ],
                                        "age" : [
                                                "[inf.0, 18.0)"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "iz8vb4efgq8tzqwlylia5uz",
                "port" : 27017,
                "version" : "4.0.5",
                "gitVersion" : "3739429dd92b92d1b0ab120911a23d50bf03c412"
        },
        "ok" : 1
}

排序场景

"key" : {
   "name" : 1,
   "age" : -1
},
"name" : "name_1_age_-1",

# 按照名称排序
db.student.find().sort({name:1}).explain()   #走索引
db.student.find().sort({name:-1}).explain() #走索引
db.student.find().sort({age:-1}).explain() #不走索引
db.student.find().sort({age:1}).explain() #不走索引
db.student.find().sort({name:1, age: -1}).explain() #走索引
db.student.find().sort({name:1, age: 1}).explain() #不走索引
db.student.find().sort({name:-1, age: 1}).explain() #走索引
db.student.find().sort({name:-1, age: -1}).explain() #不走
db.student.find().sort({age: -1, name:1}).explain() #不走
db.student.find().sort({age: -1, name: -1}).explain() #不走
db.student.find().sort({age: 1, name: -1}).explain() #不走
db.student.find().sort({age: 1, name: 1}).explain() #不走

全文索引

# 加在字段属性为字符串的字段上
# 添加数据
db.project.insert(
   [ { _id: 1, name: "Java Script", description: "name is js and jquery" },
     { _id: 2, name: "Git", description: "Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency" },
     { _id: 3, name: "Apache dubbo", description: "Apache Dubbo  is a high-performance, java based open source RPC framework.阿里 开源 项目" },
     { _id: 4, name: "Redis", description: "Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache and message broker. It supports data structures" },
     { _id: 5, name: "Apache ZooKeeper", description: "Apache ZooKeeper is an effort to develop and maintain an open-source server which enables highly reliable distributed coordination" }
   ]
)

# 多关键词查询
db.project.find({$text:{$search:"java dubbo"}})
{ "_id" : 3, "name" : "Apache dubbo", "description" : "Apache Dubbo  is a high-performance, java based open source RPC framework.阿里 开源 项目" }
{ "_id" : 1, "name" : "Java Script", "description" : "name is js and jquery" }
# 由于id为3的是通过java和dubbo匹配查询到的，所以权重更高

#使用-屏蔽关键字
db.project.find({$text:{$search:"java -dubbo"}})
{ "_id" : 1, "name" : "Java Script", "description" : "name is js and jquery" }

# 查询短语，\" 包含即可
db.project.find({$text:{$search:"\"Apache Dubbo\""}})
{ "_id" : 3, "name" : "Apache dubbo", "description" : "Apache Dubbo  is a high-performance, java based open source RPC framework.阿里 开源 项目" }

过期索引

# 过期索引设置在时间列上，过期后删除数据
# 创建索引
db.log.createIndex({"createTime":1},{expireAfterSeconds:10})
# 插入数据
db.log.insert({"title":"this is logger info","createTime":new Date()})
# 立即查看数据
db.log.find()
{ "_id" : ObjectId("5dcd657d64782a209176b919"), "title" : "this is logger info", "createTime" : ISODate("2019-11-14T14:32:29.321Z") }
# 10秒后查看数据
> db.log.find()
>
db.log.insert({"title":"this is logger info","createTime":Date()}) 
# 时间字符串是删除不了的
会飞的卡卡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MongoDB索引特性
Tony10010的博客
03-31 134
唯一索引 值唯一，不能重复 db.users.dropIndexes() // 删除全部索引 > db.users.find() { "_id" : ObjectId("601cf85c7cfdb08d65ff4668"), "name" : "n1", "age" : 20, "gender" : "m", "birth" : ISODate("2000-04-10T00:00:00Z"), "pswd" : "password123", "courses" : [ "Golang", "Gor..
MongoDB性能篇之索引分析
u011374919的博客
08-02 552
一、索引MongoDB 提供了多样性的索引支持，索引信息被保存在system.indexes 中，且默认总是为_id创建索引，它的索引使用基本和MySQL 等关系型数据库一样。其实可以这样说说，索引是凌驾于数据存储系统之上的另一层系统，所以各种结构迥异的存储都有相同或相似的索引实现及使用接口并不足为 奇。1.基础索引在字段age 上创建索引，1(升序);-1(降序)：db.users.en
MongoDB索引概述
张启明
12-26 471
数据库索引与书籍的索引类似。有了索引就不需要反正本书，数据库可以直接在索引中查找。在索引中找到条目后就可以直接跳转到目标文件中，这能使查找速度提高几个数量级。复合索引1.建立 db.user.ensureIndex({“age”:1,”username”:1}); 每一个索引条目都包含一个“age”字段和一个“username”字段，并且指向文档在磁盘上的存储位置（重点）。2.使用mongodb
MongoDB 索引详解
黑白影的博客
01-16 526
一、索引简介 1.1 创建索引 和大多数关系型数据库一样，MongoDB 支持使用索引来进行查询优化，采用类似 B-Tree 的数据结构来储存索引和文档的位置信息，同样也支持前缀索引和覆盖索引。在当前最新的 MongoDB 4.0 中，索引的创建语法如下： db.collection.createIndex( <key and index type specification>, &l...
mongodb常用命令
阳光梦的专栏
05-06 2306
如：如果你想创建一个“myTest”的数据库，先运行use myTest命令，之后就做一些操作（如：db.createCollection('user')）,这样就可以创建一个名叫“myTest”的数据库。 一、数据库常用命令 1、Help查看命令提示 复制代码 代码如下: help db.help(); db.yourColl.help(); db.youColl.find
MongoDB的索引
09-09
MongoDB的索引是数据库管理系统中用于加速查询性能的关键组件。在MongoDB中，索引类似于书籍的目录，它帮助...正确地设计和管理索引是数据库性能调优的关键步骤，应根据具体的应用场景和数据特性来制定合适的索引策略。
大数据环境下mongoDB为何要加索引浅析
09-09
在实际应用中，应根据查询需求和数据特性，选择合适的索引策略，以达到最佳的性能表现。同时，定期评估和调整索引策略也是保持数据库高效运行的重要环节。希望本文的内容对你的MongoDB使用和学习有所帮助，让你在大...
MONGODB的索引探究
06-25
MongoDB的索引是数据库性能优化的关键因素，与MySQL、Oracle等关系型数据库中的索引原理相似，但具有自身的特性和限制。MongoDB的索引建立在Collection...了解和掌握MongoDB的索引特性，对于优化数据库性能至关重要。
mongodb如何建立索引
04-29
组合索引有许多特性要记住，例如创建索引语句如下 db.foo.ensureIndex({a: 1, b: 1, c: 1}) 。 使用 Explain 命令可以查看查询的过程，并且可以查看是否使用缩影。explain 输出主要有三个字段：cursor、nscanned、n...
MongoDB索引与查询.pdf
07-11
每个索引类型都有其特定的用途和性能特性。 例如，**单字段索引**是针对单个字段创建的，是最基础的索引类型，适用于最常见的查询场景。**复合索引**则由多个字段组成，可以优化涉及多个字段的查询。**唯一索引**...
MongoDB - 索引的管理和类型
it_lihongmin的博客
08-06 5629
MongoDB的索引与mysql的索引大致相同，但是由于MongoDB的特有性，比如文档可能不会存在某一个字段，文档有嵌套以及数组类型，所以也会有些许差异。为了测试数据，和demo的使用，单节点上创建一个1千万的文档，如下： for(i=0; i&lt;1000000; i++) { db.user.insert({"i":i,"username":"user"+i,"age"...
MongoDB 优缺点
热门推荐
羽过天晴
03-22 7万+
mongodb与关系型数据库相比的优缺点与关系型数据库相比，MongoDB的优点：①弱一致性（最终一致），更能保证用户的访问速度：举例来说，在传统的关系型数据库中，一个COUNT类型的操作会锁定数据集，这样可以保证得到“当前”情况下的较精确值。这在某些情况下，例 如通过ATM查看账户信息的时候很重要，但对于Wordnik来说，数据是不断更新和增长的，这种“较精确”的保证几乎没有任何意义，反而会产生...
mongodb的explain分析执行过程
哇哦~
01-20 1547
numbers集合里有2000个{"_id":XXXX, "num":XXX}这样的文档。执行如下查询语句 db.numbers.find({num:{"$gt":1995}}).explain("executionStats") //execution-stats 3.0以后新增的 输出以下： {      "queryPlanner" : {         "plannerVersio.
MongoDB查看执行计划
weixin_33696106的博客
11-30 520
MongoDB中的explain()函数可以帮助我们查看查询相关的信息，这有助于我们快速查找到搜索瓶颈进而解决它，本文我们就来看看explain()的一些用法及其查询结果的含义。 本文是MongoDB系列的第八篇文章，了解前面的文章有助于更好的理解本文： 1.Linux上安装MongoDB 2.MongoDB基本操作 3.Mon...
mongoDB 索引分析
yinhaoh的博客
12-11 1510
概述 最近在执行脚本更新全表数据和查询数据清全表的时候遇到索引的问题，因此进行一下学习总结。 mongoDB的索引是在集合级别定义的索引，也就是说，集合里的字段也被支持。 不走索引分页查全表的情况 不走索引根据id排序过滤查全表的情况 走索引的情况 索引的目的 减少行数的扫减、少内存计算 默认索引 在创建集合的时候，mongoDB会自动创建_id索引，且不能被删除。 索引交集 mongoDB可以使用多个/嵌套索引交集来解析查询。 索引交集可以是整个索引，也可以是索引前缀的交集（即每个索引前面到不匹配终止）。
Mongo的SQL语句如何通过explain来优化
冰刀(skate)
08-12 710
Author:skatexg Time:2021/08/12 mongo的SQL语句为什么慢？如何优化慢sql？（如何定位慢sql不在本文讨论范围内） 这个时候就需要根据SQL语句的执行计划来诊断了 一. Mongo的SQL执行计划介绍 查看SQL语句执行计划： db.docl2.find({"by":"sdsd"}).explain("queryPlanner") //这个语句不是真正执行SQL语句,是explain的默认参数 queryPlanner的解释： { "queryP..
mongo数据库索引原理
u012939368的博客
08-05 1万+
索引的本质 索引（Index）是帮助数据库高效获取数据的数据结构。提取句子主干，就可以得到索引的本质：索引是数据结构。 现在的数据库（mongo，mysql等）索引多采用B－Tree数据结构
Mongodb中Index特性
深入一点
10-27 2616
    Mongodb支持多种index类型，这相对于其他Nosql数据库而言具有很大的优势，它的索引类型比较接近SQL数据库，所以开发者在mongodb中使用索引将是非常便捷的。索引最大的作用就是提高query的查询性能，如果没有索引，mongodb需要scan整个collection的所有的documents，并筛选符合条件的document，如果有索引，那么query只需要遍历index...
一篇文章带你学习 MongoDB 中各种类型的索引（_id索引/复合索引/过期索引/全文索引/地理空间索引/复合地理空间索引）
南淮北安的博客
08-24 2711
上篇文章中我们介绍了 MongoDB 中索引的简单操作，创建、查看、删除等基本操作，不过上文我们只介绍了一种类型的索引，本文我们来看看其他类型的索引。 文章目录一、_id 索引二、复合索引三、过期索引四、全文索引五、地理空间索引1. 2d 索引2. 2d sphere 索引六、复合地理空间索引 一、_id 索引 我们在上文介绍过，我们往集合中添加文档时，默认情况下MongoDB都会帮助我们创建一个名为_id的字段，这个字段就是一个索引。默认情况下，一般的集合都会帮我们创建这个字段作为索引，但也有一些集合不会
MongoDB安装与特性详解
MongoDB以其灵活性、可扩展性和易用性而备受青睐，特别强调了以下关键特性： 1. **面向文档存储**：MongoDB采用类似JSON的BSON数据格式，允许存储复杂的数据结构，如文档、数组和嵌套对象，使得数据模型更加灵活。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值