【修改-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();