关于mongodb创建索引的一些经验总结

最新推荐文章于 2024-07-20 09:52:04 发布
最新推荐文章于 2024-07-20 09:52:04 发布
阅读量1w 收藏 15
点赞数 3
分类专栏： mongodb 文章标签： mongodb 性能 索引
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/startupmount/article/details/37312205
版权

想来接触mongodb已经快一年了，对于它的索引知识也积攒了不少经验，趁着这个月黑风高的夜晚，就把mongodb的索引总结一番吧。

一，索引介绍

    mongodb具有两类索引，分别为单键索引和复合索引。

    1.单键索引是最简单的一种索引，创建单键索引的开销要比复合索引小很多。单键索引主要用于针对单值查询的条件。

    2.复合索引是将文档中的几个键联合起来创建的一种索引，创建这种索引需要更多的空间与性能开销。分别体现在：

        1).在给大量数据创建复合索引时，会阻塞数据库的查询，更不用说修改和插入操作了；

        2).插入一条数据时，要花费更多的时间来给复合索引加数据；

        3).创建的复合索引所站得空间大小根据数据的类型以及键的数量而有所不同。比如，如果你用五个NumberInt的键创建的复合索引的空间大小，并不会比两个NumberInt和一个String类型创建的复合索引占用更多的空间。索引在设计数据类型时，尽量将数据类型设置为NumberInt类型，以及尽量少使用string类型的数据做索引；


二，创建索引

    创建索引的语句很简单。

    1.单键索引的创建：db.test.ensureIndex({name:1},{name:'index_name'})

    2.复合索引的创建：db.test.ensureIndex({name:1,age:1,sex:1},{name:'index_nas'})


三，索引优化

    索引的优化是一个重头戏，需要详细的来解释。我得测试数据插入了100万条。字段分别为name,sex,type,time,id

    1.我们来看一个简单的查询：db.test.find({name:'name_1'})  相信大家对这个查询已经很熟悉了，然后我们来看看这个语句的索引执行计划：

    

{
	"cursor" : "BasicCursor",   查询语句所用到的索引，而BasicCursor代表没有索引
	"isMultiKey" : false,     是否为复合索引
	"n" : 1,       查询到的结果数
	"nscannedObjects" : 1000000,    扫描的文档数量
	"nscanned" : 1000000,     扫面的索引数量
	"nscannedObjectsAllPlans" : 1000000,   //影响的所有的被扫描文档的总数量
	"nscannedAllPlans" : 1000000,      //所有被扫描的索引的总数量
	"scanAndOrder" : false,  是否排序
	"indexOnly" : false,
	"nYields" : 2,
	"nChunkSkips" : 0,
	"millis" : 342,   花费的时间
	"indexBounds" : {
		
	},
	"server" : "node1:27017"
}

    从这个执行计划中可以看出，该条查询语句查询一条数据需要扫描整个表，这肯定扯淡了嘛，那这时候就该给这个字段创建索引了，创建一个单键索引

    db.test.ensureIndex({name:1},{name:'index_name'})

    创建完索引之后，再来查看看这条查询语句的执行计划：

    

{
	"cursor" : "BtreeCursor index_name",
	"isMultiKey" : false,
	"n" : 1,
	"nscannedObjects" : 1,
	"nscanned" : 1,
	"nscannedObjectsAllPlans" : 1,
	"nscannedAllPlans" : 1,
	"scanAndOrder" : false,
	"indexOnly" : false,
	"nYields" : 0,
	"nChunkSkips" : 0,
	"millis" : 0,
	"indexBounds" : {
		"name" : [
			[
				"name_1",
				"name_1"
			]
		]
	},
	"server" : "node1:27017"
}

    简直是逆天啊，nscanned和nscannedObjects居然从100万下降到1条，也就是查询数据时，只扫描了一条就已经找到，而且花费的时间是0秒，没有创建索引时，居然是342毫秒，绝对索引威武啊。

    2.这时候我想通过type和sex来组合查询某一条件的数据: db.test.find({type:1,sex:0})  看看这句的执行计划：

    

{
	"cursor" : "BasicCursor",
	"isMultiKey" : false,
	"n" : 55555,
	"nscannedObjects" : 1000000,
	"nscanned" : 1000000,
	"nscannedObjectsAllPlans" : 1000000,
	"nscannedAllPlans" : 1000000,
	"scanAndOrder" : false,
	"indexOnly" : false,
	"nYields" : 0,
	"nChunkSkips" : 0,
	"millis" : 529,
	"indexBounds" : {
		
	},
	"server" : "node1:27017"
}

    从这个计划中可以看出，为了查找几万条数据，它也扫描了整个表，很显然，该创建索引了：

    db.test.ensureIndex({type:1,sex:1},{name:'index_ts'})

    创建完索引之后，再来执行查询语句，看看执行计划：

    

db.test.find({type:1,sex:0}).explain()
{
	"cursor" : "BtreeCursor index_ts",
	"isMultiKey" : false,
	"n" : 55555,
	"nscannedObjects" : 55555,
	"nscanned" : 55555,
	"nscannedObjectsAllPlans" : 55555,
	"nscannedAllPlans" : 55555,
	"scanAndOrder" : false,
	"indexOnly" : false,
	"nYields" : 0,
	"nChunkSkips" : 0,
	"millis" : 112,
	"indexBounds" : {
		"type" : [
			[
				1,
				1
			]
		],
		"sex" : [
			[
				0,
				0
			]
		]
	},
	"server" : "node1:27017"
}

    很显然，绝对是一个最佳索引，因为n=nscannedObjects=nscanned了，而且查询时间从529毫秒下降到112毫秒了，这也是一个质的飞跃，可以明显的看到，它使用了刚刚创建的index_ts索引。

    现在我又有一个需求了，我想通过时间再来排序，好的，我们执行查询语句： db.test.find({type:1,sex:0}).sort({time:-1})    我们来看看这个查询语句的执行计划：

    

{
	"cursor" : "BtreeCursor index_ts",
	"isMultiKey" : false,
	"n" : 55555,
	"nscannedObjects" : 1000000,
	"nscanned" : 1000000,
	"nscannedObjectsAllPlans" : 1000000,
	"nscannedAllPlans" : 1000000,
	"scanAndOrder" : true,
	"indexOnly" : false,
	"nYields" : 1,
	"nChunkSkips" : 0,
	"millis" : 695,
	"indexBounds" : {
		"type" : [
			[
				1,
				1
			]
		],
		"sex" : [
			[
				0,
				0
			]
		]
	},
	"server" : "node1:27017"
}

    看到没，这个查询语句跟上一个创建索引之后的查询出来的结果相差还是很大的，scanAndOrder和millis,时间花费了将近700毫秒，而且在查询完毕之后还要排序，这也太不近人情了，就加了一个排序操作，怎么会让它从白天鹅变成丑小鸭了呢？啊，关键参数就是scanAndOrder，意思就是在内存中把结果排序了嘛，那好啊，既然你如此薄情，那我就建个复合索引来对抗:   db.test.ensureIndex({type:1,sex:1,time:-1},{name:'index_tst'})

    

{
	"cursor" : "BtreeCursor index_tst",
	"isMultiKey" : false,
	"n" : 55555,
	"nscannedObjects" : 55555,
	"nscanned" : 55555,
	"nscannedObjectsAllPlans" : 55555,
	"nscannedAllPlans" : 55555,
	"scanAndOrder" : false,
	"indexOnly" : false,
	"nYields" : 0,
	"nChunkSkips" : 0,
	"millis" : 126,
	"indexBounds" : {
		"type" : [
			[
				1,
				1
			]
		],
		"sex" : [
			[
				0,
				0
			]
		],
		"time" : [
			[
				{
					"$maxElement" : 1
				},
				{
					"$minElement" : 1
				}
			]
		]
	},
	"server" : "node1:27017"
}

    看到了吗？各种参数又回到最佳状态了。这时候可能有人会问了，为什么要把time放到索引的最后而不是其它位置呢？其实这在创建索引时是有要求的，即：

  1.  将等值索引放在最前面

  2. 尽量将排序字段放在范围字段的后面

  3. $nin和$ne跟索引没有关系

   接下来我们再给查询语句加条件： db.test.find({type:1,sex:0,id:{$gt:1,$lt:500000}}) 执行计划如下:

    

{
	"cursor" : "BasicCursor",
	"isMultiKey" : false,
	"n" : 55555,
	"nscannedObjects" : 1000000,
	"nscanned" : 1000000,
	"nscannedObjectsAllPlans" : 1000000,
	"nscannedAllPlans" : 1000000,
	"scanAndOrder" : false,
	"indexOnly" : false,
	"nYields" : 2,
	"nChunkSkips" : 0,
	"millis" : 553,
	"indexBounds" : {
		
	},
	"server" : "node1:27017"
}

    可以看到，只返回两万多条数据，但是却扫描了整个表，这肯定是很蛋疼的事情嘛，索引走起：

    db.test.ensureIndex({type:1,sex:1,id:1},{name:'index_tis'})

     

{
	"cursor" : "BtreeCursor index_tis",
	"isMultiKey" : false,
	"n" : 55555,
	"nscannedObjects" : 55555,
	"nscanned" : 55555,
	"nscannedObjectsAllPlans" : 55555,
	"nscannedAllPlans" : 55555,
	"scanAndOrder" : false,
	"indexOnly" : false,
	"nYields" : 1,
	"nChunkSkips" : 0,
	"millis" : 137,
	"indexBounds" : {
		"type" : [
			[
				1,
				1
			]
		],
		"sex" : [
			[
				0,
				0
			]
		],
		"id" : [
			[
				1,
				1000000
			]
		]
	},
	"server" : "node1:27017"
}

    很显然，这是个非常不错的组合索引，那为何不把id放在其它地方，偏偏放在最后面呢？因为在mongodb中，索引是从左到右执行的，因此显然要从左到右一次过滤最大数量的数据显然type和sex的组合过滤数据量要比id高更多，因为id的忙查率要远高于这两个组合。

    接着再把按time排序加上，查询：db.test.find({type:1,sex:1,id:{$gt:0,$lt:1000000}}).sort({time:-1}).explain()    

    

{
	"cursor" : "BasicCursor",
	"isMultiKey" : false,
	"n" : 55556,
	"nscannedObjects" : 1000000,
	"nscanned" : 1000000,
	"nscannedObjectsAllPlans" : 1000000,
	"nscannedAllPlans" : 1000000,
	"scanAndOrder" : true,
	"indexOnly" : false,
	"nYields" : 1,
	"nChunkSkips" : 0,
	"millis" : 725,
	"indexBounds" : {
		
	},
	"server" : "node1:27017"
}

    可以看到，这个查询语句也是极其慢的，而且还要再内存中排序，所以肯定要创建索引了：

    db.test.ensureIndex({type:1,sex:1,id:1,time:-1},{name:'index_tist'}) 我们先这样创建索引，看看执行计划：

    

{
	"cursor" : "BtreeCursor index_tist",
	"isMultiKey" : false,
	"n" : 55556,
	"nscannedObjects" : 55556,
	"nscanned" : 55556,
	"nscannedObjectsAllPlans" : 55657,
	"nscannedAllPlans" : 55657,
	"scanAndOrder" : true,
	"indexOnly" : false,
	"nYields" : 0,
	"nChunkSkips" : 0,
	"millis" : 404,
	"indexBounds" : {
		"type" : [
			[
				1,
				1
			]
		],
		"sex" : [
			[
				1,
				1
			]
		],
		"id" : [
			[
				0,
				1000000
			]
		],
		"time" : [
			[
				{
					"$maxElement" : 1
				},
				{
					"$minElement" : 1
				}
			]
		]
	},
	"server" : "node1:27017"
}

    看到了没有，虽然查询时间缩短了，但是这个查询结果还是会排序结果，好，我们再把索引改改：

    

    db.test.ensureIndex({type:1,sex:1,time:-1,id:1},{name:'index_tist'})

    

{
	"cursor" : "BtreeCursor index_tist",
	"isMultiKey" : false,
	"n" : 55556,
	"nscannedObjects" : 55556,
	"nscanned" : 55556,
	"nscannedObjectsAllPlans" : 55657,
	"nscannedAllPlans" : 55657,
	"scanAndOrder" : false,
	"indexOnly" : false,
	"nYields" : 0,
	"nChunkSkips" : 0,
	"millis" : 168,
	"indexBounds" : {
		"type" : [
			[
				1,
				1
			]
		],
		"sex" : [
			[
				1,
				1
			]
		],
		"time" : [
			[
				{
					"$maxElement" : 1
				},
				{
					"$minElement" : 1
				}
			]
		],
		"id" : [
			[
				0,
				1000000
			]
		]
	},
	"server" : "node1:27017"
}

    再来看看，快到什么程度了，这个查询的速度和参数条件已经比上一个索引的快了很多，那为什么会出现这种情况呢？为什么time在id的前后会有不同的表现？这是因为通过type和sex字段过滤完之后，已经在内存中有了数据，而这些数据下一步需要怎么办？是先通过id来筛选，还是按照排序筛选呢？这里有一个知识点，在把id放在time前面时，程序首先会取复合id值，然后再把复合的数据排序，但是如果id放在排序的后面，那么程序将直接通过顺序扫描索引树的方式取出复合id范围的数据。

四，总结

    1.mongodb创建索引难点在于排序和范围查询的字段位置选择

    2.mongodb的复合索引的索引截取查询是顺序的，即如果(a:1,b:1,c:1},则可以是查询{a:1},{a:1,b:1},{a:1,b:1,c:1}中得任何一种都会使用该索引，其它查询情况将不会用到该索引；

    3.尽量创建更少的索引以提高数据库性能

    4.以上的索引优化只是生产环境的一部分，具体情况可能还要看自己的业务来定

jiangfullll
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
mongodb如何建立索引
04-29
mongodb中如何建立高效索引，文档讲述的很清楚
MongoDB使用小结：一些不常见的经验分享
09-09
以上经验总结了MongoDB在实际操作中可能出现的问题及解决策略，涵盖了统计、数据恢复、索引管理以及数据迁移等多个方面。在使用MongoDB时，理解这些细节能帮助我们更有效地管理和优化数据库性能。随着MongoDB的不断...
MongoDB性能篇
weixin_33778778的博客
02-22 838
一、索引 MongoDB 提供了多样性的索引支持，索引信息被保存在system.indexes 中，且默认总是为_id创建索引，它的索引使用基本和MySQL 等关系型数据库一样。其实可以这样说说，索引是凌驾于数据存储系统之上的另一层系统，所以各种结构迥异的存储都有相同或相似的索引实现及使用接口并不足为奇。 1.基础索引 在字段age 上创建索引，1(升序);-1(降序)： db.use...
mongoDB教程（十三）：索引
大剑师兰特的GIS世界
06-30 961
MongoDB 中的索引是为了加速数据检索而设计的数据库结构。索引可以显著减少查找数据所需的时间，特别是在大型数据集中。理解索引的工作原理和如何有效地使用它们对于优化 MongoDB 性能至关重要。
四、mongodb创建索引
热门推荐
s_daqing的博客
03-28 1万+
1、mongodb创建简单的索引方法 db.集合.ensureIndex({字段名:1})，1表示升序， -1表示降序 db.集合.createIndex({字段名:1}) 上面两个命令效果等价 2、索引的查看 默认情况下_id是集合的索引 查看方式：db.集合.getIndexes() 默认只有_id的情况： [ { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id
MongoDB管理与开发精要《红丸出品》16 索引
红丸的专栏
06-22 403
第十六章 索引 MongoDB提供了多样性的索引支持，索引信息被保存在system.indexes中，且默认总是为_id创建索引，它的索引使用基本和MySQL等关系型数据库一样。其实可以这样说说，索引是凌驾于数据存储系统之上的另一层系统，所以各种结构迥异的存储都有相同或相似的索引实现及使用接口并不足为奇。 16.1 基础索引 在字段age上创建索引，1(升序);-1(降序)
MongoDB 如何创建索引
最新发布
My_wife_QBL的博客
07-20 635
索引是数据库中用于加速数据检索的重要工具。在 MongoDB 中，索引可以显著提高查询性能，减少数据检索的时间。本文将详细介绍如何在 MongoDB 中创建索引，包括单字段索引、复合索引、多键索引、文本索引和地理空间索引等。
MongoDB入门.pdf
11-15
- **创建数据库和集合**：通过`use`命令创建数据库，通过`db.createCollection()`方法创建集合。 - **插入文档**：使用`db.collectionName.insertOne()`或`db.collectionName.insertMany()`方法将文档插入集合。 - *...
【老版本】MongoDB+Linux+2.6.12
05-09
总结来说，MongoDB 2.6.12是MongoDB历史上的一个重要版本，它在Linux平台上提供了强大的数据存储和处理能力。虽然现在已有更新的版本，但理解这个老版本的功能和在Linux环境中的配置技巧，对于维护旧系统或学习...
MongoDB管理工具RockMongo-1.17源代码
03-20
总结来说，RockMongo是一款强大的MongoDB管理工具，它的存在极大地简化了数据库的管理工作，无论对于初学者还是经验丰富的开发者，都是一个不可或缺的辅助工具。通过源代码的学习，开发者可以深入理解MongoDB的交互...
mongodb安装(linux环境)
02-08
### MongoDB在Linux环境下的安装与初步使用 #### 实验环境 - **操作系统**: 虚拟Linux操作系统（桌面...随着实践经验的积累，还可以深入学习更多高级特性，如索引管理、复制集、分片等，以满足更复杂的应用场景需求。
mongodb pdf
03-23
根据提供的信息，我们可以总结出以下关于 MongoDB 的关键知识点： ### MongoDB 概览 - **官方文档**：用户提及“mongodb 官方文档”，这表明文档是 MongoDB 的权威指南，覆盖了从入门到进阶的各种主题。 - **学习...
MongoDB-3.0.4-manual
05-24
### MongoDB 3.0.4 手册知识点总结 #### 一、MongoDB简介 - **定义**：MongoDB 是一款高性能、无模式的文档型数据库。它支持动态查询，并且能够快速处理大规模数据集。 - **特点**： - **可扩展性**：能够轻松地...
MongoDB tools.rar
12-12
总结来说，“MongoDB tools.rar”提供的Robo 3T是MongoDB数据库管理的实用工具，通过其直观的界面和丰富的功能，无论是初学者还是经验丰富的开发人员，都能有效地进行数据操作和管理。在选择连接工具时，应根据具体...
php mongodb 5.2
06-15
PHP MongoDB 5.2不仅提供了基本的CRUD（创建、读取、更新、删除）操作，还支持复杂的查询语法、聚合框架、索引管理等高级功能。 首先，让我们看看如何安装和配置PHP MongoDB 5.2驱动。通常，你可以通过Composer，...
mongodb创建索引
nlrkbqndrhh的博客
11-06 491
索引的目的：提升查询速度 测试：插入10万条数据到数据库中 for(i=0;i<100000;i++){db.t255.insert({name:"test"+i,age:i})} 用db.t1.find({name:'test10000'}).explain('executionStats')来显示查询时间 建立索引之后对比： 语法：db.集合名称.ensure...
给mongodb创建索引
weixin_42046751的博客
10-30 885
直接上图（解释了创建成功后，返回的提示）：
MongoDB创建索引
09-07
在MongoDB中，你可以使用以下方式创建索引： 1. 单字段索引： ``` db.collection.createIndex({ field: 1 }) ``` 这将在指定的集合中创建按照 "field" 字段进行升序排序的索引。 2. 多字段索引： ``` db.collection.createIndex({ field1: 1, field2: -1 }) ``` 这将在指定的集合中创建一个复合索引，同时按照 "field1" 字段进行升序排序，并按照 "field2" 字段进行降序排序。 3. 文本索引： ``` db.collection.createIndex({ field: "text" }) ``` 这将在指定的集合中创建一个文本索引，用于全文搜索。 4. 唯一索引： ``` db.collection.createIndex({ field: 1 }, { unique: true }) ``` 这将在指定的集合中创建一个唯一索引，确保 "field" 字段的值是唯一的。 5. TTL（过期）索引： ``` db.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 }) ``` 这将在指定的集合中创建一个TTL索引，用于自动删除 "createdAt" 字段值超过指定时间的文档。 请根据你需要的索引类型选择相应的方法，并替换掉 "collection" 和 "field" 为你的集合和字段名称。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值