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

hellboy0621 hellboy0621 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 800+累计阅读 845平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄9年
关注
原创 最新推荐文章于 2026-03-26 03:14:51 发布 845 阅读 AI 写同款· GEO 优化 ›
MongoDB实战 – 用MongoDB Shell访问MongoDB数据库 MongoDB Shell用来连接和使用MongoDB，是最快捷的方式；用户可以使用Mongo Shell查询和更新数据以及执行管理操作。 Mongo Shell作为MongoDB Server安装的一部分包含在内。 阅读详情

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

默认情况下，当一个集合被创建并且文档被添加到其中时，会在_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
}

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


收录于
Linux

当前文章被收录于：

Linux
27 篇文章 2 人学习
订阅专栏 查看详情
MongoDB

当前文章被收录于：

MongoDB
9 篇文章 0 人学习
订阅专栏 查看详情
标签
#索引 #MongoDB
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
mongodb搭建，shell操作，索引，副本集 该文档适用于运维，dba，非开发代码，下再留意目录。 立即下载

相关推荐

麒麟KylinV10系统yum源更换全攻略：从官方源到第三方仓库的保姆级教程

本文详细介绍了麒麟KylinV10系统yum源的更换与优化方法，包括官方源配置、第三方仓库集成及RPM包管理技巧。通过实战案例和命令示例，帮助用户快速解决软件依赖问题，提升系统管理效率。特别适合需要在国产操作系统上进行开发的工程师参考。

weixin_30752699的博客 647

执行shell 文件为mongodb建立索引

1.mongodb建立索引的命令为db.collections.ensureIndex({xx:1})  我们为表user建立字段为age的索引 db.user.ensureIndex({age:1}) 1 这里代表升序，-1代表降序 2.1个表1个索引，我们可以通过手动输入，如果在服务器上有多张表，多个索引，这种在终端敲的方法肯定不行，因为容易出错，检查出错会浪费很多的时间，因此通过执行s

rjgcx2的专栏 2526

基于Labview2012实现的双通道信号源（课程设计）

双通道信号源，产生8种波形，能进行调制，带信号幅度与频率扫描功能，波形可存储与导入

qq_40617082的博客 1460

mongodb创建索引

mongo shell如下：读取索引文件，给表aaa创建索引。导出索引至1.json文件。

路过我的生活呀 402

Code Composer Studio 8.3.1安装与常见问题解决指南

本文提供了Code Composer Studio 8.3.1版本的详细安装指南与常见问题解决方案。内容涵盖从下载离线安装包、系统环境准备、自定义安装步骤，到首次启动配置及汉化建议。重点解析了安装过程中可能遇到的闪退、卡顿、Java虚拟机错误等典型问题的排查与修复方法，旨在帮助开发者高效部署这一稳定的嵌入式集成开发环境。

weixin_29195217的博客 327

Linux初级介绍之番外篇：Linux挂载windows中的共享目录

挂载windows共享目录Windows端共享权限设定解禁Guest设置共享目录权限Linux挂载端扫描共享目录挂载共享目录遇到错误的解决方案 Windows端共享权限设定 解禁Guest 右击我的电脑选择管理–>本地用户和组–>在用户项中双击Guest用户–>取消账号已禁用选项 设置共享目录权限 右击共享目录点属性–>在共享页面中点击共享选项–>下拉选择共享对象为Everyone–>点击共享按钮 3.设置本地策略 打开命令框–>输入secpol.msc–&gt

m0_53497201的博客 228

MongoDB常用操作示例

以下是基于 MongoDB Shell 的完整操作示例，覆盖数据库管理、集合操作、文档处理、聚合分析、索引管理等核心功能，并结合实际场景说明。所有示例均结合搜索结果中的技术要点整理而成。

未来已来，AI时代，学AI编程，做AI量化，就来大鹏AI教育。 918

PCL Super4PCS算法实现点云粗配准（版本一）【2025最新版】

Win11系统下实现[Super4PCS: Fast Global Pointcloud Registration via Smart Indexing一文中的配准算法。

点云侠的博客 3377

Mongo的基本shell操作(大全)

mongo操作命令大全

qq_53217531的博客 3708

一网打尽身份验证与授权：深入剖析ASP.NET Core Identity在C#中的全方位实战应用

ASP.NET Core Identity 是 Microsoft 提供的一个强大且可扩展的身份验证和授权框架，用于构建基于用户账户、角色和权限的Web应用程序。它提供了用户注册、登录、密码管理、多因素认证、角色分配、授权等功能，与ASP.NET Core框架深度集成，简化了安全相关的开发工作。通过上述代码示例和注释，展示了如何安装配置Identity、自定义用户实体与数据库上下文、实现用户注册登录、管理角色与用户角色关系，以及如何使用授权策略保护应用程序资源。，并指定用户和角色类型以及主键类型。

java专栏 1526

AFSim2.9.0学习笔记 —— 1、AFSim及完整工具介绍（文末附：完整afsim2.9.0源码、编译好的完整工具包、中文教材等）

AFSim2.9.0学习笔记 —— 1、AFSim及完整工具介绍（附：完整afsim2.9.0源码、编译好的完整工具包、中文教材等）

5168

MongoDb 如何创建索引

你可以在 MongoDB shell 或者通过编程语言的 MongoDB 驱动来创建索引。

zzqincsdn的博客 290

图像处理系列——直方图之直方图规定化(Histogram Specification)

直方图规定化也叫直方图匹配(Histogram Matching)，让原图像的像素分布与规定图像的像素分布保持一致。直方图规定化比直方图均衡化更加灵活，算是直方图均衡的变种。常用于图片风格一致性的自动处理，能有效的改善图像的整体或局部的特征，广泛运用在图像增强处理中。

nanke_yh的博客 4594

MongoDB 关于MongoDB Shell的使用 (三)

在本文中，将介绍mongo shell的基本知识，以及如何使用它来管理MongoDB文档。为了使读者更容易地理解和实践概念，MongoDB shell的引入被分成了三个部分。

Noseparte的博客 1万+

SAP B1中文培訓教材_SDK

公司内部培训资料，对开发工具 ，DIAPI， UIAPI，Add-ON有详细解说

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

MongoDB Shell

MongoDB Shell 是 MongoDB 提供的官方交互式界面，允许用户与 MongoDB 数据库进行交互、执行命令和操作数据库。MongoDB Shell 是基于 JavaScript 的，允许用户直接在命令行或者脚本中使用 JavaScript 语言来操作 MongoDB 数据库。

w850608的博客 1423

IEM模型，地表粗糙度模拟

利用微波反演土壤水分时候，利用IEM模型可以实现对随机地表的模拟

mongoDB的shell的基本操作

mongoDB的shell的基本操作 　　默认是以test用户操作，我们可以通过mongolocalhost:27017/admin增大权限 　　1.创建一个数据库 　　use[databaseName] 　　但是若什么也不做就退出的话这个空数据库会被删除 　　2.查看所有数据库 　　showdbs 　　3.给指定数据库添加集合并且添加记录 　　db

u014464526的专栏 333

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章，有部分习题没有答案，全英文复分析阿尔福斯(Ahlfors) 第三版答案

MongoDB shell 基本操作

MongoDB shell 基本操作 文章目录MongoDB shell 基本操作MongoDB bin目录结构MongoDB Shell 客户端数据库 CURD 操作查看当前数据库查看数据库状态信息查看所有数据库切换数据库创建数据库删除数据库集合 CURD 操作创建集合显示集合删除集合插入文档insertOne 函数：集合插入单个文档insertMany 函数：集合插入多个文档(数组)insert 函数：集合插入1个或多个文档（数组）save 函数：更新集合文档删除文档remove 函数：删除集合文档

ZL94666的博客 259

【MongoDB】二、MongoDB数据库的基本操作

通过本次实验，我熟练地使用Mongo Shell对数据库，集合，文档进行增删改的操作，以及流畅使用 $group $limit $match $sort $project $skip等聚合管道操作符对文档进行查询、处理及分析。在实验过程中遇到了很多硬件或者是软件上的问题，请教老师，询问同学，上网查资料，都是解决这些问题的途径。最终将遇到的问题一一解决最终完成实验。

慢热型网友的博客 3255

MongoDB Shell命令

MongoDB Shell是MongoDB的官方交互式工具，基于JavaScript，允许用户通过命令行操作数据库。文章介绍了在macOS、Linux和Windows系统上安装MongoDB Shell的详细步骤：macOS可通过Homebrew或手动下载安装，Linux使用包管理器或手动安装，Windows则下载安装程序。安装完成后，用户可通过mongosh命令连接数据库，执行查询、插入、更新、删除等基本操作。文中提供了连接本地服务器、查看数据库、操作集合的完整示例流程，并附有官方安装文档链接。

xiaoaque的博客 935

MongoDB Shell 基本操作总结

MongoDB Shell 基本操作总结

qq_39045558的博客 645

mongodb shell基础命令

mongodb shell命令 1.数据库基本操作 在mongodb中，使用use来创建和选择数据库，当数据库不存在时，use会创建一个新的数据库，但是这数据库并没有持久化到硬盘里面，而存在内存中，只有当用户往这个新创建的空数据库建collection才会做持久化操作。 创建和切换数据库 use 数据库名称 查看有权限查看的所有的数据库 mongodb是不对空数据库做持久化的，所以新创建的空数据库，用show指令是看不见的，必须建collection后才能看见。 show dbs show datab

qq_43203949的博客 2134

MongoDB Shell 使用详解：从安装到实战操作

本文全面介绍了MongoDB Shell（mongosh）的使用方法，从安装配置到实战操作。

✨ 欢迎来到【Seal ^_^ 的优快云博客】！✨ 7584

MongoDB 导出索引（表结构）

导出索引的脚本 var collectionList = db.getCollectionNames(); for(var index in collectionList){ var collection = collectionList[index]; var cur = db.getCollection(collection).getIndexes(); if(cu...

不是好汉 7501

MongoDB——Shell的基本操作及使用窍门

MongoDB自带一个JavaScript shell,可以从命令行与MongoDB实例交互。这个 shell非常有用，通过它可以执行管理操作、检査运行实例，亦或做其他尝试。这个 mongo shell对于使用MongoDB来说是至关重要的工具，本书后面也会经常使用这 个工具。 运行shell 运行mongo启动shell: $ ./mongo MongoDB shell versio...

学亮编程手记 996

MongoDB 之旅（二） 基本操作（MongoDB Javascript Shell）

在了解了MongoDB后，这里简单介绍一下对MongoDB的一些简单操作。 MongoDB安装介绍： http://www.cnblogs.com/czxu/archive/2011/06/13/2080162.html MongoDB javascript shell 是一个基于javascript的解释器，故是支持js程序的。如下： for(i=0;i<200000;i...

139
上一篇： MongoDB Shell基本操作（二） - 查询
下一篇： MongoDB Shell基本操作（四） - 高级查询
点赞 0
评论 0
书签 书签 0
hellboy0621
hellboy0621
博客等级 码龄9年 61粉丝 147原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值