Question

我有三份文件：

[
  { _id: 1, article: 1, details: { color: "red" } },
  { _id: 2, article: 1, details: { color: "blue", size: 44 },
  { _id: 3, article: 2, details: { color: "blue", size: 44 }
]

我想在查询中转换为：

[
  { article: 1, details: { color: ["red", "blue"], size: [44] } },
  { article: 2, details: { color: ["blue"], size: [44] }
]

目前这是通过mapReduce实现的：

db.varieties.mapReduce(map, reduce, { out: { inline: 1 } });

function map() {
  for (var key in this.details) {
    this.details[key] = [this.details[key]];
  }

  emit(this.article, this.details);
}

function reduce(article, details) {
  var result = {};

  details.forEach(function(detail) {
    for (var key in detail) {
      if (!Array.isArray(result[key])) result[key] = [];
      if (~result[key].indexOf(detail[key])) result[key].concat(detail[key]);
    }
  });
  return result;
}

但是我想通过mongodb聚合框架工作来实现这一点，因为我的环境中的地图缩减实现非常困难＆＃34;。

关于我到目前为止的聚合：

var pipeline = [];

pipeline.push({ $project: { article: 1, details: 1 } });
pipeline.push({ $group: { _id: "$article", details: { $push: '$details' } });

db.varieties.aggregate(pipeline);

然而，这只会返回：

[
  { article: 1, details: [{ color: "red", size: 44 }, { color: "blue", size: 44 }] },
  { article: 2, details: [{ color: "blue", size: 44 }]
]

我在某处读到这是$unwind的一个用例，遗憾的是这对象不起作用。

让我们回答一下我的问题：

是否有可能以某种方式将details对象转换为具有{ key: "color", value: "red" }的数组，如果是，如何实现此目标？
如果以上是不可能的，我会将我的文档重组为以上述格式存储（详细信息为数组），我如何完成聚合以从我的原始mapReduce获得相同的结果？

我无法对细节的密钥进行硬编码。聚合必须处理未知密钥的详细信息。

Answer 1

您最好使用聚合框架：

db.colors.aggregate([
    { "$group": {
        "_id": "$article",
        "color": {"$addToSet": "$details.color" },
        "size": { "$addToSet": "$details.size" }
    }},
    { "$project": {
        "details": {
            "color": "$color",
            "size": "$size"
        }
    }}
])

产地：

{ "_id" : 2, "details" : { "color" : [ "blue" ], "size" : [ 44 ] } }
{ "_id" : 1, "details" : { "color" : [ "blue", "red" ], "size" : [ 44 ] } }

所以你不能把这些钥匙放在＆＃34;细节＆＃34;当您$group时，您可以始终$project到结果中所需的表单。

聚合框架是一个本机代码实现，运行速度比JavaScript解释器驱动的mapReduce快得多。

但是如果你真的需要灵活性这个概念是相似的，它只需要更长的时间，但可以在细节下使用不同的键：

db.colors.mapReduce(
  function () {
    emit( this.article, this.details );
  },
  function (key,values) {

      var reduced = {
      };

      values.forEach(function(value) {
        for ( var k in value ) {
          if ( !reduced.hasOwnProperty(k) )
            reduced[k] = [];
          if ( reduced[k].indexOf( value[k] ) == -1 )
            reduced[k].push( value[k] );
        }

      });

      return reduced;

  },
  {
      "finalize": function(key,value) {

        for (var k in value) {
          if ( Object.prototype.toString.call( value[k] ) !== '[object Array]') {
            var replace = [];
            replace.push( value[k] );
            value[k] = replace;
          }

        }

        return value;
      },
      "out": { "inline": 1 }
  }
)

但这一切都在一个非常＆＃34; mapReduce＆＃34;因此，主要字段的值将会不同。

{ "_id" : 1, "value" : { "color" : [ "blue", "red" ], "size" : [ 44 ] } }
{ "_id" : 2, "value" : { "color" : [ "blue" ], "size" : [ 44 ] } }

MongoDB将对象映射到不同的值

1 个答案: