mongodb 常用语句

不积跬步，无以至千里；不积小流，无以成江海。

【修改-update】-------------------------------------------------------------

语法格式如下：

db.collection.update(
　　<query>,
　　<update>,
　　{
　　　　upsert:<boolean>,
　　　　multi:<boolean>,
　　　　writeConcern:<document>
　　}
)

参数说明：

• query:update的查询条件，类似sql update查询内where后面的。
• update：update的对象和一些更新符的操作（如$,$inc...）等，也可以理解为sql update查询内set后面的内容
• upsert：可选，意思事如果不存在update的记录，是否插入objNew，true为插入，默认是false，不插入。
• multi：可选，默认是false，只更新找到的第一条记录，如果这个参数为true，就把按条件查出来多条记录全部更新。
• writeConcern：可选，抛出异常的级别

例如：db.getCollection('CollectionName').update({xm:'张三0',xmpy:'zs0'},{$set:{xb:'0'}},{multi:true});

 

【索引】 ----------------------------------------------------

创建索引：

 db.CollectionName.ensureIndex({"字段名":-1}) 

 db.CollectionName.createIndex({"字段名":"hashed"})

 

查询条件中针对某个字段使用大于、大于等于、小于、小于等于、等于、不等于判断

$gt: 大于

$gte: 大于等于

$lt: 小于 

$lte: 小于等于

$eq: 等于 

$ne: 不等于

 

#相当于mysql里面的 select dm,count(distict dmmc) from tabelName group by dm
db.CollectionName.aggregate([ 
　　{$group:{_id:{"dm" : "$dm"},uniqueCount: {$addToSet: "$dmmc"}}},
　　{$project:{"dm":1,tj:{$size:"$uniqueCount"}} } 
]);

 

#修改字段
db.表名.update({},{$unset:{"原来的字段":"新字段","原来的字段":"新字段"}})
#删除字段
db.表名.update({},{$unset:{"原来的字段":"","原来的字段":""}})

 

 

#指定返回字段
db.getCollection("表名").find({"查询字段":"01"}，{字段名：1，字段名：1})

#聚合查询多个字段以XX开头的数据

var res = db.表名.aggregate([
　　{$match:{$or:[
　　　　　　{"字段名"：{$regex:"^61.*"}},
　　　　　　{"字段名"：{$regex:"^61.*"}},
　　　　]}
　　}
])
while(res.hasNext()){
　　var re = res.next();
　　db.另一个表名.insert(re);
}

#或者查询对应Java代码

 

 

 

#普通的统计 带多条件查询  分组统计多字段
db.CollectionName.aggregate([
    {$match:
    { 
        $and:
        [
            {"dm" : { "$regex" : "1"}},
            {"dmlx":"MAP_HYZK"}
        ]
    }},
    {$group: { "_id" : {"dmlx":"$dmlx","dm":"$dm"}, tj : { $sum : 1}}}
])

#普通的统计 带多条件查询  分组统计单字段

db.CollectionName.aggregate([
    {$match:
    { 
        $and:
        [
            {"dm" : { "$regex" : "1"}},
            {"dmlx":"MAP_HYZK"}
        ]
    }},
    {$group: { "_id" : "$dmlx", tj : { $sum : 1}}}
])

 

//把查出来的数据进行逗号，拼接
db.表名.aggregate([
    {$match:
    { $and:
        [
            {"dm" : { "$regex" : "1"}},
            {"dmlx":"MAP_HYZK"}
        ]
    }},
    {$group: { "_id" : "$post", "dmmc" : { "$push" : "$dmmc"}}}
])

///////////////匹配的java代码
Aggregation aggregation = Aggregation.newAggregation(
　　　　Aggregation.match(匹配查询条件),
　　　　Aggregation.group("dmlx").push("$dmmc").as("dmmc"),
　　　　Aggregation.project("dmmc")
);

AggregationResults<实体类> results = mongoTemplate.aggregate(aggregation, "表名", 实体类.class);
System.out.println("打印获得数据=="+results.getMappedResults().get(0).get字段名);

 

 //把细类字段有，的数据查询出来遍历
db.getCollection("CollectionName").find({"fkmc": {"$regex":","}}).
forEach( 
    function(item) {
        var tmp = [];
        var pjtmp = "";
        tmp = item.fkmc.split(",");//逗号分割为数组
        for(var k in tmp){
            var fhmc = db.getCollection('CollectionName').findOne({"fkzd":tmp[k]},{"fkzd":1});//然后通过分割的细类代码去查询返回名称
            if(fhmc!=null){
                print("====="+fhmc.fkzd);
                pjtmp = pjtmp + fhmc.fkzd + ",";
             }
         }
         print("打印获得的值："+pjtmp);
         item.zddm = pjtmp.substr(0,pjtmp.length-1);
         db.getCollection('CollectionName').save(item);//将修改的数据保存
         //print(item.zddm);
    } 
);

 

 【聚合查询】--------------------------------------------

带split字段分割，再group统计
db.getCollection('表').aggregate([
　　{$match: { "模糊查询字段" : { "$regex" : "^6101.*"}}},
　　{$project : { zdrylb : { $split: ["$zdrylbdm", ","] },gxdwjgdm:1} },
　　{$unwind:"$zdrylb"},
　　{$group : {_id : "$zdrylb", num : {$sum : 1}}}
])


///////////////////////匹配对应的java代码
Pattern pattern = Pattern.compile("^"+dlrdwdm+".*");
//需要分组的字段名
Aggregation aggregation = Aggregation.newAggregation(
        Aggregation.match(Criteria.where("gxdwjgdm").is(pattern)),
        Aggregation.project().andExpression("{ $split: {'$zdrylbdm', ','} }").as("zdrylb"),
        //Aggregation.project().andExpression("{ $substrCP: { '$gxdwjgdm', 0, "+t+" } }").as("gxdwjgdmqz"),
        Aggregation.unwind("$zdrylb"),
        Aggregation.group("$zdrylb").count().as("y"),//.first("$_id").as("x"),
        Aggregation.project("y").and("$_id").as("x")//.previousOperation()
);
AggregationResults<MessageCountTwoVo> outputTypeCount = mongoTemplate.aggregate(aggregation, "t_ythgk_zdry", MessageCountTwoVo.class);
List<MessageCountTwoVo> list = outputTypeCount.getMappedResults();

 

带模糊查询多个字段，再group，并重命名返回字段

db.表名.aggregate([
    {$match:{
        $and:
            [{ "gxdwjgdm" : { "$regex" : "^6101[0-9][1-9].*000000$"}},
            {"zdrylbdm":"01"}]
    }},
    {$group: { "_id" : "$gxdwjgdm", "y" : { "$sum" : 1}, "x" : { "$first" : "$gxdwjgdm"}}},
    {$project: {
        "x": 1,
        "y": 1
    }}
]);
///////////////////////匹配对应的java代码
Pattern pattern1 = Pattern.compile(zz);
Aggregation aggregation = Aggregation.newAggregation(
        Aggregation.match(Criteria.where("gxdwjgdm").is(pattern1).and("zdrylbdm").regex(zdrylbdm)),
        Aggregation.group("gxdwjgdm").count().as("count").first("gxdwjgdm").as("name"),
        Aggregation.project("count","name")//.previousOperation()
);
AggregationResults<MessageCountVo> outputTypeCount = mongoTemplate.aggregate(aggregation, "t_ythgk_zdry", MessageCountVo.class);
List<MessageCountVo> list = outputTypeCount.getMappedResults();