MongoDB的基础

操作条件:

 1,已经安装好的MongoDB

 2,进入到MongoDB中

基础操作：

0) show dbs #查看所有的库

1) use mydb #进入mydb库，如果mydb不存在将创建一个mydb数据库并进入

2) db #查看你当前所在的库

3) db.dropDatabase() # 删除数据库(在进入库后，输入)

4)  show collections # 查看库中的集合(进入库后)

5) db.createCollection('集合名') #创建一个集合,相当于MySQL中的table

6) db.集合名.insert([{"x":"y","z":1,...} , {...},...]) #创建一个集合并向里面写入一个或者多个文档  

      如果集合已经存在,将向里面写入文档

7) db.集合名.remove({文档中的元素},1/0) #删除具体条件 

第二位为1时:删除一条符合条件的文档 为零时或者不写:则是删除全部符合条件的文档

8) db.集合名.remove({}) #删除集合中的全部文档

9) db.集合名.find() #查询的集合中的文档(在末尾处加.pretty() 则可以使其格式化显示)

-------------------------------------分割线---------------------------------------

集合中条件内容的查询操作:

$it <
 1) db.集合名.find({"xxx":{$it:50}}).pretty() #查询集合中的xxx小于50的文档 格式化显示

$ite <=

2) db.集合名.find({"xxx":{$ite:50}}).pretty() #查询集合中的xxx小于等于50的文档 格式化显示

$gt >

3) db.集合名.find({"xxx":{$gt:20}}).pretty() #查询集合中的xxx大于20的文档 格式化显示

$gte >=

4) db.集合名.find({"xxx":{$gte:20}}).pretty() #查询集合中的xxx大于等于20的文档 格式化显示

$ne !=

5) db.集合名.find({"xxx":{$ne:30}}).pretty() #查询集合中的xxx不等于20的文档 格式化显示

$and 和

6) db.集合名.find({$and:[{条件1},{条件2},...]}).pretty() #查询集合中符合条件1同时又符合条件2的-文档

$or 或

7) db.集合名.find({$or:[{条件1},{条件2},...]}).pretty() #查询集中中符合条件1或符合条件2的文档

$in

$nin

8) db.集合名.find({"xxx":{$in:["yyy","zzz",...]}}).pretty() #查询集合中"xxx": 中属于"yyy"/"zzz"/...的文档 

   db.集合名.find({"xxx":{$nin:["yyy","zzz",...]}}).pretty() #查询集合中"xxx": 中不属于"yyy"/"zzz"/...的文档 

-------------------------------------分割线---------------------------------------

修改文档,更新文档

$set 修改器:指定一个字段值,如果该字段不存在,则创建它

db.集合名.update(查询文档,修剪文档器)

db.集合名.update({条件},{$set:{"x":30}}) #把集合中符合条件的文档的"x"的键值修改为30

db.集合名.update({条件},{$set:{"x":[1,2,3,4]}}) #把集合中符合条件的文档的"x"的键值修改为[1,2,3,4]

$unset 将某个键完全删除

db.集合名.update({条件},{$unset:{"x":1}}) #删除符合条件的"x"键

$inc 增加已有的键的值，若该键不存在的话，就创建一个

db.集合名.update({条件},{$inc:{"x":20}}) #把集合中符合条件的文档的"x"的键值自增长20

$push 向集中的文档中的数组中添加元素

db.集合名.update({条件},{$push:{"x":'y'}}) #把符合条件的文档的键为"x"的元组中添加元素y

$pop 从数组中任何一端删除元素

db.集合名.update({条件},{$pop:{"key":1/-1}}) 

当为1时删除元组中的末尾元素，当为-1时删除元组中的首位2元素

$pull 根据具体条件删除元组信息

db.集合名.update({},{$pull:{"x":"y"}}) #删除元组"x"中元素y

----------------------------------分割线------------------------------------

集合查询的其他操作

db.集合名.find({},{"_id":1,"key":1/-1}) 

#查询显示当文档中的键设为1为显示,0为隐藏 "_id"默认显示 key的默认是不显示

limet() skip() sort()

db.集合名.find().pretty().limit(x)  #把集合的前x个文档显示出来

db.集合名.find().pretty().skip(y)  #跳过开头y个文档显示

db.集合名.find().pretty().sort("key":1/-1) #根据键的值进行升序(1)和降序(-1)排列显示

$all 多个元素匹配数组

db.集合名.find({"key"{$all:["x","y"...]}}).pretty() #查询键值元组中同时有"x","y"...元素的文档

$size 查询特定长度的数组

db.集合名.find({"key":{$size:x}}) #查询键值元组中元素有x个的文档

$slice 返回某个键值的数组元素的一个子集

db.集合名.find({条件},{"key":{$slice:x/-x/[x,y]}}) 

返回符合条件的文档,键值元组的前x个元素组成的元组/键值元组的后x个元素的组成的元组/键值元组的x到y位置的元素组成的元组 

文本搜索：
首先要在想要搜索的key的键值设置文本连接

db.集合名.createIndex({"key":"text","key":"text",...}) #key的键值为字符串

设置文本连接查询 有这个设置才能使用文本搜索

$text $search

db.集合名.find({$text:{$search:"x y -z ..."}})  #查询文本连接中包含"x"/"y"...同时不包含z的文档信息

注:使用$text和$search,可以忽略字符串的大小问题 用"-"表示不包含

db.集合名.find({$text:{$search:"x \"y z\"}})  #查询文档连接中包含"x"或者包含"y z"的文档

$score $meta

db.集合名.find({文本搜索},{$score:{$meta:"textScore"}}).sort({$score:{$mate:"textScore"}}) 

#{$score{$meta:"textScore"}} 是匹配度的分数 按照匹配度的分数降序排列

$elemMatch 查询内嵌文档

db.集合名.find({"key":{$elemMatch:{"key":1,"key":2,...}}}).pretty()

#查询key键值元组中各个文档中的key:1的或者key:2的...的文档 

                                   ||

db.集合名.find("key.key":1,"key.key":2,....).pretty()

修改内嵌文档元素

db.集合名.update({条件},{$set:{"key.x.key":1}}) 把条件下的键值数组的 第x位的 内嵌文档的 键值修改为1

修改全部的内嵌文档元素

db.集合名.update({条件},{$set:{"key.$.key":1}},{multi:true}) 把条件下的键值数组的 全部 内嵌文档的 键值修改为1

db.集合名.update({查询条件},{修改内容},{同一修改})

管道操作符

注:{匹配条件} 可以省略 省略就是全档查询 

$match 匹配状态

db.集合名.aggregate({$match:{"key":x}}) #匹配键值为x的文档

$group 匹配分组

$sum 匹配求和

db.集合名.aggregate({匹配条件},{$group:{"_id":"$key1",sums:{$sum:"$key2"}}})

#以key1键值分组(相同的一组),并求出key2键值的和 (sums为显示的键)

$group 匹配分组

$avg 匹配求平均值

db.集合名.aggregate({匹配条件},{$group:{"_id":"$key1",avgs:{$avg:"$key2"}}})

#以key1键值分组(相同的一组),并求出key2键的平均值 (avgs为显示的键)

$project 重塑文档结构

db.集合名.aggregate([{匹配条件},{$project:{"key":1/0,"_id":0,...}}]) #显示key:1的 当key:0时隐藏

$unwind 把数组中的元素逐个展示,一个文档转为多个文档

db.集合名.aggregate([{匹配条件},{$unwind:"$key"}]) #键值元组逐个显示形成多个文档

$sort 文档排序 1:升序 -1:降序

db.集合名.aggregate([{匹配条件},{$sort:{"key":1}}]) #以key的键值来升序排列

$limit 显示文档显示的数量
db.集合名.aggregate([{匹配条件},{$limit:x}}]) #显示x个匹配文档

$skip 跳过开始的几个文档

db.集合名.aggregate([{匹配条件},{$skip:x}}]) #跳过开头的x个匹配文档

$lookup 连接显示

db.集合名1.aggregate([{匹配条件}, {$lookup:{from:"集合2",localField:"集合1的key",foreignField:"集合2的key",

as:"key"}}])

注：集合1的key值和集合2的键值有相同的 连接显示集合1和集合2 as后是更新名字显示

$cond

db.集合名.aggregate([{匹配条件},{$project:{"key":{$cond:{if:{布尔表达式},then:"x",else:"y"}}}}])

匹配条件中符合布尔表达式的增加键及键值x,不符合的增加键和键值y

注:if后一定要有then和else

$setIntersection #返回数组中的相同部分 一个文档中

db.集合名.aggregate([{匹配条件},{$project:{"key":{$setIntersection:["$key1","$key2"]}}}])

$redact 编排文档 操作数据

db.集合名.aggregate({匹配条件},{$redact:{$cond:{if:{布尔表达式},then:"$$DESCEND",else:"$$PRUNE"}}})

#把符合的条件结果显示出来

注:$redact通常和$cond一起用

$$DESCEND #表示符合条件的文档显示出来

$$PRUNE #表示不符合条件的文档剔除

map-reduce函数

db.集合1.mapReduce(

 function(){emit(this.key1,this.key2,...)},

 function(key,values){return Array.sum(values)},

 {quert:{搜索条件},

out:"集合2"})

把集合1中的key1,key2进行映射 映射到key和values中

Array.sum(valuse) 在进行数组求和

把集合1的key1作为集合2的id 把集合1的key2中的数字元素相加形成value:元素总和

第一步:query ;第二步map(映射),就是emit函数;第三步:reduce(化简把元组中的元素化简为一个元素)

count()

db.集合名.count() #查询集合中有多少文档

distinct()

db.集合名.distinct("key") #显示文档中所有key的不相同的键值