MongoDB常用操作

2018/07/17 08:16
阅读数 20

Mongodb:是一种NoSQL数据库,NoSQL:Not Only SQL
SQL: 数据表->JDBC读取->POJO(VO、PO)->控制层转化为JSON数据->客户端
这种转换太麻烦了,如果有直接数据库存放要显示的内容,就能够省略所有需要进行转换的过程。
所以在实际开发中,往往除了关系型数据库之外还要提供一个NoSql数据库,其中NoSql数据库负责数据的读取,因为直接保存的就是JSON(前提:MongoDB中的数据是排列好的组合数据)。
例如:现在要求显示出每个雇员的编号、姓名、部门名称、部门位置、工资等级。传统的关系型数据库之中一定要存放大量的冗余数据,不合理。而又nosql数据库,可以直接在业务层里面将数据交给nosql数据库保存。按照指定的结构进行存储。
MongoDB数据库之中与Oracle数据库有如下的概念对应:
oracle:表 nosql:集合
oracle:行 nosql:文档
oracle:列 nosql: 成员
oracle: 主键: nosql:object id(自动)
Node.js中一定要使用MongoDB,而node.js(基于JavaScript操作)在国内最成功的应用-taobao。
Mongodb:面向集合的存储过程,模式自由(无模式)。支持索引、支持短暂数据保留、填充、具备完整的数据库状态监控、基于BSON的应用。
Mongodb与mysql是一种互补的关系。

命令:
不设置端口号启动MongoDB服务:
mongod --dbpath D:\MongoDB\db 表示要再这个目录保存所有的数据库文件的操作
设置端口号启动:
mongod --dbpath D:\MongoDB\db --port=2700
如果通过程序访问数据库的话,一定要设置端口号。
使用mongo命令连接数据库(重新启动一个cmd)
mongo
范例:查询所有的数据库
show databases
此时,只存在一个local的本地数据库,不过这个数据库不使用。
在实际的开发中,在Mongodb中设置一些相应参数:端口号、是否启用用户验证、数据文件的位置等等。
在D:\MongoDB目录下,建立一个文件"mongodb.conf",
同时,建立一个保存日志信息的文件" mongodb.log"

重新启动mongodb的命令:
mongod -f d:\MongoDB\mongodb.conf

在Mongo数据库的基础操作:
1、使用mldn数据库:
use mldn
实际上这个时候并不会创建数据库,只有在数据库里面保存集合数据之后才能真正创建数据库。
2、创建一个集合 
db.createCollection("emp") 创建一个emp集合
此时,利用show databases;可以看到创建的数据库即mldn数据库才会真正的存在。
3、但是很多时候如果按照以上代码的形式进行会觉得你不正常,正常是直接保存一个数据。
db.dept.insert({"deptno":10,"dname":"财务部","loc":"北京"});

4、查看所有集合的命令:show collections
可以看出dept的集合自动创建

5、查看emp标的数据
db.集合名称.find({若干条件})
从传统的数据表来看(集合就相当于表的结构),表的结构一旦定义就要按照其定义的内容来编写,但是MongoDB不一样,可以随意扩展数据。

6、可以随意增加数据
var deptData = {
"deptno":20,
"dname":"研发部",
"loc":"深圳",
"count":20,
"avg":8000.0
};
db.dept.insert(deptData)
此时dept集合的内容可以由用户随意去定义,完全不用考虑其它的结构,那么实际上就必须明确一点,在MongoDB数据库中是绝对不可能存在有查看集合结构的操作。

7、关于ID的问题
在MongoDB集合中的每一行记录都会自动的生成一个"_id“:" 数据组成是:时间戳+机器码+PID+计数器",这个ID的信息是MongoDB自己为用户服务的。
范例:查看单独的一个文档信息
db.dept.findOne();
8、范例:删除数据
db.dept.remove({"_id" : ObjectId("5624fc5bfddcd6e2428e9ed0")})

10、更新数据
var timData = {
"account":"tim",
"passwd":"123",
"studentid":525
};
db.dept.update({"_id" : ObjectId("5624fe1ffddcd6e2428e9ed1")},timData);
11、删除集合
语法:db.集合名称.drop()
db.dept.drop()
12、删除数据库(删除当前所在的数据库信息)
db.dropDatbase()


数据操作
CRUD:除了增加之外,其它的都很麻烦。
1、数据增加
使用:db.集合.insert() 可以实现数据的增加操作。
范例:增加一个简单的数据
db.infos.insert({"url":"www.mldn.cn"});
切换到mldn数据库:use mldn
范例:保存数组
db.infos.insert([
{"url":"www.mldn.cn"},
{"url1":"www.mldnjava.cn"}
]);
范例:保存10000个数据
for(var x = 0;x<10000;x++){
db.infos.insert({"url":"mldn-"+x});
}
如果数据保存很多的情况下,列表不会全部列出,只会列出部分内容。
2、数据查询
任何数据库中,数据的查询操作是最为麻烦的,而在MongoDB的数据库中有关系运算、逻辑运算、正则运算等等。
语法:db.集合名称.find({查询条件}[,{设置显示的字段}])
范例:最简单的用法是用find()函数完成查询:db.infos.find();
希望查询出url为:www.mldn.cn
db.infos.find({"url":"www.mldn.cn"});
对于设置的显示字段严格来说称为数据的投影操作,如果不需要显示的字段设置为”0“,而需要显示的字段设置为”1“。
范例:不显示ID
db.infos.find({"url":"www.mldn.cn"},{"_id":0,"url":1});
大部分的情况下,这种投影意义的查询意义不大,数据的查询可以使用”pretty()“函数进行漂亮显示。
范例:漂亮显示:
db.infos.find({"url":"www.mldn.cn"},{"_id":0,"url":1}).pretty();
数据列多的时候可以看出华丽的显示。

关系查询:
在MongoDB里面支持的关系查询操作:大于($gt)、小于($lt)、大于等于($gte)、小于等于($lte)、不等于($ne)、等于(key:value,$eq)。但是要想让这些操作可以正常使用,那么需要准备出一个数据集合。
范例:定义一个学生信息集合:
db.students.drop();
db.students.insert({"name":"张三","sex":"男","age":19,"score":89,"address":"北京"});
db.students.insert({"name":"李四","sex":"女","age":21,"score":59,"address":"广州"});
db.students.insert({"name":"王五","sex":"男","age":20,"score":99,"address":"天津"});
db.students.insert({"name":"赵六","sex":"女","age":19,"score":100,"address":"上海"});
db.students.insert({"name":"陈七","sex":"男","age":25,"score":20,"address":"深圳"});
db.students.insert({"name":"王八","sex":"男","age":19,"score":78,"address":"福州"});
范例:查询名字为张三的信息:
db.students.find({"name":"张三"}).pretty();
范例:查询性别是男的信息:
db.students.find({"sex":"男"}).pretty();
范例:查询年龄大于20岁:
db.students.find({"age":{"$gt":20}}).pretty();
范例:查询成绩大于等于60分:
db.students.find({"score":{"$gte":60}}).pretty();
范例:查询姓名不是王五的信息:
db.students.find({"name":{"$ne":"王五"}}).pretty();
此时与之前最大的区别就在于,在一个JSON结构里面需要定义其他的JSON结构,这种风格通过程序进行操作依然如此。

逻辑运算主要就是三种:与($and)、或($or)、非($not、$nor)。
范例:查询年龄在19~20岁的学生信息
db.student.find({"age":{"$gte":19,"$lte":20}}).pretty();
在进行逻辑运算的时候,"and”的连接是最容易的,因为只需要利用","分割若干个条件就可以了。
范例:查询年龄不是19岁。
db.student.find({"age":{"$ne":{"$gte":19}}});
范例:查询年龄大于19岁、或者成绩大于90分的学生信息:
db.students.find({"$or":[
{"age":{"$gt":19}},
{"score":{"$gt":90}};
] }).pretty();
针对于或的运算,可以实现一个求反的功能。
在这几个逻辑运算之中,与的连接最简单,而或的连接需要为数据设置数据的过滤条件。

求模
模的运算使用:“$mod” 语法:“{$mod:[数字,余数]}”
db.students.find({"age":{"$mod",[20,0]}}).pretty()
利用求模运算可以编写一些数学公式。

范围查询:
只要是数据库,必须存在有"$in"(在范围之中)、"$nin"(不在范围之中)
范例:查询姓名是"张三"、”李四"、“王五"的信息。
db.students.find({"name":{"$in":["张三","李四","王五"]}}).pretty();
在实际的工作之中,范围的操作很重要。

数组查询:
在mongodb是支持数组保存的,就需要对数组的数据进行匹配。
范例:保存一部分数组内容:
db.student.insert({"name":大神,"course":["语文","英语","数学"]});
此时的数据包含有数组的内容,而后需要针对数组数据进行判断,可以使用几个运算符:$alll、$size、$slice、$elemMatch
范例:查询同时参加语文和数学课程的学生:
现在两个数组内容都需要保存,所以使用"{"$all",[内容1,内容2,...]}"
db.students.find({"course":{"$all":["语文","数学"]}}).pretty();
现在显示所有信息包含语文和数学的内容,而如果差一个内容的不会显示。
虽然,$all 计算可以用于数组上,但是也可以用于一个数据的匹配上。
范例:查询学生地址是“海淀区"的信息
db.students.find({"address":{"$all":[海淀区]}}).pretty();
既然在集合里面保存的是数组信息,那么数组就可以利用索引操作,使用"key.index”的方式来定义索引。
范例:查询数组中第二个内容(index=1,索引下标从0开始)为数学的信息。
db.students.find({"course.1":"数学"}).pretty();
范例:要求查询出只参加两门课程的学生:(使用$size 来进行数量的控制)
db.students.find({"course":{"$size":2}})
在进行数据查询的时候,只要是内容符合条件,数组的内容就全部显示出来,但是现在希望可以控制数组返回的数量,那么可以使用$slice 进行控制。
范例:返回年龄为19岁,所有学生的信息,但是只显示两门参加课程。
db.students.find({"age":19},{"$course":{"$slice":2}}).pretty()
现在只取得前两门的信息,也可以设置取得后两门的信息,把上面的2设置为-2.
db.students.find({"age":19},{"$course":{"$slice":-2}}).pretty()
或者只是取得中间部分的信息:
db.students.find({"age":19},{"$course":{"$slice":[1,3]}}).pretty()
在此时设置的两个数据里面,第一个数据表示跳过的数据量,而第二个表示返回的数据量。


嵌套集合运算:
在MongoDB数据库里面每一个集合数据可以继续保存其它的集合数据,例如:有些学生需要保存家长信息。
范例:
此时给出的内容是嵌套的集合,而这种集合的数据的判断只能够通过"$elemMatch"完成
范例:查询出父母有人是局长的信息。
db.students.find("$and":[{"age":{"$gte":19}},{"parents":{"$elemMatch":{"job":"局长"}}}]).pretty();
由于这种查询的条件比较麻烦,所以尽可能不要搞这么复杂的数据结构组成。

判断某个字段是否存在:
使用“$exists”可以判断某个字段是否存在,如果设置为true表示存在,如果设置为false表示不存在.
范例:查询具有parents成员的数据
db.students.find({"parents":{"$exists":true}}).pretty();
范例:查询不具有course成员的数据:
db.students.find({"course":{"$exists":false}}).pretty();
可以利用此类查询来进行一些不需要的数据过滤,但是建议数据组成一致。

条件过滤
实际上习惯于传统关系型数据库开发的我们对于数据的筛选,可能首先想到的一定是where子句,所以在mogo里面也提供有"$where"。
范例:使用where进行数据查询
db.students.find({"$where":"this.age>20"}).pretty();
可以直接用:db.students.find("this.age>20").pretty();
对于“$where”是可以简化的,但是这类的操作是属于进行每一行的信息判断,实际上对于数据量较大的情况是不方便使用。实际上,以上的代码严格来讲是属于编写一个操作的函数。
db.students.find(function(){ return this.age>20; }).pretty();
以上只是查询了一个判断,如果要想实现多个条件的判断,那么就需要使用and连接。

db.students.find({"$and":[
{"$where":"this.age>19"}.
{"$where":"this.age<19"}
]}).pretty();
虽然这种形式的操作可以实现数据查询,但是最大的缺点是将MongDB里面保存的BSON数据变为JavaSript的语法结构,这样的方式不方便使用数据库的索引机制。

正则运算
如果要想实现模糊查询,那么必须使用正则表达式,而且正则表达式使用的语言Perl兼容的正则表达式的形式。如果要想实现正则使用,则按照如下的定义格式:
基础语法:{key:正则标记}
完整语法:{key:{"$regex":正则标记,"$options":选项}}
其中,对于options主要是设置正则的信息查询的标记。
"i":忽略字幕大小写
"m":多行查找
"x":空白字符串除了被转义的或在字符中意外的完全被忽略:
"s":匹配所有的字符(圆点、“.”),包括换行内容
需要注意的是,如果是直接使用(javascript)那么只能够使用i和m,而"x"和"s"必须使用"$regex"
范例:查询以"谷"开头的姓名
db.students.find({"name":/谷/}).pretty();
范例:查询姓名有字母a
db.students.find({"name":/a/i}).pretty(); 其中,i表示忽略大小写
上面的写法可以为:db.students.find("name":{"$regex":/a/i}).pretty();
如果要执行模糊查询的操作,严格来说只需要编写一个关键字。
正则操作之中,除了可以查询单个字段的内容之外,也可以查询数组数据。
范例:查询数组数据。
db.students.find("course":{"$regex":/语/}).pretty();
mongodB中的正则符号和之前java正则是有一些小小差别。不建议使用以前的一些标记,正则就用在模糊数据的查询上。

数据排序:
在mongoDB里面数据排序操作使用"sort()"函数,在进行排序的时候可以有两个顺序:升序(1)、降序(-1)
范例:数据排序
db.students.find().sort({"sort":-1}).pretty();
但是在进行排序的过程中,有一种方式称为自然排序,按照数据保存的先后顺序排序,使用"$natural"表示
范例:自然排序
db.students.find().sort({"$natural":-1}).pretty();
在MongoDB数据库里面排序的操作相比传统关系型数据库的设置要简单。

数据的分页显示:
在MongoDB里面的数据分页显示也是符合大数据要求的操作函数:
skip():表示跨过多少数据行。
limit(n):取出的数据行的个数限制。
范例:分页显示(第一页,skip(0),limit(5))
db.students.find().skip(0).limit(5).sort({"age":-1}).spretty();
范例:分页显示(第二页,skip(5),limit(5))
db.students.find().skip(5).limit(5).sort({"age":-1}).spretty();
这两个分页的控制操作,就是在以后只要有存在大数据的信息情况下都会使用它。

数据更新操作
对于MongoDB而言,数据的更新基本上是一件很麻烦的事情,如果在实际的工作中,真的具有此类的操作支持,那么最好的做法,在MongoDB里面对于数据的更新操作提供了两类函数:save()、update()。

函数的基本使用
如果要修改数据最直接的使用函数就是update()函数,但是这个函数的语法要求很麻烦。
语法:db.集合.update(更新条件,新的对象数据(更新操作符),upsert,multi)
-update:如果要更新的数据不存在,则增加一条新的内容(ture为增加、false为不增加)
-multi:表示是否只更新满足条件的第一行记录,如果设置为false,则只更新第一行记录,如果是true全更新。
以下是更新存在的数据:
范例:将年龄是19岁的人的成绩更新为100分(此时会返回多条数据)
db.students.update({"age":19},{"$set":{"score":100}},false,false); 选择只更新更新的第一条数据
db.students.update({"age":19},{"$set":{"score":100}},false,true); 所有满足条件的数据都更新
范例:更新不存在的数据
db.students.update({"age":30},{"$set":{"name":"不存在"}},true,false)
由于没有年龄是30岁的学生信息,所以此时相当于进行数据的创建。

那么除了update()函数之外,还提供有一个save()函数,这个函数的功能与更新不存在的内容相似。
范例:使用save()操作
db.students.save({"_id":ObjectId("5123145d2fde")},{"age":50})
save操作不好用,可以用update函数来使用。


修改器:
对于MongDB数据库而言,数据的修改会牵扯到内容的变更、结构的变更(包含有数组),所以在进行MongoDB设计的时候,就提供有一系列修改器的应用,那么之前使用的"$set"就是一个修改器的使用
1、$inc:主要针对于一个数字字段,增加某个数字字段的内容;
语法:{"$inc":{成员:内容}}
范例:将所有年龄为19岁的学生成绩一律减少30分,年龄加一岁
db.students.update({"age":19},{"$inc":{"score":-30,"age":1}},false,true);//全部执行,false,true

2、$set:进行内容的重新设置
语法:{"$set":{"成员":"新内容"}}
范例:将年龄是20岁的人的成绩修改为89分
db.students.update({"age":20},{"$set":{"score":19}})
3、$unset:删除某个成员的内容
语法:{"$unset":{"成员":1}}
范例:删除"张三"的年龄与成绩信息
db.students.update({"name":"张三"},{"$unset":{"age":1,"score":1}})
执行之后指定的成员内容就消失了。
4、$push:相当于将内容追加到指定的成员之中(基本上是数组)
语法:${"$push":{"成员":value}}
范例:向张三添加课程信息(此时张三信息里面没有course信息)
db.students.update({"name":"张三"},{"$push":{"course":["语文","数学"]}})
范例:向"谷大声-E"里面的课程追加一个"美术"
db.students.update({"name":"股大声-E"},{"$push":{"course":"美术"]}})
push就是进行数组数据的添加操作使用,如果没有数组则进行一个新的数组的创建,如果有则进行内容的追加。

5、$pushAll:与"$push"类似的,可以一次追加多个内容到数组里面:
语法:${"$pushAll":{成员:数组内容}}
范例:向"王五"的信息里面添加多个课程内容
db.students.update({"name":"王五"},{"$pushAll":{"course":["语文","数学"]}})

6、$addToSet:向数组里面添加一个新的内容,只有这个内容不存在的时候才会增加。
语法:{"$addToSet":{成员:内容}}
范例:向王五的信息增加新的内容
db.students.update({"name":"王五"},{"$addToSet":{"course":"跳舞"}})
此时会判断要增加的内容在数组里面是否已经存在了,如果不存在则追加内容,如果存在,则不增加内容。

7、$pop:删除数组内的数据:
语法:{"$pop":{成员:内容}},内容如果设置为-1表示删除第一个,1表示删除最后一个
范例:删除王五的一个课程
db.students.update({"name":"王五"},{"$pop":{"course":"-1"}})
范例:删除王五的最后一个课程:
db.students.update({"name":"王五"},{"$pop":{"course":"1"}})

8、$pull:从数组内删除一个指定内容的数据
语法:{"$pull",{成员:数据}} 进行数据比对,如果是此数据则进行删除
范例:删除王五内的跳舞的课程,如果存在就删除
db.students.update({"name":"王五"},{"$pull":{"course":"跳舞"}})
9、$pullAll:一次性删除多个内容
语法:{"$pull":{成员:[数据1,数据2]}}
范例:删除”顾大神-a“的二门课程
db.students.update({"name":"股大声"},{"$pullAll":{"course":["跳舞","音乐"]}})

10、$rename:为成员名称重命名
语法:{"$rename":{旧的成员名称:新的成员名称}}
范例:将"张三"name成员名称修改为"姓名"
db.students.update({"name":"王五"},{"$rename":{"name":"姓名"}})
在整个的MongoDB数据库里面,提供的修改器的支持很到位。

删除数据:
在MongoDB里面数据的删除实际上并不复杂,只需要使用"remove()"函数就可以了。
但是,整个函数是有两个可选项。1、删除条件:满足条件的数据被删除 2、是否只删除一个数据,如果设置为true或者是1表示只删除一个。
范例:清空info集合中的内容。
db.infos.remove({});
范例:删除所有姓名里面带有“谷”的信息。
db.students.remove({"name":/谷/})
范例:删除姓名带有"高"的信息,要求只删除一个
db.students.remove({"name":/高/},true)
删除操作里面依然需要使用限定查询的相关操作内容。

游标:
所谓的游标就是指的数据可以进行一行行的进行操作,非常类似于ResultSet数据处理。在MongoDB数据里面对于游标的控制非常简单,只需要使用find()函数就可以返回游标了。对于返回的游标如果要进行操作,则可以通过两个函数:一个是是否有下一行数据:hasNext(),另一个是取出当前数据next();
var cursor = db.students.find();
cursor.hasNext()
cursor.next();
以上是游标的操作形式,但是实际上并不可能这么去用,因为必须利用循环才能输出内容。
相当于每一个数据都单独拿出来逐行的控制。当我们游标数据取出来的时候,实际上每行数据返回的都是Object型的内容,那么如果需要数据按照json的形式出现,可以使用printjson()函数完成。
在所有的已知数据里,MongoDB的游标操作是最简单的,最直观的。

索引
在任何的数据库之中,索引都是一种提升数据库检索性能的手段,这一点在MongoDB数据库之中同样是存在的,在MongoDB数据库之中,依然会存在两种的索引的创建:一种是自动创建的;另一种是手工创建。
范例:重新准备一个新的简单集合
此时,我们在students集合之上并没有设置任何的索引,那么下面通过getIndexes()函数来观察在students集合已经存在索引内容。
范例:查询默认状态下的students集合的索引内容。
db.students.getIndexes();
想创建自己的索引,如下:
索引创建:db.集合名称.ensureIndex({列:1})
-设置的1表示索引将按照升序的方式进行排列,如果使用降序设置"-1"
范例:创建一个索引,在age字段上设置一个降序索引
db.students.ensureIndexes({"age":-1})
此时并没有设置索引的名字,所以名字是自动命名的。命名规范:“字段名称_索引的排序"
范例:针对于当前的age字段上的索引做一个分析
db.students.find("age":19).explain();
此时的查询使用了索引的技术,但是下面再来观察一个查询,不使用索引字段。
范例:针对score字段上设置查询
db.students.find({"score":{"$gt":60}}).explain();
此时在score上的字段并没有设置索引,所以当前的索引形式就变为了全集合扫描的模式。
但是,如果说现在年龄和成绩一起执行查询。
db.students.find({"$or":[{"age":{"$gt":19}},{"score":{"$gt":60}}]}).explain();
这个时候虽然age字段上存在有索引,但是由于score字段上没有索引,所以依然使用的是全表扫描操作,所以此时,为了解决这个问题,可以使用一个符合索引。
db.students.ensureIndex({"age":-1,"score":-1},{"name":"age_-1_score_-1"})
范例:默认使用索引
db.students.find({"age":19,"score":89}).explain()
但是如果换到了条件之中:
db.students.find({"$or":[{"age":{"$gt":19},{"score":{"$gt":60}}}]}).explain();
但是发现并没有使用索引,所以如果这个时候看能够强制使用一次索引。hint()函数为强制使用一次索引操作。
范例:强制使用索引
db.students.find({"$or":[{"age":{"$gt":19},{"score":{"$gt":60}}}]}).hint({"age":-1,"score":-1}).explain();
正常来讲,这个代码根本就不可能调用默认的索引执行,可使用hint()函数,告诉MongDB必须使用一次索引,由于此时在age和score两个字段已经设设置了符合索引,那么现在 的复合索引。
但是在一个集合里面设置了过多的索引,实际上会导致性能下降,那么就可以删除索引。
范例:删除一个索引
db.students.dropIndex({"age":-1,"score":-1})
可是如果一个一个删除索引,也会很麻烦,所以提供有删除全部索引的操作。
范例:删除全部索引。
db.students.dropIndex()
所谓的删除全部索引,就是非"_id"的索引,所有的自定义索引。

唯一索引:
唯一索引的主要目的是用在某一个字段上,使该字段的内容不重复。
范例:创建一个唯一索引
db.students.ensureIndex({"name":1},{"unique":true})
在name字段上的内容绝对不允许重复。
范例:在students集合里面增加重复的数据。
此时除了,name字段上的内容之外,发现所有的数据都不一样,但是由于在name字段上设置了唯一索引,所以整个程序里面,如果增加了重复内容,会出现以下的错误信息。

过期索引:
在一些程序点上回出现若干秒之后信息被删除的情况,例如:手机的信息验证码,那么在MongoDB里面可以轻松的实现过期索引,但是这个时间往往不怎么准确。
范例:设置过期索引
db.phones.ensureIndex({"time":1},{expireAfterSeconds:10})
设置索引在10秒后过期
等到10秒之后(永远不会那么准确)所保存的数据就会消失。这个操纵在进行一些临时数据保存的时候非常有帮助,最早如果没有MongoDB,而是使用最简单的关系型数据库进行开发这个过程是非常麻烦的。

范例:在一个叫做phone集合里面设置过期索引
如果要想实现过期索引,需要保存一个时间信息。
db.phones.insert({"tel":"110","code":"110","time":new Date()})

全文索引
在一些信息管理平台上经常要进行信息模糊查询,最早的时候是利用了某个字段上实现的模糊查询,但是这个时候返回的信息,并不会很准确,因为只能够查询A字段或者是B字段,而在MongoDB里面实现了非常简单的全文检索。
范例:定义一个新的集合:
db.news.insert({"titel":"mldn java","content":"gyh"})
范例:设置全文检索
db.news.ensureIndex({"title":"text","content":"text"})
范例:实现数据的模糊查询
如果要想表示出全文检索,则使用"$text"判断符,而要想进行数据查询则使用"$search"运算符:
-查询指定的关键字;{"$serach":"查询关键字"}
-查询多个关键字(或关系):{"$search":"查询关键字 查询关键字 ..."}
-查询多个关键字(与关系){"$search":"\"查询关键字\""}
-查询多个关键字(排除某一个):{"$search":" "}
范例:查询单个内容
db.news.find("{"$text":{"$search":"gyh"}}")
范例:包含有"gry"与"sfq"的信息
db.news.find("{"$text":{"$search":"gry sfq"}}")
范例:同时包含有"mldn" 与 "lxh"的内容
db.news.find({"$text":{"$search":"\"mldn\" \"lxh\""}})
范例:包含有"mldn",但是没有"gyh"的信息。
db.news.find("$text":{"$serach":"\"mldn\" \"lxh\" -gyh"})
但是在进行全文检索操作的时候,还可以使用相似度的打分来判断检索成果。
范例:为结果打分
db.news.find({"$text":{"$search":"gyh"}},{"score":{"$meta":"textScore"}}).sort({"score":{"score":{"$meta":"textScore"}})
按照打分的成绩进行排列可以实现更加准确的信息搜索。
但是在这里面还有一个小问题,如果一个集合的字段太多了,那么每一个字段都分别设置全文检索麻烦点。所以简单一些,可以为所有字段设置全文检索。
范例:为所有字段设置全文索引
db.news.ensureIndex({"$**":"text"})
这是一种最简单的设置全文索引的方式,但是尽可能不用,速度慢。

地理信息索引
地理信息索引分为两类:2D平面索引,另外就是2DSphere球面索引。在2D索引里面基本上能够保存的信息都是坐标,而且坐标保存的就是经纬度坐标。
范例:定义一个商铺的集合
db.shop.insert({loc:[10,11]})
范例:为shop集合定义2D索引
db.shop.ensureIndex({"loc":"2d"})
这个时候shop集合就可以实现坐标位置的查询,而要进行查询有两种查询方式:
-1:"$near"查询,查询距离某个点最近的坐标点
-2:"$geoWithin"查询:查询某个形状内的点
范例:假设我现在的坐标是[11,11]
db.shop.find({"loc":{"$near":[11,11]}})
但是,如果执行以上的查询,实际上会将集合里面的额前100个点的信息都返回来了,可是太远了,设置了一个距离范围--5个点内。
范例:设置查询的距离范围
db.shop.find({"loc":{"$near":[11,11],"$maxDistance":5}})
但是,我们需要注意一点,在2D的索引里面虽然支持最大距离,但是不支持最小距离。
但是,也可以设置一个查询的范围,使用"$geoWithin"查询,可以设置以下几种范围:
-1、矩形范围($box) {"$box":[[x1,y1],[x2,y2]]}
-2、圆形范围($centor):{"$center":[[x1,y1],r]}
-3、多边形($polygon):{"$polygon":[[x1,y1],[x2,y2],[x3,y3]]}
范例:查询矩形
db.shop.find({"loc":{"$geoWithin":[[9,9],[11,11]]}})
范例:查询圆形
db.shop.find({"loc":{"$geoWithin":[[9,9],2]}})
在MongoDB数据库里面,除了一些支持的操作函数之外,还有一个重要的命令:runCommand(),这个函数可以执行特定的MongoDB命令。
范例:利用runCommand()实现信息查询
db.runCommand({"geoNear":"shop",near:[10,10],maxDistance:5,num:2})
这类的命令可以说是MongoDB之中最为基础的命令。

聚合函数:
MongoDB产生的背景是在大数据的环境下,实际上大数据就是进行信息的收集汇总。那么必须存在有信息的统计操作,而这样的统计操作称为聚合(直白:分组统计就是一种聚合操作)。

取得集合的数据量
对于集合的数据量而言,在MongoDB里面直接使用count()函数就可以完成。
范例:统计students表中的数据量
db.students.count();
范例:模糊查询
db.students.count({"name":/张/i})
在信息查询的时候,不设置条件永远要比设置条件的查询快很多。也就是说,在之前的代码编写里面不管是查询全部还是模糊查询,实际最终都使用模糊查询的一种(没有设置关键字)。

消除重复数据:
在学习SQL的时候,对于重复的数据可以使用"DISTINCT",那么这一操作在MongoDB之中依然支持。
范例:查询所有name的信息(没有重复)。
-本次的操作没有直接的函数支持,只能怪利用runCommand()函数。
db.runCommand({"distinct":"students","key":"name"})
此时,实现了对于name数据重复值得筛选。

group操作
使用"group"操作可以实现数据的分组操作,在MongoDB里面会将集合指定的Key的不同进行分组操作,并且每一个组都会产生我们处理的文档结果。
范例:查询所有年龄大于等于19岁的学生信息,并且按照年龄分组。
db.runCommand({"group":{"ns":"students",
"key":{"age":true},
"initial":{"count":0},
"condition":{"age":{"$gte":19}},
"$reduce":function(doc,prev){
prev.count++;
}
}});
以上的操作代码里面实现的就属于一种MapReduce,但是这样只是根据传统的数据库设计思路操作实现所谓的分组操作。但是这个分组操作的最终结果是有限的。

MapReduce
MapReduce是整个大数据的精髓所在(实际中别用),所谓的MapReduce就是分为两步处理数据:
-Map:将数据分别取出
-Reduce:负责数据的最后处理。
可是要想在MongoDB里面实现MapReduce处理,那么复杂度是相当高的。
范例:建立一组雇员数据
db.emps.insert({"name":"张三","age":30,"sex":"男","job":"CLERK","salary":1000})
使用MapReduce操作会将处理结果保存在一个单独的集合里面,而最终的处理效果如下:
范例:按照职位分组,取得每个职位的人名
- 编写分组的定义:
var jobMapFun = function()
{
emit(this.job,this.name);//按照job分组,取出name
};
第一组:{key:"CLERK",values:[姓名,姓名,,,,]}
-编写Reduce操作:
var jobReduceFun= function(key,values){
return{"job":key,"names":values};
}

var jobFinalizeFun = function(key,values){
if(key == "PRESIDENT"){
return{"job":key,"names":value,"info":"公司的老大"} 
}
return{"job":key,"names":values};
}

-进行操作的整合:
db.runCommand({"mapreduce":"emps","map":jobMapFun,"reduce":jobReduceFun,"out":"t_job_emp",”“finalize":jobFinalizeFun})
现在执行之后,所有的处理结果都保存在"t_job_temp"集合里面。

范例:统计出个性别的人数、平均工资、最低工资、雇员姓名
var sexMapFun = function(){
//定义好分组的条件,以及每个集合要取出的内容
emit(this.sex,{"ccount":1,"cavg":this.salary,"cmax":this.salary,"cmin":this.salary,"cname":this.name});//emit表示分组处理函数
}
var sexReducnFun = function(key,values){
var total =0;//统计
var sum =0;//计算总工资
var max = values[0].cmax; //第一个数据是最高工资
var min = values[0].cmin;//第一个数据是最低工资
var names = new Array();//定义数组内容
for(var x in values){//表示循环取出里面的数据
total+= values[x].ccount;//特殊增加
sum+=values[x].csal;//就可以循环取出所有的工资,并且累加
if(max<values[x].cmax){//不是最高工资
max = values[x].cmax;
}
if(min>values[x].cmin){//不是最低工资
min = values[x].cmin;
}
name[x] = values[x].cname; //保存姓名

}
var avg = (sum/total).toFixed(2);//设置两位小数
//返回数据的处理结果
return("count":total,"avg":avg,"sum":sum,"max":max,"min":min,"names":names);

};
db.runCommand({
"mapreduce”:"emps",
"map":sexMapFun,
"reduce":sexReduceFun,
"out","t_sex_emp"
});


虽然大数据的时代,提供有最强悍的MapReduce,但是从现实的开发中,真的不可能实现起来,很耗时。但是该功能可用定时任务来定期处理数据结果。

聚合框架:
MapReduce功能强大,但是它的复杂度和功能一样强大,那么我们说很多时候,我们需要MapReduce功能,但是又不想把代码写的太复杂,所以从Mongo 2.x版本之后引入了聚合框架并且提供了聚合函数:aggregate()。

group操作
group主要进行分组的数据操作:
范例:实现聚合查询的功能--求出每个职位的雇员人数
db.emps.aggregate(["$group":{"_id":"$job","job_count":{"$sum":1}}]);
这样的操作,更加符合传统的group by子句的操作使用。
范例:求出每个职位的总工资
db.emps.aggregate(["$group":{"_id":"$job","job_count":{"$sum":"$salary"}}]);
在整个聚合框架里面如果要使用每行的数据使用:"$字段名称"
范例:计算出每个职位的平均工资
db.emps.aggregate(["$group":{"_id":"$job","job_sal":{"$sum":"$salary"},"job_avg":{"$avg":"$salary"}}]);
范例:求出最高与最低工资
db.emps.aggregate(["$group":{"_id":"$job","max_sal":{"$max":"$salary"},"min_sal":{"$min":"$salary"}}]);
以上的几个与SQL类似的操作计算成功的实现了。
范例:计算出每个职位的工资数据(数组显示)
db.emps.aggregate([{
"$group":{
"id":"$job",
"sal_data":{"$push":"$salary"}

}
}]);
范例:求出每个职位的人员:
db.emps.aggregate([{
"$group":{
"_id":"$job",
"sal_data":{"$push":"$name"}
}
}]);
以上使用"$push"的确可以将使用的数据变为数组进行保存,但是有一个问题出现了,重复的内容也会进行保存。在MongoDB里面提供有取消重复的设置。
范例:取消重复的数据
db.emps.aggregate([{
"$group":{
"id":"$job",
"addToSet":{"$push":"$name"}
}
}]);
默认情况下,是将所有的数据都保存进去,但是希望可以保存第一个和最后一个的数据。
范例:保存第一个内容
db.emps.aggregate([{
"$group":{
"id":"$job",
"addToSet":{"$first":"$name"}
}
}]);
范例:保存最后一个内容
db.emps.aggregate([{
"$group":{
"id":"$job",
"addToSet":{"$last":"$name"}
}
}]);
虽然可以实现分组处理,但是有一点需要注意,所有的分组数据是无序的,并且都是在内存之中完成,所以不可能支持大数据量。

$project
可以利用"$project"来显示数据列的显示规则,那么可以执行的规则如下:
-普通列({成员:1|true}):表示要显示的内容
-"_id"列({"_id":0|false}):表示"_id"列的显示是否显示
-条件过滤列({成员:表达式}):满足表达式之后的数据可以进行显示
范例:只显示name、job列
db.emps.aggregate({"$project":{"_id":0,"name":1}})
此时,只有设置进去的列才可以被显示出来,而其他的列不能够被显示出来。实际上这就属于数据库的投影机制。
实际上在进行数据投影的过程里面也支持四则运算:加法("$add")、减法("$subtract")、乘法("$multiply")、除法("$divide")、求模("$mod")
范例:观察四则运算
db.emps.aggregate([{"$project":{
"_id":0,
"name":1
"job":1,
"salary":{"年薪":{"$multiply":["$salary",12]}}
}}])
除了四则运算之外,也支持如下的各种运算fu :
-关系运算:大小比较("$cmp")、等于("$eq")、大于("$gt")、大于等于("$gte")、小于“$lt”、小于等于"$lte"、不等于"$ne"、判断NULL("$ifNull"),这些操作返回的结果都是布尔型数据。
-逻辑运算:与"$and"、或"$or"、非"$not"
-字符串操作:连接"$concat"、截取"$substr"、转小写"$ToLower"、转大写"$ToUpper"、不区分大小写比较"$strcasecmp"
范例:找出所有工资大于等于2000的雇员的姓名、年龄、工资
db.emps.aggregate([{"$project":{
"_id":0,
"name":1,
"job":1,
"工资":"$salary",
"salary":{"$gte":["$salary",2000]}
}}])
范例:查询职位是manager的信息
-MongoDB的数据是区分大小写的:
db.emps.aggregate([{"$project":{
"_id":0,
"name":1,
"职位":"$job",
"工资":"$salary",
"job":{"$eq":["$job",{"$toUpper":"manager"}]}
}}])
范例:使用字符串截取
db.emps.aggregate([{"$project":{
"_id":0,
"name":1,
"职位":"$job",
"job":{"前面三位":{"$substr":["$job",0,3]}}
}}])
利用"$project"实现的投影操作功能相当强大,所有可以出现的操作几乎都能够使用。

$sort
使用"$sort"可以实现排序,设置1表示升序,设置-1表示降序。
范例:实现排序
db.emps.aggregate([{"sort":{"age":-1,"salary":1}}])

分页处理:$limit $skip
$limit:负责数据的取出个数
$skip:数据的跨过个数

$unwind
在查询数据的时候经常会返回数组信息,但是数组并不方便信息的浏览,所以提供有"$unwind"可以将数组数据变为独立的字符串内容。

$geoNear
使用"$geoNear"可以得到附近的坐标点

$out
"$out":利用此操作可以将查询结果输出到指定的集合里面。
范例:将投影的结果输出到集合之中
db.emps.aggregate([{
"$project":{"_id":0,"name":1,"salary":1,"job":1}},
{"$out":"emp_infos"}
])
这类的操作相当于实现最早的数据表的复制操作。

固定集合:
所谓的固定集合指的是规定集合大小,如果要保存的内容已经操作了集合的长度,那么会采用LRU的算法(最近最少使用原则)将最早的数据移出,从而保存新的数据。
默认情况下一个集合可以使用createCollection()函数创建,或者使用增加数据后自动创建,如果使用固定集合,必须明确的创建一个空集合。
范例:创建一个空集合(固定集合)
db.createCollection("depts",{"capped":true,"size":1024,"max":5})
其中,"capped":为一个固定集合,而"size:1024"指的是集合所占的空间容量(字节),"max:5"表示最多只能有5条记录文档。
范例:向集合里面保存5条数据。
db.depts.insert({"deptno":10,"dename":"财务部-A","loc":"北京"})
db.depts.insert({"deptno":11,"dename":"财务部-A","loc":"北京"})
db.depts.insert({"deptno":12,"dename":"财务部-A","loc":"北京"})
db.depts.insert({"deptno":13,"dename":"财务部-A","loc":"北京"})
db.depts.insert({"deptno":14,"dename":"财务部-A","loc":"北京"})
此时已经达到集合的上限,那么继续保存新的内容。
db.depts.insert({"deptno":15,"dename":"财务部-F","loc":"北京"})
此时,最早保留的数据已经消失了。实际上,这种操作跟缓存机制非常相似的,例如:在百度上经常会出现搜索的关键词,这些词都是会被不断替换的。

GridFS
在MongoDB里面支持大数据的存储(例如:图片、音乐、各种二进制数据),但是这个做法需要用户自己处理了。使用"mongofiles"完成。
1、利用命令行进入到所在的路径下
2、将文件保存到文件库之中:
mongofiles --port=27001 put photo.tif
此时,会向数据库里面写入要保存的二进制数据。
3、查看保存的文件
mongofiles --port=27001 list
4、在MongoDB里面有fs系统的集合,这个集合默认保存在test集合的数据库中
use test;
db.fs.files.find();
5、删除文件
mongofiles --prot=27001 delete photo.tif
等于在MongoDB里面支持二进制数据的保存,但是存在的意义不大。

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部