MongoDB Shell基本操作（三） - 索引

最新推荐文章于 2025-05-06 09:58:21 发布
原创 最新推荐文章于 2025-05-06 09:58:21 发布 · 817 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#索引 #MongoDB

本文详细介绍了MongoDB中不同类型的索引，包括单键索引、复合索引、唯一索引等，并展示了如何通过实际的例子创建和使用这些索引，同时讨论了索引的维护和优化策略。

索引被用于为频繁使用的查询提供高性能读取操作；

默认情况下，当一个集合被创建并且文档被添加到其中时，会在_id字段上创建一个索引；

使用for循环在testindx的新集合中插入100W个文档：

> for(i = 0; i < 1000000; i++) { db.testindx.insert({"Name":"user"+i,"Age":Math.floor(Math.random()*120)})}
WriteResult({ "nInserted" : 1 })

查询Name值为user101的文档：

> db.testindx.find({"Name":"user101"}).explain("allPlansExecution")
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "mydb.testindx",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "Name" : {
                                "$eq" : "user101"
                        }
                },
                "winningPlan" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "Name" : {
                                        "$eq" : "user101"
                                }
                        },
                        "direction" : "forward"
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 1,
                "executionTimeMillis" : 232,
                "totalKeysExamined" : 0,
                "totalDocsExamined" : 1000000,
                "executionStages" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "Name" : {
                                        "$eq" : "user101"
                                }
                        },
                        "nReturned" : 1,
                        "executionTimeMillisEstimate" : 216,
                        "works" : 1000002,
                        "advanced" : 1,
                        "needTime" : 1000000,
                        "needYield" : 0,
                        "saveState" : 7817,
                        "restoreState" : 7817,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "direction" : "forward",
                        "docsExamined" : 1000000
                },
                "allPlansExecution" : [ ]
        },
        "serverInfo" : {
                "host" : "localhost.localdomain",
                "port" : 27017,
                "version" : "3.4.10",
                "gitVersion" : "078f28920cb24de0dd479b5ea6c66c644f6326e9"
        },
        "ok" : 1
}

1、单键索引

> db.testindx.ensureIndex({"Name":1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
> db.testindx.find({"Name":"user101"}).explain("allPlansExecution")
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "mydb.testindx",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "Name" : {
                                "$eq" : "user101"
                        }
                },
                "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" : [
                                                "[\"user101\", \"user101\"]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 1,
                "executionTimeMillis" : 223,
                "totalKeysExamined" : 1,
                "totalDocsExamined" : 1,
                "executionStages" : {
                        "stage" : "FETCH",
                        "nReturned" : 1,
                        "executionTimeMillisEstimate" : 136,
                        "works" : 2,
                        "advanced" : 1,
                        "needTime" : 0,
                        "needYield" : 0,
                        "saveState" : 1,
                        "restoreState" : 1,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "docsExamined" : 1,
                        "alreadyHasObj" : 0,
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "nReturned" : 1,
                                "executionTimeMillisEstimate" : 136,
                                "works" : 2,
                                "advanced" : 1,
                                "needTime" : 0,
                                "needYield" : 0,
                                "saveState" : 1,
                                "restoreState" : 1,
                                "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" : [
                                                "[\"user101\", \"user101\"]"
                                        ]
                                },
                                "keysExamined" : 1,
                                "seeks" : 1,
                                "dupsTested" : 0,
                                "dupsDropped" : 0,
                                "seenInvalidated" : 0
                        }
                },
                "allPlansExecution" : [ ]
        },
        "serverInfo" : {
                "host" : "localhost.localdomain",
                "port" : 27017,
                "version" : "3.4.10",
                "gitVersion" : "078f28920cb24de0dd479b5ea6c66c644f6326e9"
        },
        "ok" : 1
}

2、复合索引

复合索引更有效的执行带有多个子句的查询；

注意：创建复合索引时，牢记字段将被用于第一个出现的精确匹配，其后是要用在范围中的字段；

> db.testindx.ensureIndex({"Name":1, "Age":1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 2,
        "numIndexesAfter" : 3,
        "ok" : 1
}
> db.testindx.find({"Name":"user5", "Age":{"$gt":25}}).explain("allPlansExecution")
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "mydb.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",
                                        "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
                                        }
                                }
                        },
                        {
                                "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
                                        }
                                }
                        }
                ]
        },
        "serverInfo" : {
                "host" : "localhost.localdomain",
                "port" : 27017,
                "version" : "3.4.10",
                "gitVersion" : "078f28920cb24de0dd479b5ea6c66c644f6326e9"
        },
        "ok" : 1
}

3、唯一索引

删除已有的索引：

> db.testindx.dropIndexes()
{
        "nIndexesWas" : 3,
        "msg" : "non-_id indexes dropped for collection",
        "ok" : 1
}

在Name字段上创建一个唯一索引：

> db.testindx.ensureIndex({"Name":1},{"unique":true})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}

Name字段不允许插入重复记录，并且只保存第一条记录：

> db.testindx.insert({"Name":"uniquename"})
WriteResult({ "nInserted" : 1 })
> db.testindx.insert({"Name":"uniquename"})
WriteResult({
        "nInserted" : 0,
        "writeError" : {
                "code" : 11000,
                "errmsg" : "E11000 duplicate key error collection: mydb.testindx index: Name_1 dup key: { : \"uniquename\" }"
        }
})
> db.testindx.find({"Name":"uniquename"})
{ "_id" : ObjectId("5afbfb168dda484c0dacf0bf"), "Name" : "uniquename" }

也可以为复合索引启用唯一性，意味着尽管单个字段可以重复，但是其组合将是唯一的；

如果先创建集合并且插入文档，然后在该集合上创建一个唯一索引，此时如果该集合的唯一索引字段存在重复值的话，索引的创建就会失败；为了满足这一场景，可以使用dropDups选项；

以下命令在Name字段上创建一个唯一索引，并且将删除所有重复的文档：

db.testindx.ensureIndex({"Name":1},{"unique":true, "dropDups":true})

4、查询、移除、重构索引

查询testindx集合上的所有索引：

> db.testindx.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "mydb.testindx"
        },
        {
                "v" : 2,
                "unique" : true,
                "key" : {
                        "Name" : 1
                },
                "name" : "Name_1",
                "ns" : "mydb.testindx"
        }
]

移除Name字段索引：

> db.testindx.dropIndex({"Name":1})
{ "nIndexesWas" : 2, "ok" : 1 }

重构testindx集合的索引，重构索引会先删除索引，包括_id字段上的默认索引，然后重构：

> db.testindx.reIndex()
{
        "nIndexesWas" : 1,
        "nIndexes" : 1,
        "indexes" : [
                {
                        "v" : 2,
                        "key" : {
                                "_id" : 1
                        },
                        "name" : "_id_",
                        "ns" : "mydb.testindx"
                }
        ],
        "ok" : 1
}

索引的维护伴随着附加成本，所以需要定期检查使用一个索引的有效性，根据在系统上执行的读和写的比例来衡量，识别出较少使用的索引并且删除它们；


【MongoDB】--MongoDB的组合索引
寻梦友的博客
04-23 900
本文章主要介绍Mongodb的组合索引的使用。
MongoDB基础+shell操作+增删改查+索引+聚合...
船停在港湾是很安全的,但那不是造船的目的.
09-30 450
一 基础了解 对应关系 -> https://docs.mongodb.com/manual/reference/sql-comparison/ database -> database collection -> table document -> row //无模式 field -> column ---------------------------------...
执行shell 文件为mongodb建立索引
rjgcx2的专栏
11-21 2488
1.mongodb建立索引的命令为db.collections.ensureIndex({xx:1})  我们为表user建立字段为age的索引 db.user.ensureIndex({age:1}) 1 这里代表升序，-1代表降序 2.1个表1个索引，我们可以通过手动输入，如果在服务器上有多张表，多个索引，这种在终端敲的方法肯定不行，因为容易出错，检查出错会浪费很多的时间，因此通过执行s
mongodb搭建，shell操作，索引，副本集
01-07
该文档适用于运维，dba，非开发代码，下再留意目录。
Mongo Shell 文档搜索
qq_39045558的博客
05-13 431
Mongo Shell 文档搜索
MongoDB基础应用
SimpleWu
11-24 179
Author:SimpleWu 聚合 聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。 //统计员工总数 db.emp.aggregate([{$count:"countName"}]) //或者 db.emp.find().count() $group 使用$group是对筛选的数据进行分组。类...
linux 下脚本执行mongodb创建索引
IT_guoguo的博客
02-17 942
linux 下脚本执行mongodb创建索引一、编写mongodb创建索引文件二、找到mongodb mongo文件位置三、执行 一、编写mongodb创建索引文件 创建文件ensureIndex.js,文件名可自定义。 文件中加入创建索引语句，如图： 二、找到mongodb mongo文件位置 使用whereis mongo查询mongo文件所在位置 三、执行 直接执行： /usr/bin/mongo 127.0.0.1/mongo_db /www/wwwroot/testweb/ensur
MongoDB（mongodb-org-shell-5.0.4-1.el7.x86_64.rpm）
11-20
MongoDB Community Server（mongodb-org-shell-5.0.4-1.el7.x86_64.rpm）适用于RedHat / CentOS 7.0 MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。 ...
MongoDB（mongodb-shell-linux-x86_64-debian10-5.0.4.tgz）
11-20
MongoDB Community Server（mongodb-shell-linux-x86_64-debian10-5.0.4.tgz）适用于Debian10 MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。 ...
MongoDB（mongodb-shell-linux-x86_64-rhel70-5.0.4.tgz）
11-20
MongoDB Community Server（mongodb-shell-linux-x86_64-rhel70-5.0.4.tgz）适用于RedHat / CentOS 7.0 MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案...
MongoDB（mongodb-org-shell-5.0.4-1.suse12.x86_64.rpm）
11-20
MongoDB Community Server（mongodb-org-shell-5.0.4-1.suse12.x86_64.rpm）适用于SUSE12 MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。 MongoDB是...
MongoDB（mongodb-org-shell-5.0.4-1.suse15.x86_64.rpm)
11-20
MongoDB Community Server（mongodb-org-shell-5.0.4-1.suse15.x86_64.rpm）适用于SUSE15 MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。 MongoDB是...
mongodb创建索引
路过我的生活呀
10-15 361
mongo shell如下：读取索引文件，给表aaa创建索引。导出索引至1.json文件。
MongoDB常用操作示例
源滚滚编程
05-06 776
以下是基于 MongoDB Shell 的完整操作示例，覆盖数据库管理、集合操作、文档处理、聚合分析、索引管理等核心功能，并结合实际场景说明。所有示例均结合搜索结果中的技术要点整理而成。
Mongo的基本shell操作(大全)
qq_53217531的博客
11-04 3643
mongo操作命令大全
MongoDb 如何创建索引
zzqincsdn的博客
06-26 249
你可以在 MongoDB shell 或者通过编程语言的 MongoDB 驱动来创建索引。
6.MongoDB之索引
mijichui2153的博客
02-18 5267
关于索引举个日常生活中的例子。拿到一本书想查阅某知识的时候我们一般都会先去看目录，找到相关的章节后直接翻到对应的页码然后在这里小章节里面进一步定位我们想要的内容；这就是目录索引，能够帮助读者快读的找到想要找的内容。(一个更好的例子应该是英汉词典了，当我们查询单词的时候我们不会一页一页的去遍历整个词典，而是现根据首字母快读定位到对应章节然后再根据次字母进一步缩小查询范围，知道最终找到对应单词。) 其实在数据库中也一样，索引能够极大的提高查询效率。如果没有索引mongodb在读取数据的时候必须扫描集合中的每个.
MongoDB学习笔记之索引（一）
yaya_jn的博客
04-25 8336
MongoDB索引 索引是一种用来快速查询数据的数据结构。B+Tree就是一种常见的数据库索引数据结构，MongoDB采用B+Tree做索引，索引创建在collections上。MongoDB不使用索引的查询，先扫描所有的文档，再匹配符合条件的文档。使用索引的查询，通过索引找到文档，使用索引能够极大的提升查询效率。 一、MongoDB索引数据结构 索引数据结构介绍及官方文档 MongoDB索引数据结构具体使用的是B+Tree，因为B+Tree是B-Tree的子集，所以叫B-Tree也对，但是容易混淆
在MongoDB中添加索引
热门推荐
小白菜的博客
05-28 1万+
    MongoDB允许你对集合中的字段建立索引，以便更快地找到文档。当你在MongoDB中添加一个索引时，后台创建一个特殊的数据结构，其中存储集合的一小部分数据并优化此数据结构，以便能够更快地找到特定的文档。    例如，对一个_id索引基本上是建立_id值的排序的数组。一旦该索引已经创建，你将获得以下好处：当按照_id查找对象时，你可以对有序索引执行优化的搜索，找到上述的对象。假定你要让对象...
udo apt install mongodb-org mongodb-org-database mongodb-org-server mongodb-org-shell mongodb-org-mongos mongodb-org-tools 我i需要安装5.0.2版本，应该怎么写
最新发布
08-27
sudo apt-mark hold mongodb-org mongodb-org-database mongodb-org-server mongodb-org-shell mongodb-org-mongos mongodb-org-tools 因此，完整的命令序列如下： 注意：请确保你使用的Ubuntu版本与MongoDB...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值