mongodb入门
2017-06-11 16:17
134 查看
学了一学期的内容整理一下
我们用的教材是人民邮电出版社出版的mongodb入门经典
复习是按照书上内容来的
mongodb真的是个很强大的数据储存和分析工具，它集储存管理分析于一身，用起来简单，都是对象.方法，而且效率还很高
可是国内似乎并没多少公司在用它，暂时应该不会再学习它了
2章
关闭数据库引擎
use admin
db.shutdownServer()
显示数据库清单
show dbs
执行脚本的方法
load()
*******************************************************
4章
创建用户
db.createUser({})
必选
user:"用户名"
roles:["",""]
pwd/userSource二选一，一般pwd:"密码"
可选
otherDBRoles:{数据库:["",""]}
用来指定用户在其他数据库中的角色
roles的值(课本提到的):
1，数据库用户角色
read,readWrite:读/读写
2，数据库管理角色
dbAdmin,userAdmin:管理文档/管理用户
上面的加AnyDatabase对所有数据库生效
3，集群管理角色
clusterAdmin:一般说到集群，就只有这个有权限
4，超级用户
root
列出用户
show users
删除用户
db.dropUser("用户名") //根据属性删的只有它，其他都是指定对象然后调用删除的方法
************************************************************
5章
这里先了解下mongodb
数据是这样存放的 数据库（集合（文档））
mongodb本身创建了一些对象，对这些对象提供了操作方法
分别是：
服务器对象：connection P67
数据库：database P68
集合：collection P69
集合的一些操作返回的对象：cursor P84
使用方法时先确定对象有这个方法，调用方式就跟java一样
所以写shell脚本时要先用实例化一个connection对象，用getDB()方法来获取数据库对象，执行操作
最后会总结一下这几个对象常用的方法，先开始第五章
第五章主要讲的是database对象和collection对象基本方法的使用，
这个对象的方法使用时先要指明对象db
创建数据库
mongodb没有直接创建数据库的方法，可以通过声明一个数据库句柄，给里面加一个空集合来实现
use 数据库
db.createCollection("集合名")
删除数据库
use 数据库
db.dropDatabase() //use了一个库，db代表的就是这个库对象
创建集合
db.createCollection("名字",可选项)
可选项类型为集合{}
属性：
autoIndexID:布尔值 类似mysql创建一个自动增长的主键用来索引，默认为true，固定集合应关掉它
capped:布尔值 是否创建固定集合，默认false
size:int 集合大小
max:int 最大文档数
这三项都是创固定集合用的，一般不用
给个例子：db.createCollection("haha",{capped:true,size:20,max:20},{autoIndexID:false})
删除集合
db.集合.drop() //这里有些奇怪，集合像是库的一个属性(也许真的是)，但就是能这么获取集合对象
查看集合（我加了一种）
show collections
db.getCollectionNames() //db对象提供的，返回是一个数组，js中就可以继续处理它
这里补下添加文档的方法，书上第八章才讲
db.集合.insert(文档)
文档的格式时对象{}，如果插入多个应用数组打包他们
给个例子： db.haha.insert([{name:"li",age:19},{name:"xiang",age:20}])
******************************************************************
6章
第六章讲的是查询，就是sql里的select，重要性不用说
find(query,projection) //查询并返回一个cursor对象，该对象有一堆方法来对查询结果进行加工
findOne(query,projection) //查询并返回一个文档，注意是 一个 文档
query 可选，用来对查询进行限制，具体书上P85，一会会在最后具体介绍有哪些
projection 可选，控制返回信息，对返回结果进行限制
放到sql就是
select projection where query
虽然select是对表内容操作而这里是对集合文档操作，但意义一样
看懂了上面，接下来实现具体功能就好理解了，要记的就是query运算符，query也是一个对象形式
当一个键值对作为属性时，肯定是对象形式，不会出现a：b：c的形式或a:[b:c,d:e],参考json
应该是这样的a:{b:c}或a:[{b:c,d:e}],json对象的属性可以是单个值，对象或数组
先写个集合，对它进行操作
db.hehe.insert([{name:"li",age:[{first:1,second:9}],height:190},{name:"xiang",age:[{first:2,second:0}],height:200}])
db.hehe.insert([{name:"li",age:{first:1,second:9},height:190},{name:"xiang",age:{first:2,second:0},height:200}])
看功能，结合书上P85
查看所有文档
db.集合.find()
db.hehe.find()
根据特定字段值查找文档 $ne:int/string
db.集合.find({字段：值})
db.hehe.find({name:"li"})
根据字段值数组 $in:[] $nin $all
db.集合.find({字段：{$in：[值1，值2]}})
db.hehe.find({name:{$in:["li","xiang"]}})
根据字段值大小 $gt:int $lt $gte $lte $or:[query，query]用或语句连接条件 $and且语句 $not非
db.hehe.find({height:{$gt:190}})
db.hehe.find({$or:[{height:{$gt:190}},{height:{$lt:210}}]})
根据数组字段长度$size:int
db.hehe.find({age:{$size:1}}) 可看出size指的是数组的元素数
根据子文档的值查找 .语法，这里属性要加""
db.hehe.find({"age.first":{$gt:0}})
根据字段是否存在 $exists:布尔值
db.hehe.find({name:{$exists:true}})
根据子文档数组中字段$elemMatch
db.hehe.find({age:{$elemMatch:{first:1}}})
db.hehe.find({"age.first":1}) 这俩对比一下区别
最后说个比较重要书上却没有提的 $regex：正则表达式 //支持两种格式
像sql语句就提供了通配符来实现模糊查询，而mongodb模糊查询通过正则表达式实现
db.hehe.find({name:{$regex:'g'}}) 包含g
db.hehe.find({name:{$regex:'^x.*g$'}}) x开头g结尾
db.hehe.find({name:{$regex:/g/}})
db.hehe.find({name:{$regex:/^x.*g$/}})
限制结果集返回的字段(书上在第七章才说)
前面说的都是第一个参数，现在来看第二个参数的作用
db.hehe.find({name:{$regex:/^x.*g$/}},{_id:false,age:false})
***********************************************************************************
7章
第七章主要讲find()方法返回的cursor对象的方法，这个表在第六章却第七章才开始讲
这个对象的常用方法会在最后给出
先从功能来学习，结合书上P84
计算文档数，准确说是返回的文档数
db.hehe.find().count()
结果集排序 sort(sortObj) 字段：1/-1 1升-1降
db.hehe.find().sort({name:1,height:-1}) 字符串应该是按首字母字典排序（猜）
限制返回文档数
db.hehe.find().limit(1)
结果分页
db.hehe.find().sort({name:1}).limit(2).skip(0)
db.hehe.find().sort({name:1}).limit(2).skip(2) 分两次
cursor的方法大部分都是返回cursor对象的，也就说可以多次处理sort()完还能limit()
最后突然提到了collection对象的distinct()方法，sql里也有它，就是去重
distinct(key,query)
key即字段
query就是我们在前面学的查询限制符
和sql不一样的是，它不是cursor对象，而是和find()一样的存在，所以为了能使它在去重后能特定查询，给它加了query这个参数
但和find()不同的是，他和findOne()一样，返回的是一个数组，且只返回去重的那列
db.hehe.distinct("name",{height:190})
*******************************************************************************
8章
第八章才教增删改，前面想用自己数据操作都不会插入，只能用给的字母集，坑
增前面说了
现在说改和删，还是用刚刚的例子
重要考点
update(query,updata,upsert,multi)P120
query 前面提到的查询限制符
upsert 布尔值，true,如果没匹配到文档就创个新的，任性
multi 布尔值，true，更新所有匹配到的，false，只更新第一个
update 对象，里面是要更新的内容，结合运算符实现P116，用法跟query很像，
其中query和update是必选，upsert,multi默认是false,应该是为了数据完整性考虑，默认最小程度破坏原始数据，不添加，只改一个
这块记得老师当时讲了两节课，几乎讲了所有运算符，书上没好好讲这
自己来总结功能,同样是collection的方法
$inc //课本就给了加，其他三个在哪见过忘了
db.hehe.update({},{$inc:{height:1}})
$rename //重命名
db.hehe.update({},{$rename:{name:"name1"}}) db.hehe.update({},{$rename:{name1:"name"}})改回来
$set //设置字段值，修改一个已经有的，如果没就新加一个字段
db.hehe.update({},{$set:{height1:1}}) db.hehe.update({},{$set:{height:1}})
$unset //删除字段
db.hehe.update({},{$unset:{height1:""}}) 这里就和set一样，值写""（测试写啥都会被删掉，但不能为空），
工程师偷懒了，不该是这样吗db.hehe.update({},{$unset:"height1"})
/////////////////////////////分割 前面是对普通字段操作，下面是对嵌套字段的操作
d94c
$addToSet //给数组里添单个不重复的字段
db.hehe.update({},{$addToSet:{age:"new"}}) //这也是json数组容器的特点，里面的元素不需要相同的格式
db.hehe.update({},{$addToSet:{age:{third:"new"}}})
$pushAll //给数组添加多个字段
db.hehe.update({},{$pushAll:{age:[{four:"old"},"old"]}})
乍一看语法是一样，区别在于
1，addToSet只能插单个值
db.hehe.update({},{$addToSet:{age:[{third:"new"},"5"]}}) //它和push一样都会把这个数组当作元素插到数组里
2，addToSet只在数组里没有这个值时插入，push会重复插入
注意，匹配数组时，如果没有这个数组，会新建一个数组
$push //给数组添加单个字段
上面的数组换成单个值
$pop //删除第一个元素或最后一个元素
db.hehe.update({},{$pop:{age:-1}})
$pullAll //删除多个元素，语法和pushAll()一样
$pull
你猜
$each
对addToSet和push的值进行加工，
用法分两步
先写基本的插入db.hehe.update({name:"xiang"},{$addToSet:{age:}}) //这里本该写要查的元素,上面说了，如果元素写成数组的形式，会把它当成整体插进去
再写db.hehe.update({name:"xiang"},{$addToSet:{age:{$each:["4","5"]}}})
要实现像pushAll那样添加多个元素，就要使用$each,这样addToSet也能插入多个了，至于push，用这个也行，但哪有pushAll好用
///////////////////////////////分割，刚刚是更新数组，最后来学更新对象
db.hehe.update({name:"xiang"},{$set:{age:{first:3}}})如果直接这么些，显然，不会把first值改为3，而是把age值改为{first:3}
db.hehe.update({name:"xiang"},{$set:{age:{first:1,second:3}}}) 先改回去
db.hehe.update({name:"xiang"},{$set:{"age.first":3}}) 其实在find()里也说过这个
$slice$sort，老师当时没讲,用法和$each类似，$bit，没讲
学完了这些，可以看出update其实是对三种类型进行更新 a:b a:[b] a:{a:b} 如果是a:[{a:b}],就将12两种类型复合起来，先找到建（例如age），才能改值
至此update结束
collection对象提供了还save()方法来实现插入和更新 //不重要
save的参数和insert一样，一个文档，它把一个新文档插入当前的集合，如果文档不存在就插入，存在就更新，语法和insert一样
最后说说删除
collection对象提供了两种删除
remove()和drop()
drop()和前面的dropDatabase()一样，直接删对象指向的内存，所以用了他集合就没了，索引什么也没了
remove(query,justone)
query说多少遍了不说了
justone和单词意思一样，删一个还是删全部，默认false删全部 //这里怎么不考虑保护数据了。。
****************************************************************************
9章
讲了collection对象的三个方法
group()提供一种基本聚合，根据指定的字段将文档分组
aggregate()让你能够访问聚合流水线
mapReduce()提供映射-归并聚合功能
group(key,cond，initial，reduce，finalize，keyf)
group(键，query，对象，函数1，函数2，函数3)
其中键，对象，函数1为必选，
键：用来分组的键 格式为key:{键:1}，可以有多个键//得到obj
对象：一个初始group对象，格式就是一个文档，最后输出的内容就是在它基础上的 //得到prev
函数1：固定的两个参数，一个指初始文档，一个指向刚刚创建的初始对象，加工原文档把结果给新对象，并返回这个对象 function(obj,prev)
函数2可以接受函数1返回的对象(俩obj不一样)，加工它的值，给对象加入新的列，再返回一个对象 function(obj）函数1和函数2的对象都是直接输出的
query对结果集进行限制，用法和前面一样
函数3用来代替键，但函数3返回值必须是用来分组的键
这个方法是对原集合一个文档一个文档遍历的，所以函数里算法应该按照这个写
看着很复杂，来写一个简单的例子
数据
db.createCollection("test")
db.test.insert([{number:1,value:100},{number:1,value:200},{number:2,value:300},{number:3,value:400}])
操作
按number分组，统计一下value的和，再把结果合并
如果理解了上面说的，就可以看出这三个要求分别对应key，函数1，函数2
db.test.group({key:{:1},initial:{},reduce:function(obj,prev){},finalize:function(obj){}})先写出需要的格式，避免掉括号
db.test.group({key:{number:1},initial:{value:0},reduce:function(obj,prev){prev.value+=obj.value},finalize:function(obj){obj.count=obj.number+obj.value}})
能看出函数2操作的是函数1返回的结果，如果不需要对这个结果操作，那么省略函数2就行
aggregate(operator,[operator],[...])
[operatra]是一堆聚合运算符，有哪些最后会列出，太多了希望不考
其实比上面的简单，就是对原文档用聚合运算符多次加工
操作
输出前两个文档并根据value倒序排序
db.test.aggregate({$limit:2},{$sort:{value:-1}})
其中$group有自己一堆运算符，先写个例子
db.test.aggregate({$group:{_id:"$number"}}) _id必须写，主键，这里其实就是在根据主键分组
db.test.aggregate({$group:{_id:"$number",values:{$sum:"$value"}}}) 统计value
mapReduce(map,reduce,arguments)
mapReduce(函数1，函数2，输出类型)
三个参数都是必须的
函数1：使用emit(key，value)对原始集合每个文档都执行一次它生成一个键值对，值是数组形式，组成一堆对象返回 //function(){}
函数2；对函数1返回的每个对象都执行一次它，参数就是对象的键和值 //function(key,values){}
输出类型：是一个对象，用来指定输出到哪，一般就{out:{inline:1}}，把返回值在shell里打印出来
这里函数是直接写的，不用像group作为键的值，所以要有return
固定格式
db.test.mapReduce(function(){emit(this.,this.)},function(key,values){},{out:{inline:1}})
操作
还是统计value
db.test.mapReduce(function(){emit(this.number,this.value)},function(key,values){b=0;for(i=0;i<values.length;i++){b=b+values[i]}result={number:key,value:b};return result;},{out:{inline:1}})
解释下第一个函数的结果
函数1对集合里每个文档获取你设置的key和value，如果key相同，就把value加到values数组里，emit(key，value)这个函数只能写两个参
运行完应该是三个对象{1:[100,200]}{2:300}{3:400} 1就是设置的this.number,[100,200]就是他的值
函数2就是把1传给key，把[100,200]传给values，参数知道了怎么操作随你
输出类型的可选参数
out：必选一般{out:{inline:1}}
query：和前面一样，对结果限制
sort：对结果排序
limit：限制返回条数
finalize：和group里一样
*********************************************************************************************
后面几章是java操作，按实验来复习
固定格式
Mongo mg=new Mongo("127.0.0.1:27017");
相当于实例化一个connection对象，参数是当时配的端口
DB db=mg.getDB("数据库")
用getDB(string)获取一个database对象，参数是数据库名
DBCollection test=db.getCollection("集合名")
用getCollection()获取一个collection对象
剩下的和shell里语法很像
比如
getDatabaseNames() 返回一个数组，元素是所有数据库名
getCollectionNames()和前面说的一样，返回的是一个所有集合名数组
db对象的 对应shell
getDatabaseNames(string) //show databases
dropDatabase() //dropDatabase()
addUser(string,char[]) //createUser()
authenticate(string,char[]) //auth()
removeUser(string) //dropUser()
createCollection(string,DBobject) //createCollection()
参数基本都一样
collection对象的
getCollectionNames(string) //show collections
find() //find()里的运算符是DBObject形式的一样的
findOne()
drop()
insert()
remove()
save()
update()
会这几个就行，和shell用法一样
下面说两个对象
DBObject
对应的格式{}
DBObject dbo=new BasicDBObject()
List<T>
对应的格式[T] T可以是各种格式
List<String> list=new ArrayList<String>()
利用它来构成需要的文档格式，作为参数给上面的方法
和find()方法返回的对象DBcursor
DBCursor cur=test.find() 来获得它
一样是那四个方法
count()
limit(int)
skip(int)
sort(DBObject orderBy)
这里给个例子，课后题p166和p186的
public class test {
public static void main(String[] args)throws MongoException, UnknownHostException{
Mongo mg =new Mongo("127.0.0.1:27017");
DB db =mg.getDB("words");
DBCollection users=db.getCollection("word_stats");
DBCursor cur=users.find();
DBObject dbs=new BasicDBObject();
dbs.put("_id", -1);
cur=cur.sort(dbs);
System.out.println("1:"+JSON.serialize(cur));
dbs.put("last", -1);
cur=cur.sort(dbs);
System.out.println("2:"+JSON.serialize(cur));//p166 1
DBObject dbs1=new BasicDBObject();
dbs1.put("$regex", "^a.*e$");
dbs.put("word",dbs1);
DBCursor cur1=users.find(dbs);
System.out.println("3:"+JSON.serialize(cur1));//p166 2
dbs1.put("$regex", "^n");
dbs.put("word",dbs1);
DBCursor cur2=users.find(dbs);
dbs.put("size", -1);
cur=cur.sort(dbs);
cur=cur.limit(5);
System.out.println("4:"+JSON.serialize(cur2));//p186 1
}}
JSON.serialize(cur2)是转化字符串的
到这里就复习完了
下面总结上面提到的方法和运算符，只写方法名，可以测试记住了没
shell基本命令
use
show dbs(databases也行)/collections/users
database对象
createUser() doc{user pwd roles}
auth() str用户 str密码
createCollection() str options
dropDatabase()
getCollectionNames()
dropUser() str用户
collection对象
aggregate()
count()
distinct() str列 query
drop()
find() query projection
findOne() query projection
group(） db.test.group({key:{:1},initial:{},reduce:function(obj,prev){},finalize:function(obj){}})
insert() doc
mapReduce() mapReduce(function(){emit(this.,this.)},function(key,values){},{out:{inline:1}})
remove() query boolean
save() doc
update() query update boolean boolean
cursor对象
count()
limit() int
skip() int
sort() {str列:int}
query运算符
$gt/$gte
$in/$nin
$lt/$lte
$ne
$or/$and/$not
$exists
$regex
$size
$elemMatch/$all
update运算符
$inc
$rename
$set
$unset
$addToSet
$push/$pushAll
$pull/$pullAll
$each
$pop
聚合运算符
$project
$match
$limit
$skip
$group
我们用的教材是人民邮电出版社出版的mongodb入门经典
复习是按照书上内容来的
mongodb真的是个很强大的数据储存和分析工具，它集储存管理分析于一身，用起来简单，都是对象.方法，而且效率还很高
可是国内似乎并没多少公司在用它，暂时应该不会再学习它了
2章
关闭数据库引擎
use admin
db.shutdownServer()
显示数据库清单
show dbs
执行脚本的方法
load()
*******************************************************
4章
创建用户
db.createUser({})
必选
user:"用户名"
roles:["",""]
pwd/userSource二选一，一般pwd:"密码"
可选
otherDBRoles:{数据库:["",""]}
用来指定用户在其他数据库中的角色
roles的值(课本提到的):
1，数据库用户角色
read,readWrite:读/读写
2，数据库管理角色
dbAdmin,userAdmin:管理文档/管理用户
上面的加AnyDatabase对所有数据库生效
3，集群管理角色
clusterAdmin:一般说到集群，就只有这个有权限
4，超级用户
root
列出用户
show users
删除用户
db.dropUser("用户名") //根据属性删的只有它，其他都是指定对象然后调用删除的方法
************************************************************
5章
这里先了解下mongodb
数据是这样存放的 数据库（集合（文档））
mongodb本身创建了一些对象，对这些对象提供了操作方法
分别是：
服务器对象：connection P67
数据库：database P68
集合：collection P69
集合的一些操作返回的对象：cursor P84
使用方法时先确定对象有这个方法，调用方式就跟java一样
所以写shell脚本时要先用实例化一个connection对象，用getDB()方法来获取数据库对象，执行操作
最后会总结一下这几个对象常用的方法，先开始第五章
第五章主要讲的是database对象和collection对象基本方法的使用，
这个对象的方法使用时先要指明对象db
创建数据库
mongodb没有直接创建数据库的方法，可以通过声明一个数据库句柄，给里面加一个空集合来实现
use 数据库
db.createCollection("集合名")
删除数据库
use 数据库
db.dropDatabase() //use了一个库，db代表的就是这个库对象
创建集合
db.createCollection("名字",可选项)
可选项类型为集合{}
属性：
autoIndexID:布尔值 类似mysql创建一个自动增长的主键用来索引，默认为true，固定集合应关掉它
capped:布尔值 是否创建固定集合，默认false
size:int 集合大小
max:int 最大文档数
这三项都是创固定集合用的，一般不用
给个例子：db.createCollection("haha",{capped:true,size:20,max:20},{autoIndexID:false})
删除集合
db.集合.drop() //这里有些奇怪，集合像是库的一个属性(也许真的是)，但就是能这么获取集合对象
查看集合（我加了一种）
show collections
db.getCollectionNames() //db对象提供的，返回是一个数组，js中就可以继续处理它
这里补下添加文档的方法，书上第八章才讲
db.集合.insert(文档)
文档的格式时对象{}，如果插入多个应用数组打包他们
给个例子： db.haha.insert([{name:"li",age:19},{name:"xiang",age:20}])
******************************************************************
6章
第六章讲的是查询，就是sql里的select，重要性不用说
find(query,projection) //查询并返回一个cursor对象，该对象有一堆方法来对查询结果进行加工
findOne(query,projection) //查询并返回一个文档，注意是 一个 文档
query 可选，用来对查询进行限制，具体书上P85，一会会在最后具体介绍有哪些
projection 可选，控制返回信息，对返回结果进行限制
放到sql就是
select projection where query
虽然select是对表内容操作而这里是对集合文档操作，但意义一样
看懂了上面，接下来实现具体功能就好理解了，要记的就是query运算符，query也是一个对象形式
当一个键值对作为属性时，肯定是对象形式，不会出现a：b：c的形式或a:[b:c,d:e],参考json
应该是这样的a:{b:c}或a:[{b:c,d:e}],json对象的属性可以是单个值，对象或数组
先写个集合，对它进行操作
db.hehe.insert([{name:"li",age:[{first:1,second:9}],height:190},{name:"xiang",age:[{first:2,second:0}],height:200}])
db.hehe.insert([{name:"li",age:{first:1,second:9},height:190},{name:"xiang",age:{first:2,second:0},height:200}])
看功能，结合书上P85
查看所有文档
db.集合.find()
db.hehe.find()
根据特定字段值查找文档 $ne:int/string
db.集合.find({字段：值})
db.hehe.find({name:"li"})
根据字段值数组 $in:[] $nin $all
db.集合.find({字段：{$in：[值1，值2]}})
db.hehe.find({name:{$in:["li","xiang"]}})
根据字段值大小 $gt:int $lt $gte $lte $or:[query，query]用或语句连接条件 $and且语句 $not非
db.hehe.find({height:{$gt:190}})
db.hehe.find({$or:[{height:{$gt:190}},{height:{$lt:210}}]})
根据数组字段长度$size:int
db.hehe.find({age:{$size:1}}) 可看出size指的是数组的元素数
根据子文档的值查找 .语法，这里属性要加""
db.hehe.find({"age.first":{$gt:0}})
根据字段是否存在 $exists:布尔值
db.hehe.find({name:{$exists:true}})
根据子文档数组中字段$elemMatch
db.hehe.find({age:{$elemMatch:{first:1}}})
db.hehe.find({"age.first":1}) 这俩对比一下区别
最后说个比较重要书上却没有提的 $regex：正则表达式 //支持两种格式
像sql语句就提供了通配符来实现模糊查询，而mongodb模糊查询通过正则表达式实现
db.hehe.find({name:{$regex:'g'}}) 包含g
db.hehe.find({name:{$regex:'^x.*g$'}}) x开头g结尾
db.hehe.find({name:{$regex:/g/}})
db.hehe.find({name:{$regex:/^x.*g$/}})
限制结果集返回的字段(书上在第七章才说)
前面说的都是第一个参数，现在来看第二个参数的作用
db.hehe.find({name:{$regex:/^x.*g$/}},{_id:false,age:false})
***********************************************************************************
7章
第七章主要讲find()方法返回的cursor对象的方法，这个表在第六章却第七章才开始讲
这个对象的常用方法会在最后给出
先从功能来学习，结合书上P84
计算文档数，准确说是返回的文档数
db.hehe.find().count()
结果集排序 sort(sortObj) 字段：1/-1 1升-1降
db.hehe.find().sort({name:1,height:-1}) 字符串应该是按首字母字典排序（猜）
限制返回文档数
db.hehe.find().limit(1)
结果分页
db.hehe.find().sort({name:1}).limit(2).skip(0)
db.hehe.find().sort({name:1}).limit(2).skip(2) 分两次
cursor的方法大部分都是返回cursor对象的，也就说可以多次处理sort()完还能limit()
最后突然提到了collection对象的distinct()方法，sql里也有它，就是去重
distinct(key,query)
key即字段
query就是我们在前面学的查询限制符
和sql不一样的是，它不是cursor对象，而是和find()一样的存在，所以为了能使它在去重后能特定查询，给它加了query这个参数
但和find()不同的是，他和findOne()一样，返回的是一个数组，且只返回去重的那列
db.hehe.distinct("name",{height:190})
*******************************************************************************
8章
第八章才教增删改，前面想用自己数据操作都不会插入，只能用给的字母集，坑
增前面说了
现在说改和删，还是用刚刚的例子
重要考点
update(query,updata,upsert,multi)P120
query 前面提到的查询限制符
upsert 布尔值，true,如果没匹配到文档就创个新的，任性
multi 布尔值，true，更新所有匹配到的，false，只更新第一个
update 对象，里面是要更新的内容，结合运算符实现P116，用法跟query很像，
其中query和update是必选，upsert,multi默认是false,应该是为了数据完整性考虑，默认最小程度破坏原始数据，不添加，只改一个
这块记得老师当时讲了两节课，几乎讲了所有运算符，书上没好好讲这
自己来总结功能,同样是collection的方法
$inc //课本就给了加，其他三个在哪见过忘了
db.hehe.update({},{$inc:{height:1}})
$rename //重命名
db.hehe.update({},{$rename:{name:"name1"}}) db.hehe.update({},{$rename:{name1:"name"}})改回来
$set //设置字段值，修改一个已经有的，如果没就新加一个字段
db.hehe.update({},{$set:{height1:1}}) db.hehe.update({},{$set:{height:1}})
$unset //删除字段
db.hehe.update({},{$unset:{height1:""}}) 这里就和set一样，值写""（测试写啥都会被删掉，但不能为空），
工程师偷懒了，不该是这样吗db.hehe.update({},{$unset:"height1"})
/////////////////////////////分割 前面是对普通字段操作，下面是对嵌套字段的操作
d94c
$addToSet //给数组里添单个不重复的字段
db.hehe.update({},{$addToSet:{age:"new"}}) //这也是json数组容器的特点，里面的元素不需要相同的格式
db.hehe.update({},{$addToSet:{age:{third:"new"}}})
$pushAll //给数组添加多个字段
db.hehe.update({},{$pushAll:{age:[{four:"old"},"old"]}})
乍一看语法是一样，区别在于
1，addToSet只能插单个值
db.hehe.update({},{$addToSet:{age:[{third:"new"},"5"]}}) //它和push一样都会把这个数组当作元素插到数组里
2，addToSet只在数组里没有这个值时插入，push会重复插入
注意，匹配数组时，如果没有这个数组，会新建一个数组
$push //给数组添加单个字段
上面的数组换成单个值
$pop //删除第一个元素或最后一个元素
db.hehe.update({},{$pop:{age:-1}})
$pullAll //删除多个元素，语法和pushAll()一样
$pull
你猜
$each
对addToSet和push的值进行加工，
用法分两步
先写基本的插入db.hehe.update({name:"xiang"},{$addToSet:{age:}}) //这里本该写要查的元素,上面说了，如果元素写成数组的形式，会把它当成整体插进去
再写db.hehe.update({name:"xiang"},{$addToSet:{age:{$each:["4","5"]}}})
要实现像pushAll那样添加多个元素，就要使用$each,这样addToSet也能插入多个了，至于push，用这个也行，但哪有pushAll好用
///////////////////////////////分割，刚刚是更新数组，最后来学更新对象
db.hehe.update({name:"xiang"},{$set:{age:{first:3}}})如果直接这么些，显然，不会把first值改为3，而是把age值改为{first:3}
db.hehe.update({name:"xiang"},{$set:{age:{first:1,second:3}}}) 先改回去
db.hehe.update({name:"xiang"},{$set:{"age.first":3}}) 其实在find()里也说过这个
$slice$sort，老师当时没讲,用法和$each类似，$bit，没讲
学完了这些，可以看出update其实是对三种类型进行更新 a:b a:[b] a:{a:b} 如果是a:[{a:b}],就将12两种类型复合起来，先找到建（例如age），才能改值
至此update结束
collection对象提供了还save()方法来实现插入和更新 //不重要
save的参数和insert一样，一个文档，它把一个新文档插入当前的集合，如果文档不存在就插入，存在就更新，语法和insert一样
最后说说删除
collection对象提供了两种删除
remove()和drop()
drop()和前面的dropDatabase()一样，直接删对象指向的内存，所以用了他集合就没了，索引什么也没了
remove(query,justone)
query说多少遍了不说了
justone和单词意思一样，删一个还是删全部，默认false删全部 //这里怎么不考虑保护数据了。。
****************************************************************************
9章
讲了collection对象的三个方法
group()提供一种基本聚合，根据指定的字段将文档分组
aggregate()让你能够访问聚合流水线
mapReduce()提供映射-归并聚合功能
group(key,cond，initial，reduce，finalize，keyf)
group(键，query，对象，函数1，函数2，函数3)
其中键，对象，函数1为必选，
键：用来分组的键 格式为key:{键:1}，可以有多个键//得到obj
对象：一个初始group对象，格式就是一个文档，最后输出的内容就是在它基础上的 //得到prev
函数1：固定的两个参数，一个指初始文档，一个指向刚刚创建的初始对象，加工原文档把结果给新对象，并返回这个对象 function(obj,prev)
函数2可以接受函数1返回的对象(俩obj不一样)，加工它的值，给对象加入新的列，再返回一个对象 function(obj）函数1和函数2的对象都是直接输出的
query对结果集进行限制，用法和前面一样
函数3用来代替键，但函数3返回值必须是用来分组的键
这个方法是对原集合一个文档一个文档遍历的，所以函数里算法应该按照这个写
看着很复杂，来写一个简单的例子
数据
db.createCollection("test")
db.test.insert([{number:1,value:100},{number:1,value:200},{number:2,value:300},{number:3,value:400}])
操作
按number分组，统计一下value的和，再把结果合并
如果理解了上面说的，就可以看出这三个要求分别对应key，函数1，函数2
db.test.group({key:{:1},initial:{},reduce:function(obj,prev){},finalize:function(obj){}})先写出需要的格式，避免掉括号
db.test.group({key:{number:1},initial:{value:0},reduce:function(obj,prev){prev.value+=obj.value},finalize:function(obj){obj.count=obj.number+obj.value}})
能看出函数2操作的是函数1返回的结果，如果不需要对这个结果操作，那么省略函数2就行
aggregate(operator,[operator],[...])
[operatra]是一堆聚合运算符，有哪些最后会列出，太多了希望不考
其实比上面的简单，就是对原文档用聚合运算符多次加工
操作
输出前两个文档并根据value倒序排序
db.test.aggregate({$limit:2},{$sort:{value:-1}})
其中$group有自己一堆运算符，先写个例子
db.test.aggregate({$group:{_id:"$number"}}) _id必须写，主键，这里其实就是在根据主键分组
db.test.aggregate({$group:{_id:"$number",values:{$sum:"$value"}}}) 统计value
mapReduce(map,reduce,arguments)
mapReduce(函数1，函数2，输出类型)
三个参数都是必须的
函数1：使用emit(key，value)对原始集合每个文档都执行一次它生成一个键值对，值是数组形式，组成一堆对象返回 //function(){}
函数2；对函数1返回的每个对象都执行一次它，参数就是对象的键和值 //function(key,values){}
输出类型：是一个对象，用来指定输出到哪，一般就{out:{inline:1}}，把返回值在shell里打印出来
这里函数是直接写的，不用像group作为键的值，所以要有return
固定格式
db.test.mapReduce(function(){emit(this.,this.)},function(key,values){},{out:{inline:1}})
操作
还是统计value
db.test.mapReduce(function(){emit(this.number,this.value)},function(key,values){b=0;for(i=0;i<values.length;i++){b=b+values[i]}result={number:key,value:b};return result;},{out:{inline:1}})
解释下第一个函数的结果
函数1对集合里每个文档获取你设置的key和value，如果key相同，就把value加到values数组里，emit(key，value)这个函数只能写两个参
运行完应该是三个对象{1:[100,200]}{2:300}{3:400} 1就是设置的this.number,[100,200]就是他的值
函数2就是把1传给key，把[100,200]传给values，参数知道了怎么操作随你
输出类型的可选参数
out：必选一般{out:{inline:1}}
query：和前面一样，对结果限制
sort：对结果排序
limit：限制返回条数
finalize：和group里一样
*********************************************************************************************
后面几章是java操作，按实验来复习
固定格式
Mongo mg=new Mongo("127.0.0.1:27017");
相当于实例化一个connection对象，参数是当时配的端口
DB db=mg.getDB("数据库")
用getDB(string)获取一个database对象，参数是数据库名
DBCollection test=db.getCollection("集合名")
用getCollection()获取一个collection对象
剩下的和shell里语法很像
比如
getDatabaseNames() 返回一个数组，元素是所有数据库名
getCollectionNames()和前面说的一样，返回的是一个所有集合名数组
db对象的 对应shell
getDatabaseNames(string) //show databases
dropDatabase() //dropDatabase()
addUser(string,char[]) //createUser()
authenticate(string,char[]) //auth()
removeUser(string) //dropUser()
createCollection(string,DBobject) //createCollection()
参数基本都一样
collection对象的
getCollectionNames(string) //show collections
find() //find()里的运算符是DBObject形式的一样的
findOne()
drop()
insert()
remove()
save()
update()
会这几个就行，和shell用法一样
下面说两个对象
DBObject
对应的格式{}
DBObject dbo=new BasicDBObject()
List<T>
对应的格式[T] T可以是各种格式
List<String> list=new ArrayList<String>()
利用它来构成需要的文档格式，作为参数给上面的方法
和find()方法返回的对象DBcursor
DBCursor cur=test.find() 来获得它
一样是那四个方法
count()
limit(int)
skip(int)
sort(DBObject orderBy)
这里给个例子，课后题p166和p186的
public class test {
public static void main(String[] args)throws MongoException, UnknownHostException{
Mongo mg =new Mongo("127.0.0.1:27017");
DB db =mg.getDB("words");
DBCollection users=db.getCollection("word_stats");
DBCursor cur=users.find();
DBObject dbs=new BasicDBObject();
dbs.put("_id", -1);
cur=cur.sort(dbs);
System.out.println("1:"+JSON.serialize(cur));
dbs.put("last", -1);
cur=cur.sort(dbs);
System.out.println("2:"+JSON.serialize(cur));//p166 1
DBObject dbs1=new BasicDBObject();
dbs1.put("$regex", "^a.*e$");
dbs.put("word",dbs1);
DBCursor cur1=users.find(dbs);
System.out.println("3:"+JSON.serialize(cur1));//p166 2
dbs1.put("$regex", "^n");
dbs.put("word",dbs1);
DBCursor cur2=users.find(dbs);
dbs.put("size", -1);
cur=cur.sort(dbs);
cur=cur.limit(5);
System.out.println("4:"+JSON.serialize(cur2));//p186 1
}}
JSON.serialize(cur2)是转化字符串的
到这里就复习完了
下面总结上面提到的方法和运算符，只写方法名，可以测试记住了没
shell基本命令
use
show dbs(databases也行)/collections/users
database对象
createUser() doc{user pwd roles}
auth() str用户 str密码
createCollection() str options
dropDatabase()
getCollectionNames()
dropUser() str用户
collection对象
aggregate()
count()
distinct() str列 query
drop()
find() query projection
findOne() query projection
group(） db.test.group({key:{:1},initial:{},reduce:function(obj,prev){},finalize:function(obj){}})
insert() doc
mapReduce() mapReduce(function(){emit(this.,this.)},function(key,values){},{out:{inline:1}})
remove() query boolean
save() doc
update() query update boolean boolean
cursor对象
count()
limit() int
skip() int
sort() {str列:int}
query运算符
$gt/$gte
$in/$nin
$lt/$lte
$ne
$or/$and/$not
$exists
$regex
$size
$elemMatch/$all
update运算符
$inc
$rename
$set
$unset
$addToSet
$push/$pushAll
$pull/$pullAll
$each
$pop
聚合运算符
$project
$match
$limit
$skip
$group
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- MongoDB入门
- MongoDB 极简实践入门
- 8天学通MongoDB——第一天 基础入门
- MongoDB从入门到提高【第二集】
- mongoDB 入门指南、示例
- 在.Net Core中使用MongoDB的入门教程（一）
- MongoDB资料分享(入门必备)
- MongoDB基础入门视频教程
- MongoDB基础入门003--使用官方驱动操作mongo,C#
- MongoDB+MongoVUE安装及入门
- MongoDB入门
- .NET 操作MongoDB入门(三)最简单的增删改查操作
- Mongodb入门篇
- MongoDB教程快速学会入门 第3篇 细说高级操作
- MongoDB CRUD 基础入门
- MongoDB中javascript脚本编程简介和入门实例
- MongoDB入门分享-笔记整理精选
- MongoDB入门---数据库&&&集合的基本操作
- mongodb入门之mongodb副本集
- 10-【MongoDB入门教程】 Journaling日志机制