Question

我有这个架构的多个文档，每个文档是每天每个产品：

{
    _id:{},
    app_id:'DHJFK67JDSJjdasj909',
    date:'2014-08-07',
    event_count:32423,
    event_count_per_type: {
        0:322,
        10:4234,
        20:653,
        30:7562
    }
}

我想得到特定日期范围的每个event_type的总和这是我正在寻找的输出，其中每个事件类型已在所有文档中求和。 event_count_per_type的键可以是任何东西，所以我需要能够循环遍历每个键的东西，而不必隐含其名称。

{
    app_id:'DHJFK67JDSJjdasj909',
    event_count:324236456,
    event_count_per_type: {
        0:34234222,
        10:242354,
        20:456476,
        30:56756
    }
}

到目前为止，我一直在尝试几个查询，这是我到目前为止所获得的最好但是子文档值没有求和：

db.events.aggregate(
{
    $match: {app_id:'DHJFK67JDSJjdasj909'}
},
{
    $group: {
        _id: {
            app_id:'$app_id',
        },
        event_count: {$sum:'$event_count'},
        event_count_per_type: {$sum:'$event_count_per_type'}
    }
},
{
    $project: {
        _id:0,
        app_id:'$_id.app_id',
        event_count:1,
        event_count_per_type:1
    }
}
)

我看到的输出是event_count_per_type键的值0，而不是对象。我可以修改模式，因此密钥位于文档的顶层，但这仍然意味着我需要在每个密钥的组语句中都有一个条目，因为我不知道密钥名称是什么我不能做。

任何帮助将不胜感激，我愿意在需要时更改我的架构并尝试mapReduce（尽管从文档中看起来表现不错。）

Answer 1

如上所述，聚合框架无法处理这样的文档，除非您实际上要提供所有密钥，例如：

db.events.aggregate([
   { "$group": {
       "_id": "$app_id",
       "event_count": { "$sum": "$event_count" },
       "0": { "$sum": "$event_count_per_type.0" },
       "10": { "$sum": "$event_count_per_type.10" }
       "20": { "$sum": "$event_count_per_type.20" }
       "30": { "$sum": "$event_count_per_type.30" }
   }}
])

但是，您当然必须明确指定您希望处理的每个键。 MongoDB中的聚合框架和一般查询操作都是如此，因为访问了这个＆＃34;子文档中的注释元素＆＃34;表格你需要指定＆＃34;确切路径＆＃34;该元素是为了对它做任何事情。

聚合框架和一般查询没有＆＃34;遍历＆＃34;的概念，这意味着他们无法处理＆＃34;每个密钥＆＃34;一份文件。这需要一个语言结构，以便在这些接口中不提供。

一般来说，使用＆＃34;密钥名称＆＃34;作为一个数据点，它的名字实际上代表一个＆＃34;值＆＃34;是一个＆＃34;反模式＆＃34;。对此进行建模的更好方法是使用数组并表示您的＆＃34;类型＆＃34;作为一个价值本身：

{
    "app_id": "DHJFK67JDSJjdasj909",
    "date: ISODate("2014-08-07T00:00:00.000Z"),
    "event_count": 32423,
    "events": [
        { "type": 0,  "value": 322  },
        { "type": 10, "value": 4234 },
        { "type": 20, "value": 653  },
        { "type": 30, "value": 7562 }
    ]
}

同时注意到＆＃34; date＆＃34;现在是一个正确的日期对象而不是字符串，这也是一个很好的做法。这种数据虽然易于使用聚合框架处理：

db.events.aggregate([
    { "$unwind": "$events" },
    { "$group": {
        "_id": { 
            "app_id": "$app_id",
            "type": "$events.type"
        },
        "event_count": { "$sum": "$event_count" },
        "value": { "$sum": "$value" }
    }},
    { "$group": {
        "_id": "$_id.app_id",
        "event_count": { "$sum": "$event_count" },
        "events": { "$push": { "type": "$_id.type", "value": "$value" } }
    }}
])

这显示了一个两阶段分组，首先获得每个＆＃34;类型＆＃34;没有指定每个＆＃34;键＆＃34;因为您不再需要，然后按照＆＃34; app_id＆＃34;作为单个文档返回将结果存储在最初存储的数组中。这种数据形式通常可以更灵活地查看某些类型＆＃34;甚至是＆＃34;值＆＃34;在一定范围内。

如果您无法更改结构，那么您唯一的选择就是mapReduce。这允许你进行编码＆＃34;遍历密钥，但由于这需要JavaScript解释和执行，因此它不如聚合框架快：

db.events.mapReduce(
    function() {
        emit(
            this.app_id,
            {
                "event_count": this.event_count,
                "event_count_per_type": this.event_count_per_type
            }
        );
    },
    function(key,values) {

        var reduced = { "event_count": 0, "event_count_per_type": {} };

        values.forEach(function(value) {
            for ( var k in value.event_count_per_type ) {
                if ( !redcuced.event_count_per_type.hasOwnProperty(k) )
                    reduced.event_count_per_type[k] = 0;
                reduced.event_count_per_type += value.event_count_per_type;
            }
            reduced.event_count += value.event_count;
        })
    },
    {
        "out": { "inline": 1 }
    }
)

这将基本上遍历和组合＆＃34;键＆＃34;并总结每一个找到的值。

所以你可以选择：

更改结构并使用标准查询和聚合。
保持结构并需要JavaScript处理和mapReduce。

这取决于您的实际需求，但在大多数情况下，重组会带来好处。

MongoDB聚合汇总子文档上的每个键

1 个答案: