MongoDB常用命令及例子详细介绍

常用命令，及其高级命令使用介绍

一：增删改查的高级应用详细介绍：
    增：***插入的时候c1不在的话将自动创建***
        不管插入那条记录都会自动给带个值id  自增主键唯一
        insert 和 save（当id冲突是则修改，否则插入）
            一:id主键不冲突的情况没区别
                db.c1.insert({name:"leyangjun"});
                db.c1.insert({name:"leyangjun"});  insert插入的值id都是唯一的，不会主键id冲突
                db.c1.save({name:"leyangjun"});    和insert一样没区别插入记录的id都是唯一主键
                 
            二：id主键冲突的情况（冲突则更新）
                db.c1.insert({_id:1,name:"leyangjun2"});
                db.c1.insert({_id:1,name:"leyangjun2"});  在插入同样的值就会报错
                db.c1.save({_id:1,name:"leyangjun3"});    --就插入成功，id冲突则更新，把idname=leyangjun2 改成leyangjun3
             
            还可以这么插入(很灵活)：
                *最好别这么玩，这么的后果就是你在php程序里面用时取值就麻烦啦
                db.c1.insert({name:"user1",post:{tit:1,cnt:1111}}); --值是子JSON
                db.c1.insert({name:"user1",post:[1,2,3,4,5,6]});    --值是数组
            既能是js的json还可以循环插入10条：
                for(i=1; i<=10; i++){
                    db.c1.insert({name:"user"+i});
                }
    删：
        db.c1.remove();  全部删除  ==({})空JSON，是json的就全删除
        db.c1.remove({name:"user1"});  --指定删除
         
    查：
        db.c1.find();    ==({})查询所有
        db.c1.find({name:"user3"});  条件查询
         
        场景：记录中有多列只要指定的列（但是_id会默认带上），要的为1，不要为0
            db.c1.insert({name:"leyangjun",age:23,sex:"nan"});
            db.c1.find({name:"leyangjun"},name:1);  只取这条记录name这列
            db.c1.find({name:"leyangjun"},name:1，age:1);  取name,age这个2列
            db.c1.find({name:"leyangjun"},name:1,_id:0);   不要默认的_id列
         
        条件表达式查询：
            1): <,<=,>,>=   --$gt大于、$lt小于 、$gte大于等于、$lte小于等于
                插入10做测试
                for(i=1; i<=10; i++){
                    db.c1.insert({name:"user"+i,age:1})
                }
                db.c1.find({age:$gt:5});     年龄大于5的 $gt大于
                db.c1.find({age:$lt:5});     年龄小于5的 $lt小于
                db.c1.find({age:$gte:5});    年龄大于等于5的 $gte大于等于
                db.c1.find({age:$lte:5});    年龄小于等于5的 $lte小于等于
                db.c1.find({age:5});         年龄等于5的
                db.c1.find({age:$ne:5});     年龄不等于5的
             
                统计里面有多少条记录：db.c1.count();  或者  db.c1.find().count()；
                 
                排序：
                    db.c1.find().sort({age:1})  --- 1表示升序
                    db.c1.find().sort({age:-1}) --- -1是降序
                     
                limit和 结合 skip分页：
                    db.c1.find().limit(3);          ---从0开始拿3条记录
                    db.c1.find().skip(1).limit(5);  ---跳过一个拿出5条（也就是从第几个开始拿几个）  2,3,4,5,6
                    db.c1.find().sort({age:-1}).skip(1).limit(5).count(0);   ---count统计默认是0，不会看前面写的条件，有几条就统计几条
                    db.c1.find().sort({age:-1}).skip(1).limit(5).count(1);   ---按照前面的条件在统计记录数
             
            2):$all,查出包含某个值   --主要针对数组来用
                db.c1.insert({name:"user"},post:[1,2,3,4,5,6]);
                db.c1.find({post:{$all:[1,2,3]}});    --找出post中包含1,2,3的，其中有值为假就查不出来
             
            3):$exists 操作检查一个字段是否存在
                db.c1.find({age:{$exists:1}});  ---查看是否包含字段age
             
            4):$mod 取余
                db.c1.find({age:{$mod:[2,1]}});  ---取对2  余1的 1,3,5,7,9.....
                db.c1.find({age:{$mod:[2,0]}});  ---取对2  余0的 2,4,6,8,10.....
             
            5):$ne 不等于
                db.c1.find({age:$ne:5});     年龄不等于5的
             
            6):$in 和 $nin  类似于传统关系型数据库中的in , not in
                db.c1.find({age:{$in:[1,3,5]}});   ---age等于1,3,5的值（是不是数组是操作符）
                b.c1.find({age:{$nin:[1,3,5]}});   ---age不等于1,3,5的
 
                *规律：查询的时候一般出现的[1,3,5]是操作符不是数组
            7):$or 、$nor（二者是相反的）
                db.c1.find({$or:[{name:"user2"},{name:"user3"}]});   --找出name=user2  或者 name=user3的记录
                db.c1.find({$nor:[{name:"user2"},{name:"user3"}]});   --过滤掉name=user2和user3的记录
                 
                db.c1.find({$or:[{name:"user2"},{age:8},{age:10}]});  --找出name=user2 或 age=8 或 age=10的记录
                db.c1.find({$nor:[{name:"user2"},{age:8},{age:10}]}); ----找出name!=user2 或 age!=8 或 age!=10的记录
                 
            8)：$size  找出字段数组值的个数->专门正对数组的操作
                    db.c1.insert({name:"user1",post:[1,2,3,4,5,6]});   第一条记录
                    db.c1.insert({name:"user1",post:[7,8,9]});         第二条记录
                    db.c1.find({post:$size:3});   --就会找到第二条记录，post里面的的个数是3
                     
            9)****正则表达式*******
                和js正则一样：
                db.c1.find({name:/user/i});   ---找出name值包含user的
             
            10):DISTINCT 类似关系数据库中的distinct
                db.c1.insert({name:"leyangjun"});
                db.c1.insert({name:"leyangjun"});
                db.c1.distinct("name");   ---name值去重，查出一条记录
                 
            11):$elemMatch元素匹配
                db.c3.insert({name:"user1",post:[{tit:1},{tit:2},{tit:3}]});
                db.c3.insert({name:"user2",post:[{tit:"aaa"},{tit:"bbb"},{tit:"ccc"}]});
                 
                查找tit=2的记录
                    db.c3.find({"post.tit":2});  --可以找到
                    db.c3.find({post:{$elemMatch:tit:2}});   --这种方式匹配
                    db.c3.find({post:{$elemMatch:tit:2,tit:3}});   --匹配tit=2 tit=3的记录
             
            12):游标的概念（用的很少）
                var x=db.c1.find();
                x.hasNext();  --有没有值，返回的是true 和 false，true的话就去链接数据库拿值，否则链接数据库
                x.next()      --取出来一条值
                x.next()
                x.next()
                x.next()      ---有值就一直往下取
                x.hasNext();  ---为FALSE也就没值啦
 
            13)：null查询（没有值，值为空，值为NULL的）
                匹配age=null的
                db.c4.find({age:null});   ---这个匹配是不准的，记录中没有age字段的也会被查出来
                db.c4.find({age:{$exists:1,$in:[null]}});   --先判断过滤age是否存在，在匹配age=null的
                或
                db.c4.find({age:$type:10});   ---10就是null  推荐使用这种查null
                db.c4.find({age:$type:10,name:"user1"});   --age=null 并且 name=user1
             
            14):$slice->只针对数组
                db.c3.insert({name:"user1",post:[{tit:1},{tit:2},{tit:3}]});
                db.c3.find({name:"user1",{post:$slice:2}});   ---取name=user1,前2条贴，就是post字段的值 对应数组的：1,2
                db.c3.find({name:"user1",{post:$slice:-2}});  ---取name=user1,后2条贴，就是post字段的值 对应数组的：2,3
                db.c3.find({name:"user1",{post:$slice:[1,2]}}), --- 从第1条开始取2条贴 对应数组的：2,3
                 
    改：
        update语法介绍   默认是0,0--后面2个参数值
                db.collection.update(criteria,objNew,upsert,multi);
                 参数说明：
                 criteria：用于设置查询条件的对象
                 objnew：用于设置更新的内容对象
                 upsert：如果记录已经存在，更新它，否则新增一个记录   
                 multi：如果有多个符合条件的记录，全部更新
                 注意：默认情况，只会更行第一个符合条件的记录哦
            例子：
                db.c1.insert({name:"leyangjun",age:23);
                db.c1.update({name:"leyangjun"},{sex:"nan"});   --这样会吧name,age删掉，记录只会留下sex字段值
                db.c1.update({name:"user6"},{name:"user66"},1); --1表示，user6存在则改成user66,否则user6不存在则增加新的记录name=user66
                第4个参数只能配合魔术变量使用$set,批量更新
                    db.c1.update({name:"user6"},{$set:{name:"user66"}},0,1); --将所有的name=user6的全部更新user66
                     
        2):$set 增加字段，或批量修改字段值（存在则更新，不存在则增加）
            db.c1.update({name:"user6"},{$set:{name:"user66"}},0,1);   --批量修改name值
            db.c1.update({name:"user10"},{$set:{age:10}},0,1);    --将name=user1的全部加上 age字段，且值=10
         
        3)：$inc -->increment自增的意思,如果字段有则加减（自己定），没有则新增
            场景：现在在大促了，想给没给会员赠送5个积分，但是：积分字段有的会员没有有的有的情况
                  现在想没有积分字段的会员也得加5分，$inc就能做到
                db.c1.insert({name:"leyangjun",age:23,score:11});
                db.c1.insert({name:"leyangjun",age:23,score:1});
                db.c1.insert({name:"leyangjun",age:23});
                --加积分
                db.c1.update({},{$inc:score:10},0,1);   --{}表示所有用户，都加10个积分，没有score字段的，$inc会统一加上
                db.c1.update({name:"user1"},{$inc:score:10});   加减都行
                db.c1.update({name:"user1"},{$inc:score:-10});
                 
            *set 和 $inc 都可以增加字段，但是$inc增加必须是整型
             
        4)：$unset 删除字段（自带的_id字段是删不鸟的）   
                db.c5.update({},{$unset:{score:1},0,1);   --1表示true，将所有记录中的score字段删掉
                db.c5.update({},{$unset:{score:1,age:1},0,1); --删除多个
         
        5)：$push 针对数组增加元素(更新的魔术方法一般在字段的外侧，查询是在内侧)
                db.c3.insert({name:"user1",arr:[1,2,3]});
                db.c3.update({name:"user1"},{$push:{arr:4}});  --name=user1的arr增加元素，记住不能同时插入多个(可以压数组，就是不能同时压入多个值)
                 
        6)：$pop 将字段里的最后元素移除，针对数组
                db.c3.update({name:"user1"},{$pop:{arr:1}});   --1表示最后一个，将arr里面的最后元素移除
                db.c3.update({name:"user1"},{$pop:{arr:-1}});  -- -1表示删除第一个值
        7):$pushAll 压入多个值   
                db.c3.update({name:"user1"},{$push:{arr:[4,5,6]}});  ---压入多个值
         
        8)：$addToSet 压入值是会去重复插入（如值里面有4，在这么插入里面只会有一个4）
                db.c3.update({name:"user1"},{$addToSet:{arr:4}});  --如果值里面有4，是插入不进去的，没有重复的则插入
                $addToSet 和 $each 配合使用插入多个：
                    db.c3.update({name:"user1"},{$addToSet:{arr:{$each:[7,8,9]}}}); --插多个
                 
        9)：$pull 删除数组里面的某个值，针对数组
                db.c3.update({name:"user1"},{$pull:{arr:5}});   --删除数组中为5的值
        10):$pullAll一次性删除多个
                db.c3.update({name:"user1"},{$pullAll:{arr:[2,4]}}); --删除值为2,4
         
        11)：$rename修改字段名
                db.c3.update({name:"user1"},{$rename:{arr:"post"}}); 或 
                db.c3.update({name:"user1"},{$rename:{"arr":"post"}}); 
         
        12):特殊的操作符号 $
            db.c3.insert({name:"user1",arr:[{tit:"php"},{tit:"java"},{tit:"linux"}]});
            把标题为linux的值改下：
                db.c3.update({"arr.tit":"linux"},{$set:{"arr.$.cnt":"linux is very good"}});
         
         
         
*小结：
    场景1：    
        db.c1.insert({name:"leyangjun",age:23});
        var x=find({name:"user1"});
        x     --回车有值
        x     --在回车没值了，所以find本身是带有游标的
     
    场景2：
        var x=findOne({name:"user1"});
        x   --回车有数据       x是一个json，在mogodb客户端的时候输出你就能看看出来
        x   --回车还有数据
        x.sex="nan"     --可以加字段，但是这加的字段是不会直接加到数据记录
        x.sex="score"  
        ......   
         
        把x加字段，直接保存到数据库
        db.c1.save(x);   --数据就加到里面去啦,
                 
    db.c1.insert({name:"leyangjun",age:23});   ---增
    db.c1.remove();   ---删（删除所有）
    db.c1.remove({"name":"leyangjun"}); --删除名字等于leyangjun的记录
    db.c1.update({name:"leyangjun"},{name:"lekey"});  ---改，（如果还有age值的话，会被删除，只留下name值）
    db.c1.update({name:"leyangjun"},{$set:{name:"lekey"}});  --改，这个改会保留原有的值
    db.c1.update({name:"lekey"},{$set:{sex:"nan"}});  --还可增加值，名字等于lekey记录增加字段值sex
    db.c1.find();     ---查
    db.c1.find({"name":"leyangjun"});
 
***普通集合  和 固定集合  的区别*****
    普通集合：普通集合的空间是随着你的json对象的值增多而自动增大
    固定集合：在32位机上一个append collection的最大值约483.5M，64位上只受系统大小的限制。
         
二：capped collection（固定集合）
    小命令记住鸟：
        show dbs;    --显示所有数据库
        db           --显示当前数据库
        show tables; -- 显示当前库下的所有集合（也就是显示所有表）
        db.c5.drop(); --删除c5集合
        db.dropDatabase();
         
        注意哈：mongodb当你插入和进入的时候会默认的给你创建数据库和集合（表）
        db.createCollection("c1");    --手动创建c1集合（表）
        db.c1.find();
        db.c1.drop();
     
    简单介绍：
        capped collections是性能出色的有着固定大小的集合，以LRU(least recently used最近最少使用)
      规则和插入顺序进行age-out(老化移出)处理，自动维护集合中对象的插入顺序，在创建时要预先执行大小
      。如果空间用完，新添加的对象将会取代集合中最旧的对象。
      永远保持最新的数据
       
      功能特点：
        可以插入及更新，但更新不能超出collection的大小，否则更新失败。
        不允许删除，但是可以调用drop()删除集合中的所有行，但是drop后需要显示地重建集合。
        在32位机上一个append collection的最大值约483.5M，64位上只受系统大小的限制（就是系统对文件大小的限制）。
       
      属性及方法: 优点
        属性1：对固定集合进行插入速度极快
        属性2：按照插入顺序的查询输出速度极快
        属性3：能够在插入最新数据时，淘汰最早的数据
         
        用法1：存储日志信息
        用法2：缓存一些少量的文档
         
    创建固定集合：
        createCollection命令来创建
        --size是大小设置的是10M,如果你的文件超了10M之前的文件就会被自动删除（删除的规则是老的数据会被删除一次类推）
        db.createCollection("my_collection",{cappend:true,size:10000000,max:5});  
        创建一个集合为：‘my_collection’的固定集合，大小为10000000字节。还可以限定文档个数。加上max：100属性。
         
        注意：指定文档上限，必须指定大小。文档限制是在容量没满是进行淘汰，要是满了，就根据容量限制来进行淘汰。
              当你创建集合后会自动给你创建对应的indexSize{"_id_":xxxx}索引id，能后
              db.system.indexs.find();  --这个里面就会自动为你刚才建立的集合形成主键索引 创建对应的ID在这里
         
        db.c1.stats();   --查看集合C1的状态值，大小啊什么的，索引id什么的
                           注意有个属性：capped为1  说明是固定集合
    普通集合转固定集合：
        runCommand命令
            db.runCommand({converToCapped:"c2",size:10000000,max:3});
 
三：GridFS    (大文件上传和下载,专门用来存储图片和视频)
    介绍：GridFS是一种在mongodb中存储大二进制文件的机制，使用GridFS的原因以下几种：
          ->存储巨大的文件，比如视频、高清图片
          ->利用GridFS可以简化需求
          ->GridFS会直接利用已经建立的复制或分片机制，故障恢复和扩展都很容易
          ->GridFS可以避免用户上传内容的文件导致系统出现问题
          ->GridFS不产生磁盘碎片
         
        GridFS使用两个表来存储数据：
            files 包含元数据对象
            chunks 包含其他一些相关信息的二进制块
             
            *  为了使多个GridFS命名为一个单一的数据库，文件和块都有一个前缀，默认情况下，前缀是fs,
           所以任何默认的GridFS存储将包含fs.files和fs.chunks。
           各种第三房语言可以更改其前缀。
            
    使用GridFS mongofiles（存文件的地方）
        mongofiles 是从命理行操作GridFS的一种工具
        三个命令：put(存储) get(获取，下载) list(列表)
         
        例子：
            ./mongofiles -h    --查看支持的基本参数
            ./mongofiles list  --查看mongofiles 的所有文件
             
            现在模拟一个文件丢到里面去
                tar czf mongosniff.tar.gz mongosniff   --把mongosniff文件压缩成包
                ./mongofiles put mongosniff.tar.gz     --把包文件上传上去 
                 
                能后你在进入mongo
                    ./mongo
                    show tables;    --你会发现多了2个集合   fs.files 、fs.chunks
                    db.fs.files.find();  --查看
                                        --出现对应的字段说明：
                                            filename：存储的文件名
                                            chunkSize: chunks分块的大小
                                            uplodaDate:入库时间
                                            md5：此文件的md5码
                                            length：文件大小，单位”字节“
                                            fs.files中存储的是一些基础的元数据信息，真正的内容在fs.chunks里面
                     
                    db.fs.chunks.find(); --真正的文件是在这里面的哦
                    exit;
                     
                ./mongofiles list   --就可以查看到我们穿上来的文件包
                ./mongofiles get mongosniff.tar.gz   --下载这个文件，下载到你当前执行命令的目录下
                ./mongofiles delete mongosniff.tar.gz  --删除该文件 
                *注意：当你删除mongofiles下的文件时候，fs.files 、fs.chunks表下也就没东西 
         
四：性能
    一：索引管理
        mongodb提供了多样性的索引支持，索引信息被保存在system.indexs中，mongodb中的_id字段在
      创建的时候，默认已经建立了索引，这个索引比较特殊，并且不可删除，不过capped collection列外。
      1：建立索引
         一：普通索引
            for(i=1;i<=10;i++){
                db.c1.insert({name:"user"+i,age:i});
            }
            db.c1.find({name:"user5"}).explain();    --explain和MySQL一样解析一条语句，没索引就全表扫描这个可以看出来
             
            1是升序(默认)  -1是降序
            db.c1.ensureIndex({name:1});
            db.c1.ensureIndex({name:1},{background:true});  --如果数据较大耗时，放到后台执行，加上第二个参数即可，表示放到后台执行
            db.c1.getIndexKeys();  --查看所有字段 简单信息
            db.c1.getIndexes()     --查看表索引  详细信息
             
            db.c1.find({name:"user5"}).explain();   --建立完索引后，你会发现只会扫描一行，不会全表扫描
         二：唯一索引
            db.c1.ensureIndex({age:1},unique:1);    --age字段建立唯一索引
            db.c1.insert({name:"user11",age:10});   --你会发现插不进去，以为age是唯一索引
     
      2：查看索引
            db.c1.getIndexKeys();  --查看所有字段 简单信息
            db.c1.getIndexes()     --查看表索引  详细信息
             
             
      3：删除索引
            db.c1.dropIndexes();   --删除所有索引   _id删不掉哦
            db.c1.dropIndex({name:1});  --指定删除name索引
     
    二：性能优化
            explain执行计划（看影响行数）
                mongodb提供了一个explain命令让我们获知系统如何处理查询请求，利用explain命令
                我们可以很好的观察系统如何使用索引来加快检索，同时可以针对性优化索引。
             
            优化器profile(类似MySQL的慢查询日志)
                默认是关闭的，且默认是100毫秒
                db.getProfilingLevel();    --0 如果是0,说明没有开启慢查询日志
                db.setProfilingLevel(1);   --1 表示开启记录慢查询（默认为100ms）
                                           --2 表示记录所有命令
                 
                db.setProfilingLevel(1，1000);   --第一种方式：第二个参数是设置时间毫秒为单位
                                                 --第二种方式：启动mongodb时带上 --slowms 设置
            mongodb优化方案：
                1：创建索引
                2：限定返回结果条数
                3：查询使用到的字段，不查询所有字段
                4：采用 capped collection
                    capped collections 比普通collections的读写效率高
                5：采用profiling慢查询日志  
 
    三性能监控（自带的2个工具）
        1：mongosniff 记载通讯记录
            打开2个窗口
                ./mongosniff --source net lo      A窗口执行
                 
                ./mongo     --B窗口链接mongodb，能后 ，A窗口就已经记录B的操作信息，登录啊退出啊什么的
                     
        2:mongostat 监控（谁访问，查删啊。。。。。）
            ./mongostat     --A窗口执行，会每一秒会刷新界面
            ./mongo         --B窗口链接mongodb， B执行的增删查的记录会在A窗口被监控到