本文实例讲述了MongoDB Shell 命令。分享给大家供大家参考，具体如下：
原始文件请到我的github上去下载：https://github.com/yangqingxian/mongodb
这里先讲几件事：
1、这是第三次修改这篇文章了，也是第一次正真意义上的使用 github 来控制版本，想想还是有点小激动的:)
2、其中的内容结构与 mongodb基础命令是一致的，只不过添加了很多内容进去，适用于想进一步学习mongodb数据库的人
3、我其实也是菜鸟，所以我会用很白目的语言来解释其中的内容，如果你也跟我一样，那就两只鸟一起飞吧
4、接下来的内容均是我对《MongoDB大数据权威指南(第2版)》的摘记
5、其中的命令例子并没有事先创建好数据库、集合，都是要用到的时候临时写的，注意理解
mongodb数据库结构与传统关系型数据库的比较，便于理解接下来的内容
数据库->集合->文档
数据库->表 ->列
--------------------数据库内容------------------
查看所有数据库
|
1
|
show dbs
|
删除数据库
|
1
|
db.dropDatebase()
|
--------------------集合内容--------------------
创建集合
|
1
|
db.createCollection()
|
查看所有集合\表
|
1
2
|
show collections
show tables
|
选定某一集合
|
1
|
use db_name
|
查看集合的信息
|
1
|
db.stats()
|
删除一个集合，但是需要先指定一个数据库，即先执行 use db_name
|
1
|
db.dropDatabase()
|
修改集合的名称
|
1
|
db.collection_name.renameCollection('new_name')
|
----------------------文档内容---------------------
插入数据
|
1
2
|
db.collection_name.insert(document)
db.collection_name.save(document)
|
查询数据多条数据
|
1
|
db.collection_name.find()
|
1、可以指定返回的内容
参数解释
|
1
2
3
4
|
db.collection_name.find(
{query_term:value},
return_key_name:1}
)
|
a find()函数的第一个参数是查询条件，即匹配该内容的文档都会被筛选出来，如果没有查询条件，则输入{}，不可以为空
b find()函数的第二个参数是指定返回的内容，例如一个student的集合中的一个xiaoming文档中包含多条内容，姓名、学生号、家庭住址等，现在我只想看姓名，不想查询的时候返回xiaoming文档的全部内容，就可以使用这种'键名:1'的形式，后面的1表示筛选出该内容并正序输出，0表示筛选出除了该内容的其余部分，-1表示逆序跟1一样的结果
c 可以返回多条记录，这里只是举个例子，还是拿ixaoming的例子
|
1
2
3
4
|
{
'name':1,
'student_id':1
}
|
这样就返回了两个信息，一个name，一个student_id
2、查询嵌套信息
结合二维数组理解下面的这个信息
|
1
2
3
4
5
6
7
8
9
10
|
{
'name':'yang',
'sex':'man',
'skill':[
{'php':1},
{'mongodb':4},
{'redis':5}
],
'favorite_food':'meat'
}
|
其中如果使用skill来作为find()的查询条件的话，千万别写成这样
---错误例子---
|
1
|
db.self.find({'skill':[{'php':1}]})
|
这样是查不到的，因为这样mongodb会将{'skill':[{'php':1}]}解析成skill数组下只包含'php':1这一条记录的内容，上面的例子明显不符合这一要求，所以查询不到
---正确的例子---
|
1
|
db.self.find({'skill.php':1})
|
这里使用了 . 告诉mongodb数据库去匹配skill数组下php为1的内容，重点在于skill下是否有'php':1这一条记录
---正确例子2---
如果一定要使用上面的错误例子的方式查询数据，可以使用$elemMatch参数，注意该参数使用的位置
|
1
2
3
4
5
|
db.self.find({
'skill':{$elemMatch:
{'php':1}
}
})
|
这里的$elemMatch是作为条件操作符来使用的
查询单条数据
|
1
|
db.collection_name.findOne()
|
skip 跳过查询的最开始的数量，limit，限制返回数量，sort，当 x:1 表示正序，x:-1 表示逆序
|
1
|
db.collection_name.find().skip(Number).limit(Number).sort({x:1})
|
计算符合查询条件的文档的数量
|
1
|
db.collection_name.find().count()
|
count()函数默认情况下会忽略skip()或limit()函数，例如假设student集合中有4个文档，下面的三条语句将显示不同的结果
db.student.find().limit(1).count() 结果为4，count忽略了limit(1)的条件
db.student.find().limit(1).count(true) 结果为1，为count()传入参数true
获取结果的唯一值
|
1
|
db.collection_name.distinct('key_name')
|
也是查询的函数，只不过他比起find()会将查询结果显示唯一值，而不是根据原有集合中，文档的数量来显示结果，结合关系型数据库中的distinct来理解，举个例子，有一个图书集合--books，该集合下有书名，作者，出版日期等信息，注意，一个作者可能写了很多本书，现在我想查看在该集合中有多少作者，如果我直接使用上面的find()函数来搜索的话
|
1
2
3
4
|
db.books.find(
{},
{'writer':1}
)
|
这样会将全部的作者列出来，但是很多都是重复的，因为find()是根据文档数量来返回结果的，而distinct()会将结果筛选，
其中重复的部分
|
1
|
db.books.distinct('writer')
|
将查询结果分组
|
1
|
db.collection_name.group()
|
- 参数1 key 按照此key进行分组
- 参数2 initial 设置变量，该变量会在最终输出，注意，这个变量是对每个分组都会定义一个的，一个新的分组开始就重新创建
- 参数3 reduce 一个函数，在文档分组期间执行，即对一个文档进行一次分组就会执行一次，传入两个参数，一个是代表initial的参数，一个是目前进行分组的文档，为了便于理解，分别取名叫out和doc
- 参数4 keyf，可选，作用跟key一样，但是可以指定一个函数创建一个原本不存在于文档中的字段作为分组的依据，需要传入一个当前文档的参数
- 参数5 cond 过滤条件，只有满足该条件的文档才能参与分组
-
参数6 finalize 在分组完成后执行的函数，传入代表initial的参数
下面来看一个例子就能大致上了解了，先传入几个文档到orders集合中
|
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
|
data1={
"_id" : ObjectId("552a330e05c27486b9b9b650"),
"_class" : "com.mongo.model.Orders",
"onumber" : "002",
"date" : ISODate("2014-01-03T16:03:00Z"),
"cname" : "zcy",
"item" : {
"quantity" : 1,
"price" : 4.0,
"pnumber" : "p002"
}
}
data2={
"_id" : ObjectId("552a331d05c275d8590a550d"),
"_class" : "com.mongo.model.Orders",
"onumber" : "003",
"date" : ISODate("2014-01-04T16:03:00Z"),
"cname" : "zcy",
"item" : {
"quantity" : 10,
"price" : 2.0,
"pnumber" : "p001"
}
}
data3={
"_id" : ObjectId("552a333105c2f28194045a72"),
"_class" : "com.mongo.model.Orders",
"onumber" : "003",
"date" : ISODate("2014-01-04T16:03:00Z"),
"cname" : "zcy",
"item" : {
"quantity" : 30,
"price" : 4.0,
"pnumber" : "p002"
}
}
data4={
"_id" : ObjectId("552a333f05c2b62c01cff50e"),
"_class" : "com.mongo.model.Orders",
"onumber" : "004",
"date" : ISODate("2014-01-05T16:03:00Z"),
"cname" : "zcy",
"item" : {
"quantity" : 5,
"price" : 4.0,
"pnumber" : "p002"
}
}
db.orders.insert(data1)
db.orders.insert(data2)
db.orders.insert(data3)
db.orders.insert(data4)
|
接下来展示group()函数
例1
|
1
2
3
4
5
6
7
|
db.orders.group({
key:{data:1,'item.pnumber':1},
initial:{'total':0},
reduce:function (doc,out){
out.total+=doc.item.quantity
}
})
|
首先是按照data和ietm数组中的pnumber分组
接着定义了输出变量total，记录每个产品的总数
接着是定义处理函数，也就是reduce中的函数，注意，传入参数的先后顺序，第一个参数表示当前进行分组的文档，第二个参数表示initial，所以doc能直接调用doc.item.quantity，即文档的内容，out能调用out.total，即initial的内容
例2
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
db.orders.group({
keyf:function(doc){
return {'month':doc.date.getMonth()+1};
},
initial:{'total':0,'money':0},
reduce:function (doc,out){
out.total+=doc.item.quantity*doc.item.price
},
finalize:function (out){
out.avg=out.money/out.total;
return out;
}
})
|
首先，这个例子展示了keyf的用法，他返回了一个新的字段--month，接下来mongodb会按照month的计算结果分类
接着，就是在keyf以及finalize的函数中都有传入参数，其实这个参数跟reduce中的参数名字没有关系，这里写在一起主要是为了便于理解其含义
最后就是在finalize中临时创建了一个变量avg，这个avg在最后也是会被输出的
最后一点，在函数中处理结果都是会被return的
----------------使用条件操作符来筛选查询结果------------------
一般情况下都使用在find()的第一个参数内部，作为筛选条件使用
---$gt,$lt,$get,$lte,$ne---
|
1
2
3
4
|
db.collection_name.find(
{
key_name:{$gt:value}
})
|
注意操作符的位置，看例子可以便于理解
|
1
2
3
4
|
db.student.find(
{
'height':{$gt:180}
})
|
表示筛选出学生集合中身高高于180的学生
可以同时使用两个操作符来指定范围
|
1
2
3
|
db.student.find({
'height':{$gt:180,$lt:220}
})
|
这两个的使用方法跟上面是一样的，但是需要单独拎出来讲，因为有点特殊
---$in,$nin---
|
1
2
3
|
db.student.find({
'height':{$in:[170,180,190,200]}
})
|
表示筛选出身高为170，180，190，200的学生，$nin就是筛选除了170，180，190，200之外的学生
---$all---
上面的$in中的内容是‘或'的形式，只要你的身高是170，或180，或190，或200，那么你就符合筛选条件，而$all则是且的关系
|
1
2
3
|
db.student.find({
'height':{$all:[170,180,190,200]}
})
|
这句话的意思是你的身高既是170，又是180，又是190，又是200才能满足条件
---$or---
|
1
2
3
4
5
6
|
db.student.find({
$or:[
{'score':100},
{'sex':man}
]
})
|
上面的例子中，score:100与sex:man是‘或'的关系，结合下面的例子就可以看出$or的作用了
|
1
2
3
|
db.student.find(
{'score':100,'sex':'man'}
)
|
其中的score:100与sex:man是且的关系
limit(x)函数加skip(y)函数=$slice:[y,x]
具体使用方法可以看下面这个例子
|
1
2
3
4
|
db.student.find(
{},
{'height':{$slice:[10,5]}}
)
|
还是那句老话，注意$slice的位置，这句话表示筛选身高第11到15的人，第一个参数是skip()的参数，第二个是limit()
limit()函数是限制返回文档的数量的，$size是筛选符合数量的数组的，看下面的例子就明白了
先在数据库中添加以下信息
|
1
2
3
4
5
6
7
8
|
message={
'cds':[
{'first_song':'hello'},
{'second_song':'world'},
{'third_song':'again'}
]
}
db.songs.insert(message)
|
接着我们来查询一下上述结果
|
1
2
3
|
db.songs.find(
{'cds':{$size:2}}
)
|
无返回结果，因为cds数组里有3组数据
|
1
2
3
|
db.songs.find(
{'cds':{$size:3}}
)
|
返回全部结果，注意一点，这里是作为find()函数的第一个参数传入的，所以是筛选条件
筛选含有特定字段的值
|
1
2
3
4
|
db.collection_name.find(
{
key_name:{$exit:true}
})
|
返回存在该字段的文档，注意，这里是存在该字段，而没有指定该字段的具体内容
根据数据类型筛选返回结果
|
1
2
3
4
|
db.collection_name.find(
{
'key_name':{$type:x}
})
|
其中的x取值内容有很多，这里就不介绍了，因为太多了看一遍也没用
在筛选中使用正则表达式
|
1
2
3
4
|
db.collection_name.find(
{
'key_name':/ /
})
|
在/ /中添加正则表达式的内容
更新数据
|
1
|
db.collection_name.update({original_key:original_value},{new_key:new_value})
|
1、只要原 collection 中包含 original_key:original_value 就会被选中成为操作对象
2、整个 collection 都会被更新成 new_key:new_value ，而不单单就只是更新 original_key:original_value
相较于上面会更新整个集合，下面添加了 $set: 的形式来只进行部分字段的更新
|
1
|
db.collection_name.update({original_key:original_value},{$set:{new_key:new_value}})
|
上面使用$set更新了一条字段，可以使用$unset删除一条字段
|
1
2
3
4
|
db.collection_name.update{
{},
{$unset:{key:value}}
}
|
如果此更新数据不存在就创建这一条数据，加第三个参数为 true 就可以实现了
|
1
|
db.collection_name.update({original_key:original_value},{new_key:new_value},true)
|
或者下面的形式也可以
|
1
|
db.collection_name.update({original_key:original_value},{new_key:new_value},{upsert:true})
|
update 只会更新第一条满足条件的记录，但是想更新多条记录时，将第三个参数设置为 false，第四个参数设置为 true，而且还要设置 $set
|
1
|
db.collection_name.update({original_key:original_value},{$set{new_key:new_value}},false,true)
|
------------------插入数据——数组部分--------------------
插入数据
|
1
2
3
4
5
6
|
db.collection_name.update(
{original_key:value},
{$push:{
new_key:new:value
}}
)
|
注意，如果original_key不存在，则会被创建，并且定义为数组的形式，new_key:value则是第一个值
如果original_key存在，并且数数组，则插入new_key:value，如果不是数组，则报错
一次性插入多个值，前面是使用$push一次插入一个值，如果想插入多个值的话，需要使用下面的内容
|
1
2
3
4
5
6
7
8
9
10
11
12
|
db.collection_name.update(
{original_key:value},
{$push:{
new_key:{
$each:[
'value1',
'value2',
'value3'
]
}
}
})
|
注意这里的$push是针对数组操作的，也就是$each后面的内容都将添加到new_key的数组中
与$push对应，$pop删除数组中的数据
|
1
2
3
4
5
6
|
db.collection_name.update(
{original_key:value},
{$pop:{
{original_key:1}
}
})
|
注意，这里的1表示删除的数量，可以是2，3等整数，表示从数组的后端开始删除，也可以是-1等负数，表示从数组的前端开始删除
前面的$pop可以指定删除的数量，但是不能指定删除的条件，$pull则可以
|
1
2
3
4
5
6
|
db.collection_name.update(
{original_key:value},
{$pull:
{key1:value1}
}
)
|
$pull会删除掉key1中所有value1的数据，注意，是删除key1中的value1数据，不是删除key1，所以只要key1数组中包含了value1就会被删除掉value1
与$pull类似，$pullAll可以删除掉多个数据
|
1
2
3
4
5
6
7
8
9
10
11
|
db.collection_name.update(
{original_key:value},
{$pullAll:{
key1:
[
'value1',
'value2',
'value3'
]
}
})
|
$addToSet是一个非常实用的向数组添加数据的命令，如果该数据不存在则添加，存在就不会重复添加了
|
1
2
3
4
5
6
7
8
9
10
11
12
|
db.collection_name.update(
{original_key:value},
{$addToSet:{
new_key:{
$each:[
'value1',
'value2',
'value3'
]
}
}
})
|
设想一下，如果这里不添加$each的情况，如果不添加$each,则会变成往数组new_key中直接添加新的数组
|
1
|
['value1','value2','value3']
|
可以尝试一下，理解$each的功能，回到$addToSet上来，如果原数组中就存在value1,value2,value3则不会添加，如果不存在，则将没有的添加进去，有的也不会重复添加，彼此之间不是互相影响的。
原子操作
这里就不解释什么叫原子操作了，对于我们使用者来说只要知道怎么采用原子操作就可以了
|
1
2
3
4
5
6
7
8
|
db.collection_name.findAndModify(
{
query:{key:value},
sort:{key2:1/-1},
update/remove:true,
new:true
}
)
|
query 指定查询的文档
sort 排序，1，-1的含义这里就不解释了，跟上面一样
update/remove 表示操作
new 表示返回最终的修改结果，可以不填
删除所有查找到的数据
|
1
|
db.coolection_name.remove({key:value})
|
删除一张表
|
1
|
db.collection_name.drop()
|
查看集合的索引
|
1
|
db.collection_name.getIndexes()
|
创建索引
|
1
|
db.collection_name.ensureIndex({key:value})
|
前面是根据key:value的形式创建索引的，接下来就为一集合的某一字段全部创建索引
|
1
|
db.collection_name.ensureIndex({key:1})
|
复合索引的创建就是在其中多添加几个内容
删除索引
|
1
|
db.collection_name.dropIndex({key:value})
|
删除所有索引
|
1
|
db.collection_name.dropIndexes()
|
前面我们操作的都是一个集合，接下来我们要学习简单的操作多个集合了，有两种方式，手动或者使用DBRef
先创建两个集合
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
collection1={
'name':'yang',
'sex':'man'
}
collection2={
'id':1,
'name':'yang',
'math':60,
'pe':30,
'chinese':60
}
db.student.save(collection2)
db.yang.save(collection)
|
接下来就是大致思路了
|
1
2
3
4
|
yang=db.yang.findOne()
db.student.find(
{'name':yang.name}
)
|
mongodb不支持像传统的关系型数据库那样的多表操作，mongodb都是需要先将数据保存好，再来调用的，如上面的yang保存的就是find()查询所需要的内容，需要先将数据从数据库中读出保存好再来调用，其中yang.name就等于'yang'
接下来就是使用DBRef引用数据库了，调用DBRef需要传入三个参数，第一个调用的collection_name，id,db_name，这个可选，还是上面的这个例子，接下来使用DBRef的方式，这玩意我搞不定
希望本文所述对大家MongoDB数据库程序设计有所帮助。
原文链接：https://blog.csdn.net/yqxllwy/article/details/52805707