node.js - 如何将数据聚合到嵌套数组输出

Question

所以我的集合中有以下数据

{ "UID" : 567, "AN0" : 100, "AN1" : 150, epoch:1401399336437 }
{ "UID" : 123, "AN0" : 200, "AN1" : 250, epoch:1401399336438 }
{ "UID" : 567, "AN0" : 300, "AN1" : 350, epoch:1401399336439 }
...

对于 UID:567 && AN0 我想得到类似于以下内容的输出:

{ key : "AN0",
values: [
  [1401399336437, 100 ]
  [1401399336439, 300 ]
]
}

我已经或多或少地使用 GROUP 完成了它，如下所示:

db.Datasets.group({ 
      cond: {UID: "567", AN0:{$exists:true}, epoch:{$exists:true}},
      initial: {key:"", values: []}, 
      reduce: function(obj, prev){ 
        var temp =[];
        temp.push(obj.epoch);
        temp.push(obj.AN0);
        prev.values.push(temp);
      },
      finalize: function(result){
          result.key = "AN0";
      }
})

但是，当与reduce 和finalize 函数共享作用域时，这种方法给我带来了很多问题。

所以我想对聚合管道做同样的事情

我试过了

db.Datasets.aggregate( [ 
    {$match:{ UID: "567" , AN0: {$exists:true} }}, 
    {$group : { _id: "$UID", value1:  { $push:  "$epoch"}, value2:  { $push:  "$AN0"} }},
] )

我明白

{ value1:[ 1401399336437, 1401399336439 ],
  value2:[ 100, 300 ]

如何改变它以获得

value: [
  [1401399336437, 100 ]
  [1401399336439, 300 ]
]

谢谢!

Answer 1

对我来说，我会以稍微不同的方式进行聚合，然后对结果进行后处理。

var res = db.collection.aggregate([
    { "$group": {
        "_id": "$UID",
        "value": { 
            "$push": {
                "a": "$epoch", "b": "$AN0"
            }
        }
    }}
]).toArray()

此阶段的结果如下所示:

[
    { "_id" : 123, "value" : [ { "a" : 1401399336438, "b" : 200 } ] },
    { "_id" : 567, "value" : [ { "a" : 1401399336437, "b" : 100 }, { a" : 1401399336439, "b" : 300 } ]}
]

现在只需转换:

var res = res.map(function(doc) { 
    doc.value = doc.value.map(function(x){ 
        return [x.a,x.b] 
    }); 
    return doc;
})

但是，如果您真的决心这样做并且拥有可用的 MongoDB 2.6，那么也总有这样的方法:

db.collection.aggregate([
    { "$group": {
        "_id": "$UID",
        "val": { 
            "$push": {
                "a": "$epoch", "b": "$AN0"
            }
        }
    }},
    { "$project": {
        "value": {
            "$map": {
              "input": "$val",
              "as": "el",
              "in": {
                  "$map": {
                      "input": { "$literal": ["A","B"] },
                      "as": "type",
                      "in": {
                          "$cond": [
                              { "$eq": [ "$$type", "A" ] },
                              "$$el.a",
                              "$$el.b"
                          ]
                      }
                  }
              }
            }
        }
    }}
])

窍门就在内部 $map陈述。本质上，这将返回一个数组，指定为源输入的文字 ["A","B"] 。就像“外部”$map 处理从 $push 创建的数组的每个元素一样。 ，“内部”$map 操作处理每个“A”或“B”并测试值。

在 $cond操作，如果当前值为“A”，则返回外部数组元素已保存的变量，因为它是“a”键值，否则返回“b”键值。简而言之，用“内部”的替换形式替换“外部”中的每个元素。现在，您不再是带有键的文档，而是在数组中包含数组。

两种情况下的输出都是您想要的:

[
    {
            "_id" : 123,
            "value" : [
                    [
                            1401399336438,
                            200
                    ]
            ]
    },
    {
            "_id" : 567,
            "value" : [
                    [
                            1401399336437,
                            100
                    ],
                    [
                            1401399336439,
                            300
                    ]
            ]
    }
]