mongodb简单查询语句

数据库常用命令
    1、Help查看命令提示
     help
      db.help();
      db.yourColl.help();
      db.youColl.find().help();
      rs.help();
    2、切换/创建数据库
     use yourDB;  当创建一个集合(table)的时候会自动创建当前数据库
    3、查询所有数据库
     show dbs;
    4、删除当前使用数据库
     db.dropDatabase();
    5、从指定主机上克隆数据库
     db.cloneDatabase(“127.0.0.1”); 将指定机器上的数据库的数据克隆到当前数据库
    6、从指定的机器上复制指定数据库数据到某个数据库
     db.copyDatabase("mydb", "temp", "127.0.0.1");将本机的mydb的数据复制到temp数据库中
     db.copyDatabase("YGZ_MONGODB_1", "YGZ_MONGODB", "133.1.1.97:33001")；把 133.1.1.97:33001 机器的 YGZ_MONGODB_1库里的所有 复制到 YGZ_MONGODB库中
    7、修复当前数据库
     db.repairDatabase();
    8、查看当前使用的数据库
     db.getName();
     db; db和getName方法是一样的效果，都可以查询当前使用的数据库
    9、显示当前db状态
     db.stats();
    10、当前db版本
     db.version();
    11、查看当前db的链接机器地址
     db.getMongo();
Collection聚集集合
    1、创建一个聚集集合（table）
     db.createCollection(“collName”, {size: 20, capped: 5, max: 100});
    2、得到指定名称的聚集集合（table）
     db.getCollection("account");
    3、得到当前db的所有聚集集合
     db.getCollectionNames();
    4、显示当前db所有聚集索引的状态
     db.printCollectionStats();
用户相关
    1、添加一个用户
     db.addUser("name");
     db.addUser("userName", "pwd123", true); 添加用户、设置密码、是否只读
    2、数据库认证、安全模式
     db.auth("userName", "123123");
    3、显示当前所有用户
     show users;
    4、删除用户
     db.removeUser("userName");
其他
    1、查询之前的错误信息
     db.getPrevError();
    2、清除错误记录
     db.resetError();
查看聚集集合基本信息
    1、查看帮助  db.yourColl.help();
    2、查询当前集合的数据条数  db.yourColl.count();
    3、查看数据空间大小 db.userInfo.dataSize();
    4、得到当前聚集集合所在的db db.userInfo.getDB();
    5、得到当前聚集的状态 db.userInfo.stats();
    6、得到聚集集合总大小 db.userInfo.totalSize();
    7、聚集集合储存空间大小 db.userInfo.storageSize();
    8、Shard版本信息  db.userInfo.getShardVersion()
    9、聚集集合重命名 db.userInfo.renameCollection("users"); 将userInfo重命名为users
    10、删除当前聚集集合 db.userInfo.drop();
聚集集合查询
    1、查询所有记录
        db.userInfo.find();
        相当于：select* from userInfo;
        默认每页显示20条记录，当显示不下的情况下，可以用it迭代命令查询下一页数据。注意：键入it命令不能带“；”
        但是你可以设置每页显示数据的大小，用DBQuery.shellBatchSize= 50;这样每页就显示50条记录了。
    2、查询去掉后的当前聚集集合中的某列的重复数据(去重)
        db.userInfo.distinct("name");
        会过滤掉name中的相同数据
        相当于：select distict name from userInfo;
        db.userInfo.distinct("name", {"age" : 23}  );
        过滤掉age=23的name中相同的数据
        相当于：select distict name from userInfo where age=23;
        db.userInfo.distinct("name").length;统计去重后的数量
        db.collection_name.distinct(field,query,options)
        field -----指定要返回的字段(string)
        query-----条件查询(document)
        options-----其他的选项(document)
    3、查询age = 22的记录
        db.userInfo.find({"age": 22});
        相当于： select * from userInfo where age = 22;
    4、查询age > 22的记录
        db.userInfo.find({age: {$gt: 22}});
        相当于：select * from userInfo where age >22;
    5、查询age < 22的记录
        db.userInfo.find({age: {$lt: 22}});
        相当于：select * from userInfo where age <22;
    6、查询age >= 25的记录
        db.userInfo.find({age: {$gte: 25}});
        相当于：select * from userInfo where age >= 25;
    7、查询age <= 25的记录
        db.userInfo.find({age: {$lte: 25}});
    8、查询age >= 23 并且 age <= 26
        db.userInfo.find({age: {$gte: 23, $lte: 26}});
    9、查询name中包含 mongo的数据
        db.userInfo.find({name: /mongo/});
        //相当于%%
        select * from userInfo where name like ‘%mongo%’;
    10、查询name中以mongo开头的
        db.userInfo.find({name: /^mongo/});
        select * from userInfo where name like ‘mongo%’;
    11、查询指定列name、age数据
        db.userInfo.find({}, {name: 1, age: 1});
        相当于：select name, age from userInfo;
        当然name也可以用true或false,当用ture的情况下河name:1效果一样，如果用false就是排除name，显示name以外的列信息。
    12、查询指定列name、age数据, age > 25
        db.userInfo.find({age: {$gt: 25}}, {name: 1, age: 1});
        相当于：select name, age from userInfo where age >25;
    13、按照年龄排序
        升序：db.userInfo.find().sort({age: 1});
        降序：db.userInfo.find().sort({age: -1});
    14、查询name = zhangsan, age = 22的数据
        db.userInfo.find({name: 'zhangsan', age: 22});
        相当于：select * from userInfo where name = ‘zhangsan’ and age = ‘22’;
    15、查询前5条数据
        db.userInfo.find().limit(5);
        相当于：selecttop 5 * from userInfo;
    16、查询10条以后的数据
        db.userInfo.find().skip(10);
        相当于：select * from userInfo where id not in (
        selecttop 10 * from userInfo
        );
    17、查询在5-10之间的数据
        db.userInfo.find().limit(10).skip(5);
        可用于分页，limit是pageSize，skip是第几页*pageSize
    18、or与 查询
        db.userInfo.find({$or: [{age: 22}, {age: 25}]});
        相当于：select * from userInfo where age = 22 or age = 25;
    19、查询第一条数据
        db.userInfo.findOne();
        相当于：selecttop 1 * from userInfo;
        db.userInfo.find().limit(1);
    20、查询某个结果集的记录条数
        db.userInfo.find({age: {$gte: 25}}).count();
        相当于：select count(*) from userInfo where age >= 20;
        如果要返回限制之后的记录数量，要使用count(true)或者count(非0) 
        db.users.find().skip(10).limit(5).count(true);
    21、按照某列进行排序
        db.userInfo.find({sex: {$exists: true}}).count();
        相当于：select count(sex) from userInfo;
    22、{age:{$all:[7,9]}}:age数组中只要有7和9就满足条件。如果只有7，没有9则不符合条件。
索引
    1、创建索引
        db.userInfo.ensureIndex({name: 1});
        db.userInfo.ensureIndex({name: 1, ts: -1});
    2、查询当前聚集集合所有索引
        db.userInfo.getIndexes();
    3、查看总索引记录大小
        db.userInfo.totalIndexSize();
    4、读取当前集合的所有index信息
        db.users.reIndex();
    5、删除指定索引
        db.users.dropIndex("name_1");
    6、删除所有索引索引
        db.users.dropIndexes();
         修改、添加、删除集合数据
1、添加
    db.users.save({name: ‘zhangsan’, age: 25, sex: true});
    添加的数据的数据列，没有固定，根据添加的数据为准
2、修改
    db.collection.update(criteria, objNew, upsert, multi )
    criteria:update的查询条件，类似sql update查询内where后面的
    objNew:update的对象和一些更新的操作符（如$,$inc...）等，也可以理解为sql update查询内set后面的。
    upsert : 如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
    multi : mongodb默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
    db.users.update({age: 25}, {$set: {name: 'changeName'}}, false, true);
    相当于：update users set name = ‘changeName’ where age = 25;
    db.users.update({name: 'Lisi'}, {$inc: {age: 50}}, false, true);
    相当于：update users set age = age + 50 where name = ‘Lisi’;
    db.users.update({name: 'Lisi'}, {$inc: {age: 50}, $set: {name: 'hoho'}}, false, true);
    相当于：update users set age = age + 50, name = ‘hoho’ where name = ‘Lisi’;
3、删除
    db.users.remove({age: 132});
4、查询修改删除
    db.users.findAndModify({
        query: {age: {$gte: 25}},
        sort: {age: -1},
        update: {$set: {name: 'a2'}, $inc: {age: 2}},
        remove: true
    });
    db.runCommand({ findandmodify : "users",
        query: {age: {$gte: 25}},
        sort: {age: -1},
        update: {$set: {name: 'a2'}, $inc: {age: 2}},
        remove: true
    });

mongodb数据库常用语句
    1.分组（按照RETURN_CODE一个字段进行分组，并统计个数）
    db.getCollection('ISSUE_BASE_INFO').aggregate({ "$group" : { "_id" : {RETURN_CODE:'$RETURN_CODE'}, 'count' : {'$sum':1} } })
    2.分组（按照l两个字段进行分组）
    db.getCollection('ISSUE_BASE_INFO').aggregate({ "$group" : { "_id" : {RETURN_CODE:'$RETURN_CODE', DATAGRAM_TYPE : '$DATAGRAM_TYPE'}}})
    3.把  DATAGRAM_STATUS为2的全部修改为0
    db.getCollection('POST_CUSTOMER_INFO').update({"DATAGRAM_TYPE" : 2,
        "DATAGRAM_STATUS" : 2, "RETURN_CODE" : 703}, {$set : {"DATAGRAM_STATUS" : 0}}, false, true )
    4.把一个表中的数据复制到另一个表
    db.test（复制源表）.find().forEach(function(x){
        db.target（目的表）.insert(x);
    })
    5.按照USERID_NUM进行分组统计数量，并按数量进行倒叙，显示数量大于1的
    db.getCollection('USERID_MAPPING').aggregate(
        [
            {
                "$group":{
                    "_id":{USERID_NUM:'$USERID_NUM'},
                    'count':{'$sum':1},
                }
            },
            { $sort : { count : -1} },
            {$match:{count:{$gt:1}}}
        ],
         {allowDiskUse: true}
    )
    6.嵌套格式查询
    db.getCollection('DISPUTE').aggregate([
        { $match: {
            "_id.ServiceProviderId": "9999999911030101" ,
            "_id.FileId": 20383387,
            "ClearingOperatorId" : "9999999901020001",
            "IssuerId" : "9999999911010001",
            } 
        }
    ]);
    7.截取字符串查询
    db.getCollection('AA').aggregate( 
        [ 
            {
                $project:
                    {
                        searchitem:
                            { $substr: 
                                [ '$trans_num', 20, -1 ] 
                            },
                            trans_num : '$trans_num',
                            type : '$type'
                    }
            } ,
            { 
                $sort : { searchitem : -1} 
            },
            {
                $match : { 
                    searchitem : 
                        { $gt : "201803021010" }, 
                        type : 2 
                    }
            }
        ] ,
        { allowDiskUse : true }
    )
    8.截取字符串查询并统计求和
    db.getCollection('BB').aggregate( 
    [ 
        {
            $project : {
                searchitem : { 
                    $substr : [ '$CARD_NO', 7, 2 ] 
                },
                CARD_NO : '$CARD_NO',
                DATAGRAM_TYPE : '$DATAGRAM_TYPE',
                userId : '$OBJECT.userId',
                OBJECT : '$OBJECT'
            }
        } ,
        {
            $match : { 
                searchitem : "09", 
                DATAGRAM_TYPE : 2 
            }
        },
        {
            "$group":{
                _id : null,
                sum : { $sum: {}},
                count:{'$sum':1}
            }
        }
    ] ,
    { allowDiskUse : true }
)
    9.根据条件去重并统计个数（按照分组方式去重）
    db.getCollection('aa').aggregate(
    [
      {
        $project:{
              // 这里指定了name为主键，相当于去重
              _id: {userno: "$userno"},
              // 让其显示 type
              type: '$type'
        }
      },
      {
         $match : { 
                 //查询 type = 2的
                type : 2 
            }
      },
        {
            "$group":{
                // 统计数量
                _id : {_id : "$_id"},
                sum : { $sum: {}},
                count:{'$sum':1}
            }
        }
    ],
    // 避免内存溢出
    { allowDiskUse : true }
)
分组常用语句：
    应用一：统计name的数量和总数；
        db.collection.aggregate([
            {$group:{_id:"$name",count:{$sum:1},total:{$sum:"$num"}}
        ]);
    应用二：统计status=1的name的数量；
        db.collection.aggregate([
            {$match:{status:1}},
            {$group:{_id:"$name",count:{$sum:1}}}
        ]);
    应用三：统计name的数量，并且数量为小于2的；
        db.collection.aggregate([
            {$group:{_id:"$name",count:{$sum:1}},
            {$match:{count:{$lt:2}}}
        ]);
    应用四：统计stauts=1的name的数量，并且数量为1的；
        db.collection.aggregate([
            {$match:{status:1}},
            {$group:{_id:"$name",count:{$sum:1}}},
            {$match:{count:1}}
        ]);
    应用五：多列group，根据name和status进行多列
        db.collection.aggregate([
            {$group:{_id:{name:"$name",st:"$status"},count:{$sum:1}}}
        ]);
    $project该操作符很简单，结果是，只有_id,name,status三个字段的表数据，相当于sql表达式 select _id,name,status from collection
        db.collection.aggregate([
            {$project:{name:1,status:1}}
        ]);

一、查询相关
    1、基本查询：
        构造查询数据。
            > db.test.findOne()
            {
                 "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"),
                 "name" : "stephen",
                 "age" : 35,
                 "genda" : "male",
                 "email" : "[email protected]"
            }
        --多条件查询。下面的示例等同于SQL语句的where name = "stephen" and age = 35
            > db.test.find({"name":"stephen","age":35})
            { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35, "genda" : "male", "email" : "[email protected]" }
        --返回指定的文档键值对。下面的示例将只是返回name和age键值对。
            > db.test.find({}, {"name":1,"age":1})
           { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35 }
        --指定不返回的文档键值对。下面的示例将返回除name之外的所有键值对。
            > db.test.find({}, {"name":0})
            { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "age" : 35, "genda" : "male", "email" : "[email protected]" }
    2、查询条件：
        MongoDB提供了一组比较操作符：$lt/$lte/$gt/$gte/$ne，依次等价于/>=/!=。
        --下面的示例返回符合条件age >= 18 && age <= 40的文档。
            > db.test.find({"age":{"$gte":18, "$lte":40}})
            { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "[email protected]" }
        --下面的示例返回条件符合name != "stephen1"
            > db.test.find({"name":{"$ne":"stephen1"}})
            { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "[email protected]" }
        --$in等同于SQL中的in，下面的示例等同于SQL中的in ("stephen","stephen1")
            > db.test.find({"name":{"$in":["stephen","stephen1"]}})
            { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "[email protected]" }  
        --和SQL不同的是，MongoDB的in list中的数据可以是不同类型。这种情况可用于不同类型的别名场景。
            > db.test.find({"name":{"$in":["stephen",123]}})
            { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "[email protected]" } 
        --$nin等同于SQL中的not in，同时也是$in的取反。如：
            > db.test.find({"name":{"$nin":["stephen2","stephen1"]}})
            { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "[email protected]" }
        --$or等同于SQL中的or，$or所针对的条件被放到一个数组中，每个数组元素表示or的一个条件。
        --下面的示例等同于name = "stephen1" or age = 35
            > db.test.find({"$or": [{"name":"stephen1"}, {"age":35}]})
            { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "[email protected]" } 
        --下面的示例演示了如何混合使用$or和$in。
            > db.test.find({"$or": [{"name":{"$in":["stephen","stephen1"]}}, {"age":36}]})
            { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "[email protected]" } 
        --$not表示取反，等同于SQL中的not。
            > db.test.find({"name": {"$not": {"$in":["stephen2","stephen1"]}}})
            { "_id" : ObjectId("4fd58ecbb9ac507e96276f1a"), "name" : "stephen", "age" : 35,"genda" : "male", "email" : "[email protected]" }
    3、null数据类型的查询：
        --在进行值为null数据的查询时，所有值为null，以及不包含指定键的文档均会被检索出来。
            > db.test.find({"x":null})
            { "_id" : ObjectId("4fd59d30b9ac507e96276f1b"), "x" : null }
            { "_id" : ObjectId("4fd59d49b9ac507e96276f1c"), "y" : 1 }
        --需要将null作为数组中的一个元素进行相等性判断，即便这个数组中只有一个元素。
        --再有就是通过$exists判断指定键是否存在。
            > db.test.find({"x": {"$in": [null], "$exists":true}})
            { "_id" : ObjectId("4fd59d30b9ac507e96276f1b"), "x" : null }
    4、正则查询：
        --MongoDB中使用了Perl规则的正则语法。如：
            > db.test.find()
            { "_id" : ObjectId("4fd59ed7b9ac507e96276f1d"), "name" : "stephen" }
            { "_id" : ObjectId("4fd59edbb9ac507e96276f1e"), "name" : "stephen1" }
        --i表示忽略大小写
            > db.test.find({"name":/stephen?/i})
            { "_id" : ObjectId("4fd59ed7b9ac507e96276f1d"), "name" : "stephen" }
            { "_id" : ObjectId("4fd59edbb9ac507e96276f1e"), "name" : "stephen1" } 
    5、数组数据查询：
        --基于数组的查找。
            > db.test.find()
            { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", "peach" ] }
            { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "apple", "kumquat","orange" ] }
            { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana","apple" ] }
        --数组中所有包含banana的文档都会被检索出来。
            > db.test.find({"fruit":"banana"})
            { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", "peach" ] }
            { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana","apple" ] }
        --检索数组中需要包含多个元素的情况，这里使用$all。下面的示例中，数组中必须同时包含apple和banana，但是他们的顺序无关紧要。
            > db.test.find({"fruit": {"$all": ["banana","apple"]}})
            { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", "peach" ] }
            { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana", "apple" ] } 
        --下面的示例表示精确匹配，即被检索出来的文档，fruit值中的数组数据必须和查询条件完全匹配，即不能多，也不能少，顺序也必须保持一致。
            > db.test.find({"fruit":["apple","banana","peach"]})
            { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", peach" ] } 
        --下面的示例将匹配数组中指定下标元素的值。数组的起始下标是0。
            > db.test.find({"fruit.2":"peach"})
            { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", peach" ] } 
        --可以通过$size获取数组的长度，但是$size不能和比较操作符联合使用。
            > db.test.find({"fruit": {$size : 3}})
            { "_id" : ObjectId("4fd5a177b9ac507e96276f1f"), "fruit" : [ "apple", "banana", "peach" ] }
            { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "apple", "kumquat","orange" ] }
            { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana","apple" ] } 
        --如果需要检索size > n的结果，不能直接使用$size，只能是添加一个额外的键表示数据中的元素数据，在操作数据中的元素时，需要同时更新size键的值。
        --为后面的实验构造数据。
            > db.test.update({}, {"$set": {"size":3}},false,true)
            > db.test.find()
            { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "apple", "kumquat", "orange" ], "size" : 3 }
            { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana", "apple" ], "size" : 3 } 
        --每次添加一个新元素，都要原子性的自增size一次。
            > test.update({},{"$push": {"fruit":"strawberry"},"$inc":{"size":1}},false,true)
            > db.test.find()
            { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "apple", "kumquat", "orange", "strawberry" ], "size" : 4 }
            { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana", "apple", "strawberry" ], "size" : 4 }
        --通过$slice返回数组中的部分数据。"$slice":2表示数组中的前两个元素。
            > db.test.find({},{"fruit": {"$slice":2}, "size":0})
            { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "apple", "kumquat" ]}
            { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "cherry", "banana" ]} 
        --通过$slice返回数组中的部分数据。"$slice":-2表示数组中的后两个元素。
            > db.test.find({},{"fruit": {"$slice":-2}, "size":0})
            { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "orange", "strawberry" ] }
            { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "apple", "strawberry" ] }
        --$slice : [2,1]，表示从第二个2元素开始取1个，如果获取数量大于2后面的元素数量，则取后面的全部数据。
            > db.test.find({},{"fruit": {"$slice":[2,1]}, "size":0})
            { "_id" : ObjectId("4fd5a18cb9ac507e96276f20"), "fruit" : [ "orange" ] }
            { "_id" : ObjectId("4fd5a1f0b9ac507e96276f21"), "fruit" : [ "apple" ] }
    6、内嵌文档查询：
        --为后面的示例构造测试数据。
            > db.test.find()
            { "_id" : ObjectId("4fd5ada3b9ac507e96276f22"), "name" : { "first" : "Joe", "last" : "He" }, "age" : 45 }
        --当嵌入式文档为数组时，需要$elemMatch操作符来帮助定位某一个元素匹配的情况，否则嵌入式文件将进行全部的匹配。
        --即检索时需要将所有元素都列出来作为查询条件方可。
            > db.test.findOne()
            {
                 "_id" : ObjectId("4fd5af76b9ac507e96276f23"),
                 "comments" : [
                     {
                         "author" : "joe",
                         "score" : 3
                     },
                     {
                         "author" : "mary",
                         "score" : 6
                     }
                 ]
            }
            > db.test.find({"comments": {"$elemMatch": {"author":"joe","score":{"$gte":3}}}}
            { "_id" : ObjectId("4fd5af76b9ac507e96276f23"), "comments" : [ { "author" : "joe", "score" : 3 }, { "author" : "mary", "score" : 6 } ] }
    7、游标：
        数据库使用游标来返回find()的执行结果，客户端对游标可以进行有效的控制，如：限定结果集的数量、跳过部分结果、基于任意键的任意方向的排序等。
        下面的例子将用于准备测试数据。
            > db.testtable.remove()
            > for (i = 0; i < 10; ++i) {
            ... db.testtable.insert({x:i})
            ... }
        我们可以通过cursor提供的hasNext()方法判断是否还有未读取的数据，再通过next()方法读取结果集中的下一个文档。如：
            > var c = db.testtable.find()
            > while (c.hasNext()) {
            ... print(c.next().x)
            ... }
            0
            1
            2

        当调用find()的时候，shell并不立即查询数据库，而是等待真正开始要求获得结果的时候才发送查询，这样在执行之前可以给查询附加额外的选项。几乎所有的游标方法都返回本身，因此可以像下面这样将游标的方法链式组合起来。如：
            > var c1 = db.testtable.find().sort({"x":1}).limit(1).skip(4);
            > var c2 = db.testtable.find().limit(1).sort({"x":1}).skip(4);
            > var c3 = db.testtable.find().skip(4).limit(1).sort({"x":1});
        此时，查询并未执行，所有这些函数都是在构造查询，当执行下面的语句时，查询将被真正执行，
            > c.hasNext()
        查询被发送到服务器，MongoDB服务器每次将返回一批数据，当本批被全部迭代后再从服务器读取下一批数据，直至查询结果需要的数据被全部迭代。
        对于上面的示例，limit(1)表示输出结果仅为一个，如果小于1，则不输出，即limit(n)函数限定的是最多输出结果。skip(4)表示跳过查询结果中的前4个文档，如果结果小于4，则不会返回任何文档。sort({"x":1})用于设定排序条件，即按照x键以升序(1)的方式排序，如果需要降序排序可以改为：sort({"x":-1})。sort也可以支持多键排序，如：sort({username:1, age:-1})即先按照username进行升序排序，如果username的值相同，再以age键进行降序排序。这里需要指出的是，如果skip过多的文档，将会导致性能问题。 
    8、对某字段求和
        db.getCollection('DATA_MONITOR_INFO').aggregate( { $group :  { _id : null,  sum : { $sum : "$successCount" } } });

        
db.getCollection('ALL_CARD_BLACK_TEMP').find({}).count();
db.getCollection('ALL_CARD_BLACK').find({}).count();
db.getCollection('ALL_OBU_BLACK_TEMP').find({}).count();
db.getCollection('ALL_OBU_BLACK').find({}).count();

mongodb 脚本导入导出数据
    导入：在mongodb安装的bin目录下执行 
        mongoimport.exe -h localhost --port 27017 -d TRANSFER_RCVPACK_TEMP -c ORIGINAL --type json --file D:\SoftWare\db\mongodb\orig.json
        mongoimport --host localhost --port 27017 --username ezsonaruser --password 123456 --collection host_locations_test --db ezsonar_25 --file /root/shaql/host_locations.json
    导出：在mongodb安装的bin目录下执行 
        命令：
            ./mongoexport --host 10.208.61.115 --port 20000 --username goin --password golaxyintelligence --authenticationDatabase "admin" --db USBill --collection bill --out /home/jianlin/softWare/bill.json
        说明：
            --host 后的 localhost：要导出数据库 ip
            --port 后的 27017：要导出的实例节点端口号
            --username 后的 ezsonaruser：数据库用户名
            --password 后的 123456：数据库用户密码
            --collection 后的 widgets-test：要导出的表名
            --db 后的 ezsonar_25：要导出的表所在数据库名
            --out 后的 /root/host_locations.json：要导出的文件路径(默认为当前文件夹)
            --type json/csv
            --authenticationDatabase
            -f, --fields：代表集合中的字段，可以根据设置选择导出的字段；
            --type：代表导出输出的文件类型，包括csv和json文件；
            --skip：跳过指定数量的数据；
            --limit：读取指定数量的数据记录；
            --sort：对数据进行排序，可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列,如sort({KEY:1})。

按条件查询，删除需要的字段
    db.yourcollection.update(
        {"需要删除的字段": {"$exists": true}, ...其他条件}, 
        {"$unset": {"需要删除的字段":null}}, 
        { multi: true}
    )

    db.news_bd1.update(
        {"_corenlu_stage": {"$exists": true},  "_nlu_cont":{}}, 
        {"$unset": {"_corenlu_stage":null}}, 
        { multi: true}
    )