Question

在mongodb 3.4.5 aggregate中，有以下文件：

{id:1, a:['x','y','z'], b:[2,3,4]}

并希望将其更改为

{id:1, field: [{a:'x', b:2}, {a:'y', b:3}, {a:'z', b:4}]}

如何在aggregate阶段进行操作？

我尝试使用mongodb 3.4.5的$arrayToObject功能，但运气不好......

Answer 1

您实际上想在$zip内$arrayElemAt和$map：

db.collection.aggregate([
  { "$project": {
     "field": { 
       "$map": {
         "input": { "$zip": { "inputs": [ "$a", "$b" ] } },
         "as": "el",
         "in": { 
           "a": { "$arrayElemAt": [ "$$el", 0 ] }, 
           "b": { "$arrayElemAt": [ "$$el", 1 ] }
         }
       }
     }
  }}
])

产生：

{
        "field" : [
                {
                        "a" : "x",
                        "b" : 2
                },
                {
                        "a" : "y",
                        "b" : 3
                },
                {
                        "a" : "z",
                        "b" : 4
                }
        ]
}

$zip执行＆＃34;成对＆＃34; $map使用$arrayElemAt处理每一对，以获取新密钥的每个索引。

作为绝对索引的替代，您可以同时使用$arrayToObject和$objectToArray：

db.collection.aggregate([
  { "$project": {
     "field": {
       "$map": {
         "input": { "$objectToArray": { 
           "$arrayToObject": {
             "$zip": { "inputs": [ "$a", "$b" ] }
           }
         }},
         "as": "el",
         "in": { "a": "$$el.k", "b": "$$el.v" }
       }
     }
  }}
])

同样的事情也是如此，但由于$zip成对地工作，所以它有点多余，所以我们已经知道结果是＆＃34;对＆＃34;使用0和1索引。

逐步详述

首先，您希望$zip创建对：

{ "$project": {
  "_id": 0,
  "field": { "$zip": { "inputs": [ "$a", "$b" ] } }
}}

生成＆＃34;成对＆＃34;来自每个阵列：

{ "field" : [ [ "x", 2 ], [ "y", 3 ], [ "z", 4 ] ] }

此处的$map应该是不言而喻的，因此我们会显示$arrayToObject步骤：

  { "$project": {
    "field": { "$arrayToObject": "$field" }
  }}

这使得这些数组对成为＆＃34;键＆＃34;和＆＃34;价值观＆＃34;：

{ "field" : { "x" : 2, "y" : 3, "z" : 4 } }

然后是$objectToArray：

的转换

  { "$project": {
    "field": { "$objectToArray": "$field" }
  }}

使用键"k"和"v"创建一个对象数组：

{ 
  "field" : [
    { "k" : "x", "v" : 2 },
    { "k" : "y", "v" : 3 },
    { "k" : "z", "v" : 4 } 
  ]
}

然后将其传递给$map以重命名＆＃34;键＆＃34;：

  { "$project": {
    "field": {
      "$map": {
        "input": "$field",
         "as": "el",
         "in": { "a": "$$el.k", "b": "$$el.v" }
      }
    }
  }}

并给出最终结果：

{ 
  "field" : [ 
    { "a" : "x", "b" : 2 },
    { "a" : "y", "b" : 3 },
    { "a" : "z", "b" : 4 }
  ]
}

作为单独的管道阶段（您不应该这样做），但是对于整个示例：

db.collection.aggregate([
  { "$project": {
    "_id": 0,
    "field": { "$zip": { "inputs": [ "$a", "$b" ] } }
  }},
  { "$project": {
    "field": { "$arrayToObject": "$field" }
  }},
  { "$project": {
    "field": { "$objectToArray": "$field" }
  }},
  { "$project": {
    "field": {
      "$map": {
        "input": "$field",
         "as": "el",
         "in": { "a": "$$el.k", "b": "$$el.v" }
      }
    }
  }}
])

但我没有MongoDB 3.4或更高版本

然后，如果您实际上没有将数据用于连续聚合操作，那么使用几乎任何语言都可以非常简单。

例如，使用来自MongoDB shell的JavaScript迭代游标：

db.collection.find().map(doc => {
  doc.field = doc.a.map((e,i) => [e, doc.b[i]]).map(e => ({ a: e[0], b: e[1] }));
  delete doc.a;
  delete doc.b;
  return doc;
})

与初始聚合函数示例中执行的操作完全相同并且完全相同。

现代shell版本或其他JavaScript引擎（甚至可以与较旧的MongoDB版本一起使用）使这更加清晰：

db.collection.find().map(({ a, b }) => 
  ({ field: a.map((e,i) => [e, b[i]]).map(([a,b]) => ({ a, b })) })
)

或者坦率地说......

db.collection.find().map(({ a, b }) =>
  ({ field: a.map((a,i) => ({ a, b: b[i] })) })
)

由于没有必要复制您需要对聚合框架执行的所有步骤，因为您可以直接通过匹配索引转换数组元素。

如何将两个数组连接到一个对象数组中

1 个答案:

逐步详述

但我没有MongoDB 3.4或更高版本