MongoDB数据库常用命令操作

吾家陈小白

已于 2022-07-29 09:08:49 修改

阅读量6.9k

点赞数 2

分类专栏： Mongodb 文章标签：数据库 mongodb sql

于 2022-07-28 16:37:05 首次发布

本文链接：https://blog.csdn.net/cw3225654/article/details/126038286

版权

Mongodb 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、数据库操作

查询数据库

> show dbs #查看所有数据库
> db #查看当前库

新增数据库

> use db1 ：#有则切换，无则新增，但需要再创建集合才会增加新库

删数据库

> db.dropDatabase()

查看帮助

> db.help()

二、集合（表）

查询集合（表）

> show collections
> show tables

新增集合（表）

#语法：db.createCollection(name, {capped: <boolean>,autoIndexId: <boolean>,size: <数值>,max: <数值>})
#capped：可选，创建固定大小集合，当达到最大值时，它会自动覆盖最早的文档。必须指定 size参数。默认为 false。
#autoIndexId：可选，自动在 _id 字段创建索引。默认为 false。
#size：可选，为固定集合指定一个最大值，以千字节计（KB）。
#max：可选，指定固定集合中包含文档的最大数量。

> db.createCollection("test")
> db.createCollection("test", { capped : true, autoIndexId : true, size : 6142800, max : 10000 } )

删除集合（表）

> db.user.info.drop()

三、文档（行）

查询文档（行）

#普通查询--------------------------------------------------------------------------------
> db.user.find() #查询aa集合中所有文档
> db.user.find({},{name:1,_id:0}) # #查询aa集合中所有文档，但只显示name字段，_id字段是默认显示的，所以0表示不显示，非0表示显示

#条件查询---------------------------------------------------------------------------------
#=：$eq
#!=：$ne
#>：$gt
#<：$lt
#>=：gte
#<=：lte

> db.user.info.find() #查看所有的记录
> db.user.info.find().pertty #美化
> db.user.findOne() #查一条
#select * from db1.usesr where id=3
> db.user.find({"_id":3})
#select * from db1.usesr where id!=3
> db.user.find({"_id":{"$ne":3}})
#select * from db1.usesr where id<3
> db.user.find({"_id":{"$lt":3}})
#select * from db1.usesr where id>3
> db.user.find({"_id":{"$gt":3}})
#select * from db1.usesr where id>=3
> db.user.find({"_id":{"$gte":3}})
#select * from db1.usesr where id<=3
> db.user.find({"_id":{"$lte":3}})

#模糊查询---------------------------------------------------------------------------------
#select * from db1.user where name like '%教%'
> db.user.find({name:/教/}) #查询 name 包含"教"字的文档
#select * from db1.user where name like '教%'
> db.user.find({name:/^教/}) #查询 name 字段以"教"字开头的文档
#select * from db1.user where name like '%教'
> db.user.find({name:/教$/}) #查询 name 字段以"教"字结尾的文档

#and、or、not逻辑查询------------------------------------------------------------------
#and逻辑查询
#select * from db1.user where id >=3 and id <=4;
> db.user.find({"_id":{"$gte":3,"$lte":4}})
#select * from db1.user where id >=3 and id <=4 and age >=40;
> db.user.find({
"_id":{"$gte":3,"$lte":4},
"age":{"$gte":40} #结束就不要加逗号了
})
#或者
> db.user.find({"$and":[
{"_id":{"$gte":3,"$lte":4}}, #一个字典就是一个条件
{"age":{"$gte":40}}
]})

#or逻辑查询
#select * from db1.user where id =3 or name = "张三";
> db.user.find({$or: [{id: 3}, {name:"张三"}]})

#and和or逻辑查询
#select * from db1.user where id >=0 and id <=1 or id >=4 or name = "张三";
> db.user.find( { "$or":[{"id":{"$lte":1,"$gte":0}},{"id":{"$gte":4}},{"name":"张三"}] } )
#select * from db1.user where id >=50 and (name = "张三" or age = 22 );
> db.user.find({"id": {$gt:50}, $or: [{"name": "张三"},{"age": 22}]})

#$type类型查询----------------------------------------------------------------------------
#Double：1 | String：2 | Object：3 | Array：4 | Binary data：5 | Undefined：6(已废弃) | Object id：7 | Boolean：8 | Date：9 | Null：10
#Regular Expression：11 | JavaScript：13 | Symbol：14 | JavaScript (with scope)：15 | 32-bit integer：16 | Timestamp：17 | 64-bit #integer：18
#Min key：255(Query with -1) | Max key：127
> db.user.find({name:{$type:"string"}}) # 查询 name 为 String 类型的数据
> db.user.find({name:{$type:2}})

#limit与skip方法范围查询------------------------------------------------------------------
#limit(number)：用来读取指定数量文档
#skip(number)：用来跳过指定数量文档
> db.user.find().limit(2) #查询前两个文档
> db.user.find().skip(1) #跳过1个文档，查询第一个以后的所有文档
> db.user.find().skip(1) .limit(2) #跳过1个文档，查询第一个以后的2个文档

#sort排序查询------------------------------------------------------------------------------
#sort()：通过参数指定排序的字段，1升序，-1降序。
> db.user.find().sort({"name":-1}) #根据name字段倒序排列

#select * from db1.user where id % 2 = 1; #奇数
> db.user.find({"_id":{"$mod":[2,1]}}) #取模运算，id对2取模
#取反，偶数
> db.user.find({"_id":{"$not":{"$mod":[2,1]}}})

#in和nin查询------------------------------------------------------------------------------
#select * from db1.user where age in (20,30,31);
> db.user.find({"age":{"$in":[20,30,31]}})
#select * from db1.user where name not in ('张三','李四');
> db.user.find({"name":{"$nin":['张三','李四']}})

#正则匹配查询-----------------------------------------------------------------------------
#select * from db1.user where name regexp "^jin.*?(g|n)$";
> db.user.find({
"name":/^jin.*?(g|n)$/i
})

#aggregate()聚合查询--------------------------------------------------------------------
#aggregate()聚合主要用于处理数据(诸如统计平均值,求和等),比如类似sql语句中的 count(*)。
#聚合表达式
#$sum ：计算总和。 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : "$likes"}}}])
#$avg：计算平均值 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$avg : "$likes"}}}])
#$min：获取集合中所有文档对应值得最小值。 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$min : "$likes"}}}])
#$max ：获取集合中所有文档对应值得最大值。 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$max : "$likes"}}}])
#$push：在结果文档中插入值到一个数组中。 db.mycol.aggregate([{$group : {_id : "$by_user", url : {$push: "$url"}}}])
#$addToSet：在结果文档中插入值到一个数组中，但不创建副本。 db.mycol.aggregate([{$group : {_id : "$by_user", url : {$addToSet : "$url"}}}])
#$first ：根据资源文档的排序获取第一个文档数据。 db.mycol.aggregate([{$group : {_id : "$by_user", first_url : {$first : "$url"}}}])
#$last：根据资源文档的排序获取最后一个文档数据 db.mycol.aggregate([{$group : {_id : "$by_user", last_url : {$last : "$url"}}}])

{ "_id" : ObjectId("5e1bdb21364a0e9e97386c8f"), "name" : "张三", "ailas" : "小白会飞檐走壁" }
{ "_id" : ObjectId("5e1d7ffdd9e88f2bdbfb34b2"), "name" : 100 }
{ "_id" : ObjectId("5e1edeb059887c0e8273e26c"), "name" : "张三", "ticket" : 2 }
{ "_id" : ObjectId("5e1edebf59887c0e8273e26d"), "name" : "李四", "ticket" : 1 }
{ "_id" : ObjectId("5e1eded059887c0e8273e26e"), "name" : "李四", "ticket" : 3 }
#select name, count(*) from user group by name
> db.user.aggregate([{$group:{_id:"$name",num_ticket:{$sum:1}}}])
{ "_id" : 100, "num_ticket" : 1 }
{ "_id" : "李四", "num_ticket" : 2 }
{ "_id" : "张三", "num_ticket" : 2 }
#select name, sum(ticket) from user group by name
> db.user.aggregate([{$group:{_id:"$name",num_ticket:{$sum:"$ticket"}}}])
{ "_id" : 100, "num_ticket" : 0 }
{ "_id" : "李四", "num_ticket" : 4 }
{ "_id" : "张三", "num_ticket" : 2 }

#MongoDB聚合管道：文档在一个管道处理完毕后可以将结果再传递给下一个管道处理，管道操作是可以重复的。
#管道操作符
#$project：修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
#$match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
#$limit：用来限制MongoDB聚合管道返回的文档数。
#$skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
#$unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。
#$group：将集合中的文档分组，可用于统计结果。
#$sort：将输入文档排序后输出。
#$geoNear：输出接近某一地理位置的有序文档。
#$out：把管道的结果写入某个集合。
#$redact：控制特定数据的访问。
#$lookup：多表关联（3.2版本新增）
> db.article.aggregate({ $project : {title : 1 ,author : 1 }}); #结果中就只有_id,tilte和author三个字段，默认情况下_id字段是被包含的
> db.article.aggregate({ $project : {_id : 0 ,title : 1 ,author : 1 }}); #如果要想不包含_id可以将_id值设为0
> db.articles.aggregate( [ { $match : { score : { $gt : 70, $lte : 90 } } }, { $group: { _id: null, count: { $sum: 1 } } } ] ); #$match用于匹配分数大于70小于或等于90记录，然后将符合条件的记录送到下一阶段$group管道操作符进行处理。
> db.article.aggregate({ $skip : 5 }); #经过$skip管道操作符处理后，前五个文档被"过滤"掉。

索引文档（行）

#创建索引--------------------------------------------------------------------------------------------------------------------------------------
#db.collection.ensureIndex() #在 3.0.0 版本前使用此方法创建，ensureIndex() 还能用，但只是 createIndex() 的别名。
#语法：db.collection.createIndex(keys, options)
#语法中 keys 值为你要创建的索引字段，1 为指定按升序创建索引，如果你想按降序来创建索引指定为 -1 即可。
#options可选参说明：
#background：Boolean 建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引，即增加 "background" 可选参数。 "background" 默认值为false。
#unique：Boolean 建立的索引是否唯一。指定为true创建唯一索引。默认值为false.
#name：string 索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成一个索引名称。
#dropDups：Boolean 3.0+版本已废弃。在建立唯一索引时是否删除重复记录,指定 true 创建唯一索引。默认值为 false.
#sparse：Boolean 对文档中不存在的字段数据不启用索引；这个参数需要特别注意，如果设置为true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 false.
#expireAfterSeconds：integer 指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间。
#v：index version 索引的版本号。默认的索引版本取决于mongod创建索引时运行的版本。
#weights：document 索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得分权重。
#default_language：string 对于文本索引，该参数决定了停用词及词干和词器的规则的列表。 默认为英语
#language_override：string 对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language，默认值为 language.

> db.user.createIndex({"title":1}) #给 title 字段按升序创建索引，如果按降序创建索引指定为 -1 即可。
> db.user.createIndex({"title":1,"description":-1}) #设置多个字段创建索引，关系型数据库中称作复合索引
> db.user.createIndex({open: 1, close: 1}, {background: true}) #通过在创建索引时加 background:true 的选项，让创建工作在后台执行

#查看索引--------------------------------------------------------------------------------------------------------------------------------------
> db.user.getIndexes() #查看集合索引
> db.user.totalIndexSize() #查看集合索引大小

#删除索引--------------------------------------------------------------------------------------------------------------------------------------
> db.user.dropIndexes() #删除所有索引
> db.use.dropIndex("索引名称") #删除指定索引

#通过创建索引过期时间，可以删除过期的文档-----------------------------------------------------------------------------------------------
> db.user.createIndex({"createDate": 1},{expireAfterSeconds: 30}) #根据createDate字段日期值，30秒过后删除该文档，注：createDate 字段必须为日期类型
> db.aa.createIndex({"createDate": 1},{expireAfterSeconds: 0}) #根据createDate字段日期值删除该文档
#注意：
#索引关键字段必须是 Date 类型。
#非立即执行：扫描 Document 过期数据并删除是独立线程执行，默认 60s 扫描一次，删除也不一定是立即删除成功。
#单字段索引，混合索引不支持。

新增文档（行）

> user0={"name":"xiaobai"}
> user1={"name":"xiaohuang"}
#方式一(推荐)：
#单条添加,3.2 版本后
> db.user.insertOne({"a": 3})
#批量添加,3.2 版本后
> db.user.insertMany([{"name":"xiaobai"},{"name":"xiaohuang"}])
> db.user.insertMany([user0,user1])

#方式二(不推荐)：
#单条添加，如果user1没写id，自动生成id,如果有id不能和已有id重复
> db.user.insert({"name":"xiaobai"})
> db.user.insert(user0)
#批量添加
> db.user.insert([{"name":"xiaobai"},{"name":"xiaohuang"}])
> db.user.insert([user0,user1])

#方式三：#语法：db.collection.save(<document>,{writeConcern: <document>})
> db.user.save({"_id":3,"name":"xiaohei"}}) #id相同是修改，id不同或没有则新增

修改文档（行）

#语法：db.collection.update(<query>,<update>,{upsert: <boolean>,multi: <boolean>,writeConcern: <document>})
#query : update的查询条件，类似sql update查询内where后面的。
#update : update的对象和一些更新的操作符（如$,$inc...）等，也可以理解为sql update查询内set后面的
#upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
#multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
#writeConcern :可选，抛出异常的级别。

#方式一：
> db.table1.updateOne({"name":"张三"},{$set:{"title":"李四"}}) #根据条件修改一条数据的内容,如出现多条,只修改最高前的数
> db.table1.updateMany({"name":"张三"},{$set:{"title":"李四"}}) #根据条件修改所有数据的内容,多条修改
#方式二：
> db.table1.update()({'name':'张三'},{$set:{'title':'李四'}}) #只会修改先发现的第一条文档。
> db.table1.update()({'name':'张三'},{$set:{'title':'李四'}},{multi:true})#如果你要修改多条相同的文档，则需要设置 multi 参数为 true。

#数据更新操作符
#$set：把文档中某个字段field的值设为value
> db.students.update({name:"张三"},{$set:{age:23}}) #把name为张三的文档的age字段值设置为23

#$unset：删除某个字段field
> db.students.update({name:"张三"},{$unset:{age:1}}) #把name为张三的文档的age字段删除

#$inc：对一个数字字段的某个field增加value
> db.students.update({name:"张三"},{$inc:{age:5}}) #把name为张三的文档的age字段值 +5

#$push：把value追加到field里。注：field只能是数组类型，如果field不存在，会自动插入一个数组类型
> db.students.find()
{ "_id" : ObjectId("5e1bdb21364a0e9e97386c8f"), "name" : "张三" }
> db.students.update({name:"张三"},{$push:{"ailas":"A0"}})
> db.students.find()
{ "_id" : ObjectId("5e1bdb21364a0e9e97386c8f"), "name" : "张三", "ailas" : [ "A0" ] }

#pushAll：用法同$push一样，只是$pushAll可以一次追加多个值到一个数组字段内。在3.6版本以后取消了$pushAll
> db.students.update({name:"张三"},{$pushAll:{"ailas":["A1","A2"]}})
> db.students.update({name:"张三"},{$push: {ailas: {$each: ["A1","A2" ]}}}) #3.6版本以后使用 $push + $each

#$addToSet：加一个值到数组内，而且只有当这个值在数组中不存在时才增加。
> db.students.update({name:"张三"},{$addToSet: {ailas: "A3"}}) #添加一个值到数组中
> db.students.update({name:"张三"},{$addToSet: {ailas: {$each: ["A3","A4" ]}}}) #添加多个值到数组中

#$pop：从数组field内删除数组内的一个值
> db.students.update({name:"张三"},{$pop:{"ailas":-1}}) #删除ailas数组中的第一个值
> db.students.update({name:"张三"},{$pop:{"ailas":1}}) #删除ailas数组中的最后一个值

#$pull：从数组field内删除一个等于_value的值
> db.students.update({name:"张三"},{$pull:{"ailas":"A1"}})

#$pullAll：用法同$pull一样，可以一次性删除数组内的多个值。
> db.students.update({name:"张三"},{$pullAll:{"ailas":["A1","A2"]}})

#$rename：对字段进行重命名
> db.students.update({name:"张三"},{$rename:{"name":"sname"}}) #把name为张三的文档的name字段名重命名为sname

删除文档（行）

#方式一(推荐)：
> db.students.deleteOne( { name: "张三" } ) #删除 name 等于 张三 的一个文档
> db.students.deleteMany({ name : "张三" }) #删除 name 等于 张三 的全部文档
> db.students.deleteMany({}) #删除集合下全部文档

#方式二(不推荐)：
#语法：db.collection.remove(<query>,{justOne: <boolean>,writeConcern: <document>})
#query :（可选）删除的文档的条件。
#justOne : （可选）如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，则删除所有匹配条件的文档。
#writeConcern :（可选）抛出异常的级别。
> db.students.remove({name:"张三"},{justOne:true}) #删除 name 等于 张三 的一个文档
> db.students.remove({'name':'张三'}) #删除 name 等于 张三 的全部文档
#remove() 方法 并不会真正释放空间，需要继续执行 db.repairDatabase() 来回收磁盘空间。
> db.repairDatabase()
或者
> db.runCommand({ repairDatabase: 1 })