javascript - 计算连续字段出现的最高数量

Question

在这样的集合中:

db.consFieldTest.insert([
    { status : "err" }
    { status : "suc" }
    { status : "res" }
    { status : "res" }
    { status : "err" }
    { status : "err" }
    { status : "err" }
]);

聚合结果应该是这样的:

              { status: "err", maxCons : 3 },
// (optional) { status: "suc", maxCons : 1 },
// (optional) { status: "res", maxCons : 2 }

实际上如果maxCons 计数器停在 3 就可以了，我需要知道 err 状态是否连续出现 3 次或更多。

解决思路:

我想到了一种解决方法，在所有文档上添加增量，如下所示:

{ status : "err", id : 0 },
{ status : "suc", id : 1 },
{ status : "res", id : 2 },
{ status : "res", id : 3 },
{ status : "err", id : 4 },
{ status : "err", id : 5 },
{ status : "err", id : 6 }

然后将它们分组到 0-2、1-3、2-4 等范围内，...这将导致:

{   _id : 0 
    res : [
        { status : "err", id : 0 },
        { status : "suc", id : 1 },
        { status : "res", id : 2 }
    ]
},
{   _id : 1
    res : [
        { status : "suc", id : 1 },
        { status : "res", id : 2 },
        { status : "res", id : 3 },
    ]
},
{
    _id : 2
    res : [
        { status : "res", id : 2 },
        { status : "res", id : 3 },
        { status : "err", id : 4 },
    ]
} ...

有了这个，我可以计算状态 err 以连续顺序出现的频率。但我不知道如何编写这个 group 阶段。

Answer 1

将此作为 aggregation framework 处理的问题问题是没有将一个文档与另一个文档进行比较的实际概念，因为所有操作要么一次对单个文档进行操作，要么将文档组合在一起。

因此，找到“连续”条目需要一个“全局”变量空间才能跨文档工作。聚合框架没有这样做，但问题可以用 mapReduce 解决。 :

db.consFieldTest.mapReduce(
    function() {
        if ( lastSeen != this.status ) {
            lastSeen = this.status;
            list = [];
            counter = 0;
        }

        list.push(this._id);
        counter++;
        emit(lastSeen,{ "list": list, "count": counter });

    },
    function(key,values) {
        var mapped = values.map(function(x) { return x.count });
        return values[mapped.indexOf(Math.max.apply(Math,mapped))];
    },
    { 
        "scope": { "lastSeen": null, "list": [], "counter": 0 },
        "out": { "inline": 1 }
    }
)

简而言之，这将为当前的“状态”值发出一个“键”，同时保留跟踪连续出现的“列表”和“计数器”的全局变量。列表将在这里建立，仅使用 _id 中的数值作为示例，但可以是任何内容:

    { "_id": "err", "values": { "list": [1], "count": 1 }}
    { "_id": "suc", "values": { "list": [2], "count": 1 }}
    { "_id": "res", "values": { "list": [3], "count": 1 }}
    { "_id": "res", "values": { "list": [3,4], "count": 2 }}
    { "_id": "err", "values": { "list": [5], "count": 1 }}
    { "_id": "err", "values": { "list": [5,6], "count": 2 }}
    { "_id": "err", "values": { "list": [5,6,7], "count":3 }}

这基本上就是映射器发出的内容。请注意那里的全局变量的构建。

在 reduce 函数中，所有相同的键一起处理，或者至少在相同键的“组”中，因为这里的 reducer 工作。因此，所有的 reduce 函数都是在该组中找到具有最大计数的值，并返回匹配索引处的奇异项。

你得到的结果本质上是:

    { "_id": "err", "value": { "list": [5,6,7], "count":3 }}
    { "_id": "res", "value": { "list": [3,4], "count": 2 }}
    { "_id": "suc", "value": { "list": [2], "count": 1 }}

mapReduce 按“键”顺序发出最终结果。

是的，JavaScript 评估运行起来比聚合框架慢一点，但是如果没有在文档范围内跟踪全局变量的能力，这就是无法通过其他方式完成的事情。