MongoDB Map/Reduce 数组聚合问题

Question

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

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

以下是映射/归约函数

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() 数组，将它们交错为 [time,value] 并排序。但我真正想知道的是这是否会变得更复杂：

1）观察到分块是因为我的代码、MongoDB 的实现还是 Map/Reduce 算法本身？

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

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

编辑：修改为发出数组：

我采纳了托马斯的建议并将其重写为发出数组。分割这些值绝对没有任何意义。

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) 可以一直清理 reduce 的输出。

最后编辑：更简单...

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

我仍在试图弄清楚为什么 Array.prototype.push.apply(result, 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

1. “分块”来自您的代码：您的reduce函数的values参数可以包含从您的map函数发出的{time:,value:}，或者< code>{time:[],value:[ 从上次调用您的reduce函数返回。

2. 我不知道它在实践中是否会发生，但它在理论上是可能发生的。

3. 只需让您的map函数发出与您的reduce函数返回相同类型的对象，即emit(, {time: [ts], value: [P[1]]})，并相应地更改您的reduce函数，即Array.push.apply(result.time, V.time)，对于result.value也类似。

   好吧，我实际上不明白为什么你不使用时间/值对的数组，而不是一对数组，即 emit(, {pairs: [ {time: ts , value: P[1] ] }) 或 map 函数中的 emit(, {pairs: [ [ts, P[1]] ] })，以及在reduce函数中Array.push.apply(result.pairs, V.pairs)。这样，您甚至不需要 Finalize 函数（除了可能从 pairs 属性中“解开”数组：因为reduce 函数无法返回数组，所以您必须以这种方式将其包装在一个对象）