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

想来接触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.以上的索引优化只是生产环境的一部分，具体情况可能还要看自己的业务来定

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

时间： 2024-10-10 20:54:21

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

MongoDB创建索引

1,查询索引 2,创建索引 来自为知笔记(Wiz)

Mongodb 创建索引

db.getCollection('ct_project').ensureIndex({'pro_code':1})  创建索引 db.getCollection('ct_project').ensureIndex({'pro_code':1,'unique':true}) 创建唯一索引 db.getCollection('ct_project').getIndexes(); 查询索引 db.getCollection('ct_project).dropIndex({"username"

MongoDB 创建索引及其他

索引 以提升查询速度 测试:插入十万条数据到数据库中 for(i=0;i<100000;i++){db.t255.insert({name:'test'+i,age:i})} db.t1.find({name:'test100000'}) db.t1.find({name:'test100000'}).explain('executionStats') 可以查看查询的时间 建立索引之后对比: 语法:db.集合.ensureIndex({属性:1}),1表示升序,-1表示降序 具体操作: db.集

Mongodb的索引

1. 简单介绍 索引是为了加速查询. 假设没有索引,mongodb在查询时会做表扫描,假设集合非常大时,这个查询会非常慢. 一般对创建查询时的键都建立索引. 为排序字段建立索引,假设对未建立索引的字段sort,mongodb会将全部的数据取到内存中来排序, 假设集合大到不能在内存中排序,则mongodb会报错. 2. mongodb创建索引 创建索引使用ensureIndex命令. > db.people.ensureIndex({"username" : 1}); 上面语句对p

MongoDB中索引的创建和使用详解

索引通常能够极大的提高查询的效率.在系统中使用查询时,应该考虑建立相关的索引.在MongoDB中创建索引相对比较容易. mongodb中的索引在概念上和大多数关系型数据库如MySQL是一样的.当你在某种情况下需要在MySQL中建立索引,这样的情景同样适合于MongoDB. 基本操作 索引是一种数据结构,他搜集一个集合中文档特定字段的值.MongoDB的查询优化器能够使用这种数据结构来快速的对集合(collection)中的文档(collection)进行寻找和排序.准确来说,这些索引是通过B-T

mongodb 创建LBS位置索引

<dependency> <groupId>org.mongodb</groupId> <artifactId>mongo-java-driver</artifactId> <version>3.2.2</version> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifact

MongoDB索引管理——创建索引，查看索引，删除索引，重建索引

先给users集合插入两条记录,然后用users集合来进行索引管理的演示: > user1={"name":"liming","age":20,"gender":"F"} { "name" : "liming", "age" : 20, "gender" : "F" } > db.users.in

mongodb的基本操作之数据创建索引

在数据量较少时,不使用索引,查询是很快的,但是在数据量较大时,查询将会变得非常缓慢,在mongodb中 查看索引 > db.test_collection.getIndexes() [ { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "config.test_collection" } ] 得到

MongoDB 创建基础索引、组合索引、唯一索引以及优化

一.索引 MongoDB 提供了多样性的索引支持,索引信息被保存在system.indexes 中,且默认总是为_id创建索引,它的索引使用基本和MySQL 等关系型数据库一样.其实可以这样说说,索引是凌驾于数据存储系统之上的另一层系统,所以各种结构迥异的存储都有相同或相似的索引实现及使用接口并不足为 奇. 1.基础索引 在字段age 上创建索引,1(升序);-1(降序): db.users.ensureIndex({age:1})1_id 是创建表的时候自动创建的索引,此索引是不能够删除的.当