【MongoDB】索引的使用

最新推荐文章于 2024-07-24 21:02:40 发布
最新推荐文章于 2024-07-24 21:02:40 发布
阅读量96 收藏
点赞数 1
分类专栏： 数据库运维-MongoDB 文章标签： mongodb 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43346403/article/details/139544314
版权

1.单键值索引 

单键索引。
name字段上创建一个索引。
sql>db.testindx.ensureIndex({"Name":1})
{
	"createdCollectionAutomatically" : false,
	"numIndexesBefore" : 1,
	"numIndexesAfter" : 2,
	"ok" : 1
}

--创建索引并查看执行计划。
db.testindx.ensureIndex({"Name":1})
{
	"createdCollectionAutomatically" : false,
	"numIndexesBefore" : 1,
	"numIndexesAfter" : 2,
	"ok" : 1
}
> db.testindx.find({"Name":"user9"}).explain("allPlansExecution")
{
	"queryPlanner" : {
		"plannerVersion" : 1,
		"namespace" : "myprocdb.testindx",
		"indexFilterSet" : false,
		"parsedQuery" : {
			"Name" : {
				"$eq" : "user9"
			}
		},
		"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" : [
						"[\"user9\", \"user9\"]"
					]
				}
			}
		},
		"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" : {
					"Name" : 1
				},
				"indexName" : "Name_1",
				"isMultiKey" : false,
				"multiKeyPaths" : {
					"Name" : [ ]
				},
				"isUnique" : false,
				"isSparse" : false,
				"isPartial" : false,
				"indexVersion" : 2,
				"direction" : "forward",
				"indexBounds" : {
					"Name" : [
						"[\"user9\", \"user9\"]"
					]
				},
				"keysExamined" : 1,
				"seeks" : 1,
				"dupsTested" : 0,
				"dupsDropped" : 0,
				"seenInvalidated" : 0
			}
		},
		"allPlansExecution" : [ ]
	},
	"serverInfo" : {
		"host" : "itpuxdb1",
		"port" : 27017,
		"version" : "4.0.2",
		"gitVersion" : "fc1573ba18aee42f97a3bb13b67af7d837826b47"
	},
	"ok" : 1
}


--"indexName" : "Name_1"
--"totalDocsExamined" : 1
可以看到使用了索引。

2.复合索引

2.复合索引。
创建一个索引时，应该牢记，索引要覆盖大多数查询。
sql>db.testindx.ensureIdex({"Name":1,"Age":1})  --创建名字和年龄复合索引。
{
	"createdCollectionAutomatically" : false,
	"numIndexesBefore" : 2,
	"numIndexesAfter" : 3,
	"ok" : 1
}
创建复合索引时，第一个字段需要精确匹配，其后的是要用在范围中的字段。
sql>db.testindx.find({"Name":"user5","Age":{"$gt":25}}).explain("allPlansExecution")
> db.testindx.find({"Name":"user5","Age":{"$gt":25}}).explain("allPlansExecution")
{
	"queryPlanner" : {
		"plannerVersion" : 1,
		"namespace" : "myprocdb.testindx",
		"indexFilterSet" : false,
		"parsedQuery" : {
			"$and" : [
				{
					"Name" : {
						"$eq" : "user5"
					}
				},
				{
					"Age" : {
						"$gt" : 25
					}
				}
			]
		},
		"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" : [
						"[\"user5\", \"user5\"]"
					],
					"Age" : [
						"(25.0, inf.0]"
					]
				}
			}
		},
		"rejectedPlans" : [
			{
				"stage" : "FETCH",
				"filter" : {
					"Age" : {
						"$gt" : 25
					}
				},
				"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" : [
							"[\"user5\", \"user5\"]"
						]
					}
				}
			}
		]
	},
	"executionStats" : {
		"executionSuccess" : true,
		"nReturned" : 1,
		"executionTimeMillis" : 0,
		"totalKeysExamined" : 1,
		"totalDocsExamined" : 1,
		"executionStages" : {
			"stage" : "FETCH",
			"nReturned" : 1,
			"executionTimeMillisEstimate" : 0,
			"works" : 3,
			"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" : {
					"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" : [
						"[\"user5\", \"user5\"]"
					],
					"Age" : [
						"(25.0, inf.0]"
					]
				},
				"keysExamined" : 1,
				"seeks" : 1,
				"dupsTested" : 0,
				"dupsDropped" : 0,
				"seenInvalidated" : 0
			}
		},
		"allPlansExecution" : [
			{
				"nReturned" : 1,
				"executionTimeMillisEstimate" : 0,
				"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" : {
							"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" : [
								"[\"user5\", \"user5\"]"
							],
							"Age" : [
								"(25.0, inf.0]"
							]
						},
						"keysExamined" : 1,
						"seeks" : 1,
						"dupsTested" : 0,
						"dupsDropped" : 0,
						"seenInvalidated" : 0
					}
				}
			},
			{
				"nReturned" : 1,
				"executionTimeMillisEstimate" : 0,
				"totalKeysExamined" : 1,
				"totalDocsExamined" : 1,
				"executionStages" : {
					"stage" : "FETCH",
					"filter" : {
						"Age" : {
							"$gt" : 25
						}
					},
					"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" : {
							"Name" : 1
						},
						"indexName" : "Name_1",
						"isMultiKey" : false,
						"multiKeyPaths" : {
							"Name" : [ ]
						},
						"isUnique" : false,
						"isSparse" : false,
						"isPartial" : false,
						"indexVersion" : 2,
						"direction" : "forward",
						"indexBounds" : {
							"Name" : [
								"[\"user5\", \"user5\"]"
							]
						},
						"keysExamined" : 1,
						"seeks" : 1,
						"dupsTested" : 0,
						"dupsDropped" : 0,
						"seenInvalidated" : 0
					}
				}
			}
		]
	},
	"serverInfo" : {
		"host" : "itpuxdb1",
		"port" : 27017,
		"version" : "4.0.2",
		"gitVersion" : "fc1573ba18aee42f97a3bb13b67af7d837826b47"
	},
	"ok" : 1
}

3.mongodb的排序操作

3.对sort()操作的支持。
在mongodb中使用一个索引字段来对文档排序的sort操作会提供最佳的性能。
如果一个索引被用于访问文档，那么他将按照与索引相同的顺序返回结果。
复合索引输出结果可以按照索引前缀的顺序或者完整索引的顺序来排序。
前缀索引时复合索引的一个子集，它包含开头部分的一个或多个字段。

sql>db.testindx.ensureIndex({"Age":1,"Name":1,"Class":1}) 
sql>db.testindx.find().sort({"Age":1}) --按年龄排序。
sql>db.testindx.find().sort({"Age":1,"Name":1})
sql>db.testindx.find().sort({"Age":1,"Name":1,"Class":1})

上面的索引在以下查询中没有用处，就第一个排序字段必须是符合索引的第一个前缀。
sql>db.testindx.find().sort({"Gender":1,"Age":1,"Name":1})

4.唯一索引 

唯一索引。
如果唯一性是需要被启用的其中一个约束，那么在创建该索引时，这个唯一属性就需要被设置为true;

sql>db.testindx.dropIndexes()   --删除已有的索引。
sql>db.testindx.ensureIndex({"Name":1},{"unique":true}) --创建唯一索引。
sql>db.testindx.insert({"Name":"uniquename"})
WriteResult({ "nInserted" : 1 })
sql> db.testindx.insert({"Name":"uniquename"})  --重复插入就会报错。
WriteResult({
	"nInserted" : 0,
	"writeError" : {
		"code" : 11000,
		"errmsg" : "E11000 duplicate key error collection: myprocdb.testindx index: Name_1 dup key: { : \"uniquename\" }"
	}
})

sql>db.testindx.find({"Name":"uniquename"})
{ "_id" : ObjectId("4cabde1e6933f3a279550a90"), "Name" : "uniquename" }  --只有一个文档。


也可以为复合索引启用唯一性。
sql>db.testindx.ensureIndex({"Name":1,"Age":1},{"unique":true})
sql>db.testindx.insert({"Name":"usercit"})
WriteResult({ "nInserted" : 1 })
> db.testindx.insert({"Name":"usercit","Age":30})
WriteResult({ "nInserted" : 1 })

可以在先创建集合并且插入数据，然后在该集合上创建一个索引。如果在该集合上创建一个
唯一索引，而创建索引的字段可能存在重复值的话，那么索引的创建将会失败。
为满足这一场景，mongodb提供dropDups选享。它会保留找到的文档，并删除后面重复的文档。
sql>db.testindx.ensureIndex({"Name":1},{"unique":true,"dropDups":true}) 
 db.testindx.ensureIndex({"Name":1},{"unique":true,"dropDups":true})
{
	"ok" : 0,
	"errmsg" : "E11000 duplicate key error collection: myprocdb.testindx index: Name_1 dup key: { : \"usercit\" }",
	"code" : 11000,
	"codeName" : "DuplicateKey"
}
> 
> 
> db.version()
4.0.2
--我的当前环境是mongodb4.0.2;dropDups属性居然一直报错。

5.索引的其他维护操作 

5.system.indexes 
无论何时创建一个数据库，默认情况下都会创建一个system.indexes集合。关于数据库索引的信息
都存储在system.indexes集合中。这是一个保留集合，无法修改或删除。只能通过ensureIndex
和dropIndexes数据库命令来操作它。

sql>db.myprocdb.getIndexes()     --查看集合上所有的索引。
[
	{
		"v" : 2,
		"key" : {
			"_id" : 1
		},
		"name" : "_id_",
		"ns" : "myprocdb.testindx"
	}
]

6.dropIndex --删除索引。
sql>db.testindx.dropIndex({"Name":1})   --删除Name列的索引。
{ "nIndexesWas" : 2, "ok" : 1 }

7.reIndex  --重构索引。
它会重构一个集合上的所有索引，它会首先删除索引，其中包括_id字段上的默认索引。然后重构
这些索引。
sql>db.testindx.reIndex();
{
	"nIndexesWas" : 1,
	"nIndexes" : 1,
	"indexes" : [
		{
			"v" : 2,
			"key" : {
				"_id" : 1
			},
			"name" : "_id_",
			"ns" : "myprocdb.testindx"
		}
	],
	"ok" : 1
}

6.索引如何工作总结 

8.索引如何工作。
mongodb会在一个二叉树结构中存储索引，因此它自动支持范围查询。
如果一个查询中使用了多个选择条件，那么mongodb会尝试找到最佳的单个索引来选择一个候选集。
在那之后，它会遍历集合来估算其他条件。
在首次执行查询时，mongodb会为每一个可用于该查询的索引创建多个执行计划。他会让这些执行计划
在一定时间间隔中轮流执行，直到执行最快的计划完成。然后其结果会被返回到系统。该结果
会记住最快执行计划使用的索引。
对于后续查询，将会使用此被记住的索引，直到该集合发生了一定数量的更新。
在超过更新限制时，系统将再次执行该处理过程以找出此时适用的最佳索引。
发生以下事件重新评估索引：
集合接收到1000个写操作。
添加或删除了一个索引。
mongod程序重启了
发生了用于重构索引的再次索引。

版本2.6之前，mongodb都仅使用一个索引。为更好匹配查询，可以创建组合索引。
版本2.6之后，引入索引交集。他使得用于满足具有复合条件的查询的索引交集成为可能。
其中一部分条件由一个索引满足，其他部分则由其他索引满足。
一般，索引交集是由两个索引组成。可以将多个索引用于解决一个查询。
为了维持一个最佳平衡，需要定期检查使用一个索引的有效性。这可以通过你在系统上执行、
的读和写的比例来平衡。识别出较少使用的索引并且删除它们。

戒掉贪嗔痴(薛双奇)
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mongodb索引使用
congge
10-27 2万+
索引简介 在MongoDB建立索引能提高查询效率，只需要扫描索引只存储的这个集合的一小部分，并只把这小部分加载到内存中，效率大大的提高，如果没有建立索引，在查询时，MongoDB必须执行全表扫描，在数据量大时，效率差别就很明显，对于包括一个没有索引的排序操作的查询，服务器必须在返回任何结果之前将所有的文档加载到内存中来进行排序。 索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是...
MongoDB索引详解
持续学习，坚持原创，分享技术笔记及经验。
01-06 1644
MongoDB索引详解
MongoDB学习笔记之索引（一）
yaya_jn的博客
04-25 7959
MongoDB索引 索引是一种用来快速查询数据的数据结构。B+Tree就是一种常见的数据库索引数据结构，MongoDB采用B+Tree做索引，索引创建在collections上。MongoDB不使用索引的查询，先扫描所有的文档，再匹配符合条件的文档。使用索引的查询，通过索引找到文档，使用索引能够极大的提升查询效率。 一、MongoDB索引数据结构 索引数据结构介绍及官方文档 MongoDB索引数据结构具体使用的是B+Tree，因为B+Tree是B-Tree的子集，所以叫B-Tree也对，但是容易混淆
学习MongoDB--（5-2）：索引（查看索引的使用，管理索引）
热门推荐
DrifterJ's Stash
08-11 3万+
前一篇简单介绍了索引，并给出了基本的索引使用，这一次，我们进一步说一下MongoDB中的索引，包括如何查看查询是否走索引，如何管理索引和地理空间索引等。 【使用explain和hint】 前面讲高级查询选项时，提到过"$explain" 和 ”$hint“可以作为包装查询的选项关键字使用，其实这两个本身就可以作为操作游标的函数调用！游标调用explain函数会返回一个文档，用于描述当前查询的一
Mongodb基础入门（3）——排序和索引
Floating Cat
01-03 7967
今天继续Mongodb，简单的记录下其排序和索引的使用。 在Mongodb中使用sort（）方法对数据进行排序。 命令格式：db.collectionName.find().sort({key:参数}) 参数说明:               -1:表示降序               1:表示升序（默认） doc集合中数据如下： > db.doc.find({},{_id:0,
Mongodb索引使用限制
威赞的专栏
07-05 827
学习mongodb，体会mongodb的每一个使用细节，欢迎阅读威赞的文章。这是威赞发布的第85篇mongodb技术文章，欢迎浏览本专栏威赞发布的其他文章。通过在Mongodb添加索引，能够提高Mongodb查询效率。但在索引在使用当中也会有一些限制。本文结合官方文档，介绍Mongodb索引使用上的一些限制。
MongoDB索引使用详解
12-16
MongoDB索引是数据库性能优化的关键工具，它们类似于书籍的目录，可以帮助快速定位到所需的数据，从而大大提高查询效率。在没有索引的情况下，MongoDB必须遍历整个集合来找到匹配的文档，这在数据量大的时候会导致...
MongoDB索引实战技巧
01-31
主要描述了MongoDB索引相关的一些基础知识和使用技巧。 虽然MongoDB的索引在存储结构上都是一样的，但是根据不同的应用层需求，还是分成了唯一索引（unique）、稀疏索引（sparse）、多值索引（multikey）等几种类型...
MongoDB 覆盖索引查询
12-16
这样，当执行以下查询时，MongoDB可以使用覆盖索引： ```shell db.users.find({gender: "M"}, {user_name: 1, _id: 0}) ``` 在这个例子中，我们明确指定了返回`user_name`字段，并排除了`_id`字段。因为`_id`默认...
SpringBoot MongoDB 索引冲突分析及解决方法
08-26
1. 删除已经存在的索引：可以使用 MongoDB 的命令来删除已经存在的索引，例如，使用 db.collection.dropIndex() 命令来删除索引。 2. 重新创建索引：可以使用 MongoDB 的命令来创建新的索引，例如，使用 db....
MongoDB——索引的使用建议
小志的博客
05-05 1407
一、索引的使用建议 为每一个查询建立合适的索引 这个是针对于数据量较大比如说超过几十上百万（文档数目）数量级的集合。如果没有索引MongoDB需要把所有的Document从盘上读到内存，这会对MongoDB服务器造成较大的压力并影响到其他请求的执行。 创建合适的复合索引，不要依赖于交叉索引 如果你的查询会使用到多个字段，MongoDB有两个索引技术可以使用：交叉索引和复合索引。交叉索引就是针对每个字段单独建立一个单字段索引，然后在查询执行时候使用相应的单字段索引进行索引交叉而得到查询结果。交叉索引目
MongoDB 索引的使用
华仔仔的博客
06-13 1048
索引支持在 MongoDB 中高效地执行查询，避免 MongoDB 执行全集合扫描来选择与查询语句匹配的文档，这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询要花费几十秒甚至几分钟，严重影响网站的整体性能。如果查询存在适当的索引，MongoDB 可以使用该索引限制必须检查的文档数。索引是特殊的数据结构，以易于遍历的形式存储集合数据集的一小部分，索引存储特定字段或一组字段的值，按字段值排序，索引项的排序支持有效的相等匹配和基于范围的查询操作，MongoDB 可以使用索引中的排序返回排序结果，M
mongodb 的查询如何使用索引
weixin_34049948的博客
04-10 1306
2019独角兽企业重金招聘Python工程师标准>>> ...
MongoDB索引与索引管理详解
老虎帅呆了的博客
01-02 2274
今天又补充了一些关于查询的内容在昨天的博客里：$elemMatch 根据数组对象中的条件进行查询 和 分页与排序  相关的内容，大家可以去看一下。今天主要说MongoDB中索引相关的内容： 一、先来看一下数据量较大的情况下查询的效率是怎么样的： 创建100000条数据，大约10秒钟就能完成： 接下来我们看一下建立索引和不建索引的情况下查询效率能差多少，我们来查看number是87
windows下实现mongodb备份还原
最新发布
07-24 484
把以下脚本保存为.bat格式的文件，双击运行bat，在备份路径下创建当天日期yyyyMMdd格式的文件夹保存mongodb数据库备份文件，并清除7天前的数据库备份文件。::删除7天前的备份文件。-d 需要备份的库名称。--gzip 启用压缩。
13.2 MongoDB
与海
07-24 177
-authMongoDB配置账号测试账号。
MongoDB教程（二十一）：MongoDB大文件存储GridFS
菜鸟小码的博客
07-24 963
在处理多媒体文件、文档或其他大型二进制数据时，传统的文件存储方式往往难以满足高并发、可扩展和易管理的需求。MongoDB 通过 GridFS 模块提供了一套完整的解决方案，用于存储和检索大型文件。本文将深入探讨 GridFS 的工作原理，以及如何在 MongoDB 中使用 GridFS 存储和检索文件。
MongoDB教程（二十二）：MongoDB固定集合
菜鸟小码的博客
07-24 791
在MongoDB中，固定集合（Capped Collections）是一种特殊类型的集合，它提供了预分配的空间和固定大小的特性，旨在优化插入性能和存储管理。固定集合适用于日志记录、消息队列和其他需要快速插入和有限历史数据保留的场景。本文将深入探讨固定集合的创建、使用和维护，通过具体的案例代码展示如何在MongoDB中有效利用固定集合。
mongodb 索引
10-19
MongoDB索引是一种用于快速查询数据的数据结构，它采用B+Tree做索引，索引创建在collections上。使用索引的查询，通过索引找到文档，能够极大地提升查询效率。MongoDB支持单键索引、复合索引、全文索引、地理空间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值