编辑：修改为发出数组：

Question

我有一个MongoDB集合，其文档使用多个级别的嵌套，我想从中提取从其字段的子集编译的多维数组。我现在有一个适合我的解决方案，但我想更好地理解“幂等”的概念及其与减少功能相关的后果。

{
  "host_name" : "gateway",
  "service_description" : "PING",
  "last_update" : 1305777787,
  "performance_object" : [
    [ "rta", 0.105, "ms", 100, 500, 0 ],
    [ "pl", 0, "%", 20, 60, 0 ]
  ]
}

这是map / reduce函数

var M = function() {
  var hn = this.host_name, 
      sv = this.service_description, 
      ts = this.last_update;
  this.performance_object.forEach(function(P){
    emit( { 
      host: hn, 
      service: sv, 
      metric: P[0] 
    }, { 
      time: ts, 
      value: P[1] 
    } );
  });
}
var R = function(key,values) {
  var result = { 
    time: [], 
    value: [] 
  };
  values.forEach(function(V){
    result.time.push(V.time);
    result.value.push(V.value);
  });
  return result;
}
db.runCommand({
  mapreduce: <colname>,
  out: <col2name>,
  map: M,
  reduce: R
});

数据以一个有用的结构返回，我将其重新格式化/排序并使用finalize进行绘图。

{
  "_id" : {
    "host" : "localhost",
    "service" : "Disk Space",
    "metric" : "/var/bck"
  },
  "value" : {
    "time" : [
      [ 1306719302, 1306719601, 1306719903, ... ],
      [ 1306736404, 1306736703, 1306737002, ... ],
      [ 1306766401, 1306766701, 1306767001, ... ]
    ],
    "value" : [
      [ 122, 23423, 25654, ... ],
      [ 336114, 342511, 349067, ... ],
      [ 551196, 551196, 551196, ... ]
    ]
  }
}

...最后

 [ [1306719302,122], [1306719601,23423], [1306719903,25654], ... ]

TL; DR：数组结果的超级“分块”的预期行为是什么？

我知道可以在发射值的数组上多次调用reduce函数，这就是为什么有几个完整数组的“块”而不是单个数组。阵列块通常是25-50个项目，并且很容易在finalize（）中清除它。我concat（）数组，将它们交错为[时间，值]和排序。但我真正想知道的是，这会变得更复杂：

1）由于我的代码，MongoDB的实现或Map / Reduce算法本身，是否观察到了分块？

2）在分片配置中是否会有更深层次（递归）的数组块嵌套，甚至只是因为我的草率实现？这会破坏concat（）方法。

3）如上所示，是否有更好的策略来获取数组结果？

编辑：修改为发出数组：

我接受了Thomas的建议并重新编写它以发射阵列。分割价值绝对没有任何意义。

var M = function() {
  var hn = this.host_name, 
      sv = this.service_description, 
      ts = this.last_update;
  this.performance_object.forEach(function(P){
    emit( { 
      host: hn, 
      service: sv, 
      metric: P[0] 
    }, { 
      value: [ ts, P[1] ] 
    } );
  });
}
var R = function(key,values) {
  var result = {
    value: [] 
  };
  values.forEach(function(V){
    result.value.push(V.value);
  });
  return result;
}
db.runCommand({
  mapreduce: <colname>,
  out: <col2name>,
  map: M,
  reduce: R
});

现在输出类似于：

{
  "_id" : {
    "host" : "localhost",
    "service" : "Disk Space",
    "metric" : "/var/bck"
  },
  "value" : {
    "value" : [
      [ [1306736404,336114],[1306736703,342511],[1306737002,349067], ... ],
      [ [1306766401,551196],[1306766701,551196],[1306767001,551196], ... ],
      [ [1306719302,122],[1306719601,122],[1306719903,122], ... ]
    ]
  }
}

我使用这个finalize函数来连接数组块并对它们进行排序。

...
var F = function(key,values) {
  return (Array.concat.apply([],values.value)).sort(function(a,b){ 
    if (a[0] < b[0]) return -1;
    if (a[0] > b[0]) return 1;
    return 0;
  });
}
db.runCommand({
  mapreduce: <colname>,
  out: <col2name>,
  map: M,
  reduce: R,
  finalize: F
});

哪个效果很好：

{
  "_id" : {
    "host" : "localhost",
    "service" : "Disk Space",
    "metric" : "/mnt/bck"
  },
  "value" : [ [1306719302,122],[1306719601,122],[1306719903,122],, ... ]
}

我想唯一能扼杀我的问题是，是否可以信任这个Array.concat.apply（[]，values.value）来清理减少所有时间的输出。

最后编辑：更简单......

自上面给出的原始示例以来，我修改了文档结构，但这只是通过使map函数非常简单来改变示例。

我仍然试图将我的大脑包围起来为什么Array.prototype.push.apply（结果，V.data）与result.push（V.data）的工作方式有所不同......但是它有效。

var M = function() {
  emit( { 
    host: this.host, 
    service: this.service, 
    metric: this.metric
  } , { 
    data: [ [ this.timestamp, this.data ] ] 
  } );
}
var R = function(key,values) {
  var result = [];
  values.forEach(function(V){
    Array.prototype.push.apply(result, V.data);
  });
  return { data: result };
}
var F = function(key,values) {
  return values.data.sort(function(a,b){
    return (a[0]<b[0]) ? -1 : (a[0]>b[0]) ? 1 : 0;
  });
}

它具有与最后编辑标题正上方相同的输出。

谢谢，托马斯！

Answer 1

“chunking”来自您的代码：您的reduce函数的values参数可以包含从map函数发出的{time:<timestamp>,value:<value>}，或者从之前调用reduce函数返回的{time:[<timestamps>],value:[<values]}。
我不知道它是否会在实践中发生，但理论上可能会发生。
只需让你的map函数发出你的reduce函数返回的相同类型的对象，即emit(<id>, {time: [ts], value: [P[1]]})，然后相应地改变你的reduce函数，即Array.push.apply(result.time, V.time)，同样地result.value }。

我实际上不明白为什么你没有使用时间/值对的数组，而不是一对数组，即map函数中的emit(<id>, { pairs: [ {time: ts, value: P[1] ] })或emit(<id>, { pairs: [ [ts, P[1]] ] })，{在reduce函数中{1}}。这样，你甚至不需要finalize函数（除了可以从对属性“解包”数组：因为reduce函数不能返回一个数组，你必须以这种方式包装它一个对象）

MongoDB Map / Reduce Array聚合问题

编辑：修改为发出数组：

最后编辑：更简单......

1 个答案: