MongoDB常用操作整理

mancha

　　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>　　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里面支持二进制数据的保存，但是存在的意义不大。