这是我的 MongoDB 集合架构:

company: String
model: String
cons: [String] // array of tags that were marked as "cons"
pros: [String] // array of tags that were marked as "pros"

我需要对其进行汇总，以便获得以下输出:

[{
  "_id": {
    "company": "Lenovo",
    "model": "T400"
  },
  "tags": {
    tag: "SomeTag"
    pros: 124 // number of times, "SomeTag" tag was found in "pros" array in `Lenovo T400`
    cons: 345 // number of times, "SomeTag" tag was found in "cons" array in `Lenovo T400`
  }
}...]

我尝试执行以下操作:

var aggParams = {};
aggParams.push({ $unwind: '$cons' });
aggParams.push({ $unwind: '$pros' });
aggParams.push({$group: {
  _id: {
    company: '$company',
    model: '$model',
    consTag: '$cons'
  },
  consTagCount: { $sum: 1 }
}});
aggParams.push({$group: {
  _id: {
    company: '$_id.company',
    model: '$_id.model',
    prosTag: '$pros'
  },
  prosTagCount: { $sum: 1 }
}});
aggParams.push({$group: {
  _id: {
    company:'$_id.company',
    model: '$_id.model'
  },
  tags: { $push: { tag: { $or: ['$_id.consTag', '$_id.prosTag'] }, cons: '$consTagCount', pros: '$prosTagCount'} }
}});

但我得到了以下结果:

{
  "_id": {
    "company": "Lenovo",
    "model": "T400"
  },
  "tags": [
    {
      "tag": false,
      "pros": 7
    }
  ]
}

使用聚合的正确方法是什么？

最佳答案

是的，考虑到有多个数组，这有点困难，如果您同时尝试两个数组，您最终会得到一个“笛卡尔条件”，其中一个数组乘以另一个数组的内容。

所以，就把数组内容组合在最开始，这大概说明了你一开始应该怎么存储数据:

Model.aggregate(
    [
        { "$project": {
            "company": 1,
            "model": 1,
            "data": {
                "$setUnion": [
                    { "$map": {
                        "input": "$pros",
                        "as": "pro",
                        "in": {
                            "type": { "$literal": "pro" },
                            "value": "$$pro"
                        }
                    }},
                    { "$map": {
                        "input": "$cons",
                        "as": "con",
                        "in": {
                            "type": { "$literal": "con" },
                            "value": "$$con"
                        }
                    }}
                ]
            }
        }},
        { "$unwind": "$data" }
        { "$group": {
            "_id": { 
                "company": "$company",
                "model": "$model",
                "tag": "$data.value"
            },
            "pros": { 
                "$sum": { 
                    "$cond": [
                        { "$eq": [ "$data.type", "pro" ] },
                        1,
                        0
                    ]
                }
            },
            "cons": { 
                "$sum": { 
                    "$cond": [
                        { "$eq": [ "$data.type", "con" ] },
                        1,
                        0
                    ]
                }
            }
        }
    ], 
    function(err,result) {

    }
)

所以通过第一个 $project舞台$map运算符将“类型”值添加到每个数组的每个项目。在这里并不重要，因为无论如何所有项目都应该处理“唯一”，$setUnion运算符将每个数组“连接”成一个单一数组。

如前所述，您可能首先应该以这种方式存储。

然后处理$unwind其次是 $group ，然后通过 $cond 评估每个“优点”和“缺点”为匹配“类型”，返回 1 或 0，其中匹配分别为 true/false 到 $sum聚合累加器。

这为您提供了一个“逻辑匹配”，可以根据指定的分组键对聚合操作中的每个相应“类型”进行计数。

关于node.js - MongoDB 汇总不同文档中两个数组中的项目数？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32155801/