我的收藏看起来是这样的，

{
    "_id" : ObjectId("55c8bd1d85b83e06dc54c0eb"),
    "name" : "xxx",
    "salary" : 10000,
    "type" : "type1"
}
{
    "_id" : ObjectId("55c8bd1d85b83e06dc54c0eb"),
    "name" : "aaa",
    "salary" : 10000,
    "type" : "type2"
}
{
    "_id" : ObjectId("55c8bd1d85b83e06dc54c0eb"),
    "name" : "ccc",
    "salary" : 10000,
    "type" : "type2"
}

我的查询参数将作为，

{salary=10000, type=type2}

所以根据查询我需要获取上述查询参数的计数

结果应该是这样的,

{ category: 'type1', count: 500 } { category: 'type2', count: 200 } { category: 'name', count: 100 }

现在我通过点击三个不同的查询并构建结果(或)服务器端迭代来计算我可以获得的结果。

任何人都可以建议或提供我获得上述结果的好方法

最佳答案

您的问题没有很清楚地呈现，但您似乎想在这里做的是计算字段中数据的出现次数，可选择按符合条件的值过滤这些字段。

这里是 $cond运算符允许您转换 logical condition转化为一个值:

db.collection.aggregate([
    { "$group": {
        "_id": null,
        "name": { "$sum": 1 },
        "salary": { 
            "$sum": { 
                "$cond": [
                    { "$gte": [ "$salary", 1000 ] },
                    1,
                    0
                ]
            }
        },
        "type": { 
            "$sum": { 
                "$cond": [
                    { "$eq": [ "$type", "type2" ] },
                    1,
                    0
                ]
            }
        }
    }}
])

所有值都在同一个文档中，在这里将它们分开没有任何意义，因为这是管道中的额外工作。

{ "_id" : null, "name" : 3, "salary" : 3, "type" : 2 }

否则在长格式中，由于需要为每个键制作每个文档的副本，因此性能不是很好，如下所示:

db.collection.aggregate([
  { "$project": {
    "name": 1,
    "salary": 1,
    "type": 1,
    "category": { "$literal": ["name","salary","type"] }
  }},
  { "$unwind": "$category" },
  { "$group": {
    "_id": "$category",
    "count": {
      "$sum": {
        "$cond": [
          { "$and": [ 
            { "$eq": [ "$category", "name"] },
            { "$ifNull": [ "$name", false ] }
          ]},
          1,
          { "$cond": [
            { "$and": [
              { "$eq": [ "$category", "salary" ] },
              { "$gte": [ "$salary", 1000 ] }
            ]},
            1,
            { "$cond": [
              { "$and": [
                { "$eq": [ "$category", "type" ] },
                { "$eq": [ "$type", "type2" ] }
              ]},
              1,
              0
            ]}
          ]}
        ]
      }
    }
  }}
])

它的输出:

{ "_id" : "type",   "count" : 2 }
{ "_id" : "salary", "count" : 3 }
{ "_id" : "name",   "count" : 3 }

如果您的文档没有统一的键名或无法在管道条件中指定每个键，请使用 mapReduce 申请相反:

db.collection.mapReduce(
    function() {
        var doc = this;
        delete doc._id;

        Object.keys(this).forEach(function(key) {
          var value = (( key == "salary") && ( doc[key] < 1000 ))
              ? 0
              : (( key == "type" ) && ( doc[key] != "type2" ))
              ? 0
              : 1;

          emit(key,value);
        });
    },
    function(key,values) {
        return Array.sum(values);
    },
    {
        "out": { "inline": 1 }
    }
);

它的输出:

    "results" : [
            {
                    "_id" : "name",
                    "value" : 3
            },
            {
                    "_id" : "salary",
                    "value" : 3
            },
            {
                    "_id" : "type",
                    "value" : 2
            }
    ]

这与条件计数基本相同，只是您仅指定所需条件的“反向”，并且仅指定要过滤条件的字段。当然，这种输出格式很容易作为单独的文档发出。

相同的方法适用于在您想要条件的字段上测试条件是否满足，并在满足条件的情况下返回 1 或在不满足条件的情况下返回 0对计数求和。

关于MongoDB基于多个查询字段的聚合计数-(Multiple field count)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32032598/