在投影中用大小数组的除法运算编写聚合查询的方法

Question

我想使用SpringDataMongoDB运行这个聚合查询。

db.collectionname.aggregate(
   {
        "$group": {
        "_id": "$searchTerm",
        "dateAddToSet": {
            "$addToSet": "$date"
        }
    }
  },
  {
    "$project": {
        "searchTerm": "$_id.searchTerm",
        "percent": {
            "$divide": [{ "$size": "$dateAddToSet" }, 28]
        }
    }
  })

我找不到在$dataAddToSet大小上写除法运算来执行这个查询的方法。

提前非常感谢。

Answer 1

很抱歉耽误时间。这里的主要问题是$size目前不是springmongo中支持的操作。因此，构造操作的唯一方法是使用DBObject构造。

但是，您可以通过提供自己的包装器类来混合这两种方法，例如：

public class CustomAggregationOperation implements AggregationOperation {
    private DBObject operation;
    public CustomAggregationOperation (DBObject operation) {
        this.operation = operation;
    }
    @Override
    public DBObject toDBObject(AggregationOperationContext context) {
        return context.getMappedObject(operation);
    }
}

因此，通常重写.toDBObject()方法，只返回提供给类构造函数的DBObject数据。

然后在稍后构建聚合时使用：

    Aggregation agg = newAggregation(
            group("searchTerm")
                    .addToSet("date").as("dateAddToSet"),
            new CustomAggregationOperation(
                new BasicDBObject("$project",
                    new BasicDBObject("_id",0)
                        .append("searchTerm","$_id")
                        .append("percent",new BasicDBObject(
                                "$divide", new Object[]{
                                    new BasicDBObject("$size","dateAddToSet"),
                                    28
                                }
                            )
                        )
                )
            )
    );

这就产生了一个具有正确格式的管道：

{ 
    "aggregate" : "__collection__" , 
    "pipeline" : [ 
        { "$group" : { 
            "_id" : "$searchTerm" , 
            "dateAddToSet" : { "$addToSet" : "$date" }
        }}, 
        { "$project" : { 
            "_id" : 0 ,
            "searchTerm" : "$_id" , 
            "percent" : { "$divide" : [ { "$size" : "$dateAddToSet" } , 28] }
        }}
    ]
}

因此，这是将可用的构建器与自定义构建器混合的一种方法，这样您就可以在当前不存在构建器的情况下使用方法。