我有一个集合，其中的元素可以简化为:

{
  t1 : [1, 3, 6],
  t2 : [8, 9]
}

were in t1 和 t2 可以是 1 到 10 个正整数，不能重复。我需要计算集合中所有文档的 t1 和 t2 中每个数字有多少。

例如，如果我的收藏包含 3 个文档:

{
  t1 : [1, 3, 6],
  t2 : [8, 9]
}, {
  t1 : [1, 2],
  t2 : [8]
}, {
  t1 : [6],
  t2 : [8, 1]
}

我应该有类似的东西

t1 : {
   1 : 2,   // there are 2 elements of 1 in t1
   3 : 1,   // there is 1 element of 3 in t1
   6 : 2,
   2 : 1
}

t2 : {
  8 : 3,    // there are 3 elements of 8 in t2
  9 : 1,
  1 : 1
}

我目前正在做的事情是这样的:

var t1 = {}, t2 = {};
db.coll.find().forEach(function(e){
   // where I am iterating through each element in t1 and t2 to
   // and increase/populate values in t1 and t2
})

虽然这种方法没有错，但我认为聚合框架有更好的方法。是否可以只使用一次聚合来做到这一点？

P.S. 我在示例中显示的输出只是一个示例。任何可以给我所需信息的输出都是合适的。

最佳答案

聚合的单一形式:

db.tags.aggregate([
    { "$project": {
        "_id": 0,
        "t1": 1,
        "t2": 2,
        "type": { "$literal": ["t1","t2"] }
    }},
    { "$unwind": "$type" },
    { "$project": {
        "type": 1,
        "value": { 
            "$cond": [
                { "$eq": [ "$type", "t1" ] },
                "$t1",
                "$t2"
            ]
        } 
    }},
    { "$unwind": "$value" },
    { "$group": {
        "_id": {
            "type": "$type",
            "value": "$value"
        },
        "count": { "$sum": 1 }
    }},
    { "$sort": { "_id.type": 1, "_id.value": 1 } }
])

并输出:

{ "_id" : { "type" : "t1", "value" : 1 }, "count" : 2 }
{ "_id" : { "type" : "t1", "value" : 2 }, "count" : 1 }
{ "_id" : { "type" : "t1", "value" : 3 }, "count" : 1 }
{ "_id" : { "type" : "t1", "value" : 6 }, "count" : 2 }
{ "_id" : { "type" : "t2", "value" : 1 }, "count" : 1 }
{ "_id" : { "type" : "t2", "value" : 8 }, "count" : 3 }
{ "_id" : { "type" : "t2", "value" : 9 }, "count" : 1 }

或者，如果您更喜欢单个文档，只需将结束阶段替换为 $group , 和 $project :

    { "$group": {
        "_id": null,
        "t1": {
            "$push": {
                "$cond": [
                    { "$eq": [ "$_id.type", "t1" ] },
                    { "value": "$_id.value", "count": "$count" },
                    false
                ]
            }
        },
        "t2": {
            "$push": {
                "$cond": [
                    { "$eq": [ "$_id.type", "t2" ] },
                    { "value": "$_id.value", "count": "$count" },
                    false
                ]
            }
        },
    }},
    { "$project": {
        "_id": 0,
        "t1": { "$setDifference": [ "$t1", [false] ] },
        "t2": { "$setDifference": [ "$t2", [false] ] }
    }}

结果:

{ 
    "t1" : [ 
        { "value" : 2, "count" : 1 }, 
        { "value" : 6, "count" : 2 }, 
        { "value" : 3, "count" : 1 }, 
        { "value" : 1, "count" : 2 } 
    ], 
    "t2" : [ 
        { "value" : 1, "count" : 1 },
        { "value" : 9, "count" : 1 },
        { "value" : 8, "count" : 3 } 
    ] 
}

这些无需使用 MongoDB 2.6 中的新运算符即可实现，只是需要多做一些工作。

mapReduce 方法看起来相当简单。由于 mapReduce 的限制，输出当然不是您的格式，但它无需迭代查询即可获得结果:

db.collection.mapReduce(
    function () {
      delete this["_id"];

      for ( var k in this ) {
        var list = this[k];
        list.forEach(function(v) {
          emit( { k: k , v: v }, 1 );
        });
      }
    },
    function (key,values) {
      return values.length;
    },
    { "out": { "inline": 1 } }
)

输出将是:

{ "_id" : { "k" : "t1", "v" : 1 }, "value" : 2 }
{ "_id" : { "k" : "t1", "v" : 2 }, "value" : 1 }
{ "_id" : { "k" : "t1", "v" : 3 }, "value" : 1 }
{ "_id" : { "k" : "t1", "v" : 6 }, "value" : 2 }
{ "_id" : { "k" : "t2", "v" : 1 }, "value" : 1 }
{ "_id" : { "k" : "t2", "v" : 8 }, "value" : 3 }
{ "_id" : { "k" : "t2", "v" : 9 }, "value" : 1 }

还取决于您是否需要灵活使用“键”名称。

关于mongodb - 聚合计算每个标签的数量，这里有两种类型的标签，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/23863255/