MongoDB数据库常用命令操作_mongodb查看所有数据库命令

一、数据库操作

---

1. 查询数据库

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

2. 新增数据库

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

3. 删数据库

> db.dropDatabase()
1

4. 查看帮助

> db.help()
1

二、集合（表）

---

1. 查询集合（表）

> show collections
> show tables
1
2

2. 新增集合（表）

#语法：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 } )
1
2
3
4
5
6
7
8

3. 删除集合（表）

> db.user.info.drop()
1

三、文档（行）

---

1. 查询文档（行）

#普通查询--------------------------------------------------------------------------------
> 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管道操作符处理后，前五个文档被"过滤"掉。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

2. 索引文档（行）

#创建索引--------------------------------------------------------------------------------------------------------------------------------------
#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 扫描一次，删除也不一定是立即删除成功。
#单字段索引，混合索引不支持。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3. 新增文档（行）

> 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不同或没有则新增
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4. 修改文档（行）

#语法：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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

5. 删除文档（行）

#方式一(推荐)：
> 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 })
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16