如果我有以下格式的数据：
[
{
_id: 1,
startDate: ISODate("2017-01-1T00:00:00.000Z"),
endDate: ISODate("2017-02-25T00:00:00.000Z"),
type: 'CAR'
},
{
_id: 2,
startDate: ISODate("2017-02-17T00:00:00.000Z"),
endDate: ISODate("2017-03-22T00:00:00.000Z"),
type: 'HGV'
}
]
是否可以检索按“类型”分组的数据，还可以检索给定日期范围内每个月的类型计数，例如2017/1/1至2017/4/1之间将返回：
[
{
_id: 'CAR',
monthCounts: [
/*January*/
{
from: ISODate("2017-01-1T00:00:00.000Z"),
to: ISODate("2017-01-31T23:59:59.999Z"),
count: 1
},
/*February*/
{
from: ISODate("2017-02-1T00:00:00.000Z"),
to: ISODate("2017-02-28T23:59:59.999Z"),
count: 1
},
/*March*/
{
from: ISODate("2017-03-1T00:00:00.000Z"),
to: ISODate("2017-03-31T23:59:59.999Z"),
count: 0
},
]
},
{
_id: 'HGV',
monthCounts: [
{
from: ISODate("2017-01-1T00:00:00.000Z"),
to: ISODate("2017-01-31T23:59:59.999Z"),
count: 0
},
{
from: ISODate("2017-02-1T00:00:00.000Z"),
to: ISODate("2017-02-28T23:59:59.999Z"),
count: 1
},
{
from: ISODate("2017-03-1T00:00:00.000Z"),
to: ISODate("2017-03-31T23:59:59.999Z"),
count: 1
},
]
}
]
返回的格式并不重要，但我想要实现的是在单个查询中检索同一分组的多个计数（每月一个）。输入可以只是报告的开始和结束日期，也可能是要分组的日期范围数组。
答案 0 :(得分：3)
这个算法基本上是＃34;迭代＆＃34;两个值的间隔之间的值。 MongoDB有两种方法可以解决这个问题，mapReduce()以及aggregate()方法可用的新功能一直存在。
我会扩展您的选择以故意显示重叠的月份，因为您的示例没有。这将导致＆＃34; HGV＆＃34;价值出现在＆＃34;三＆＃34;几个月的产出。
{
"_id" : 1,
"startDate" : ISODate("2017-01-01T00:00:00Z"),
"endDate" : ISODate("2017-02-25T00:00:00Z"),
"type" : "CAR"
}
{
"_id" : 2,
"startDate" : ISODate("2017-02-17T00:00:00Z"),
"endDate" : ISODate("2017-03-22T00:00:00Z"),
"type" : "HGV"
}
{
"_id" : 3,
"startDate" : ISODate("2017-02-17T00:00:00Z"),
"endDate" : ISODate("2017-04-22T00:00:00Z"),
"type" : "HGV"
}
db.cars.aggregate([
{ "$addFields": {
"range": {
"$reduce": {
"input": { "$map": {
"input": { "$range": [
{ "$trunc": {
"$divide": [
{ "$subtract": [ "$startDate", new Date(0) ] },
1000
]
}},
{ "$trunc": {
"$divide": [
{ "$subtract": [ "$endDate", new Date(0) ] },
1000
]
}},
60 * 60 * 24
]},
"as": "el",
"in": {
"$let": {
"vars": {
"date": {
"$add": [
{ "$multiply": [ "$$el", 1000 ] },
new Date(0)
]
},
"month": {
}
},
"in": {
"$add": [
{ "$multiply": [ { "$year": "$$date" }, 100 ] },
{ "$month": "$$date" }
]
}
}
}
}},
"initialValue": [],
"in": {
"$cond": {
"if": { "$in": [ "$$this", "$$value" ] },
"then": "$$value",
"else": { "$concatArrays": [ "$$value", ["$$this"] ] }
}
}
}
}
}},
{ "$unwind": "$range" },
{ "$group": {
"_id": {
"type": "$type",
"month": "$range"
},
"count": { "$sum": 1 }
}},
{ "$sort": { "_id": 1 } },
{ "$group": {
"_id": "$_id.type",
"monthCounts": {
"$push": { "month": "$_id.month", "count": "$count" }
}
}}
])
使这项工作的关键是$range运算符，该运算符为＆＃34; start＆＃34;和＆＃34;结束＆＃34;以及＆＃34;间隔＆＃34;申请。结果是从＆＃34; start＆＃34;取得的一系列值。并递增，直到＆＃34;结束＆＃34;到了。
我们将此与startDate和endDate一起使用，以生成这些值之间的可能日期。你会注意到我们需要在这里做一些数学运算，因为$range只需要一个32位整数，但我们可以从时间戳值开始毫秒，这样就可以了。
因为我们想要＆＃34;月＆＃34;，所应用的操作从生成的范围中提取月份和年份值。我们实际上生成的范围为＆＃34; days＆＃34;从...＆＃34;月＆＃34;之间数学很难处理。随后的$reduce操作仅需要＆＃34;不同的月份＆＃34;从日期范围开始。
因此，第一个聚合流水线阶段的结果是文档中的一个新字段，它是一个＆＃34;数组＆＃34;在startDate和endDate之间涵盖的所有不同月份。这给了一个＆＃34;迭代器＆＃34;其余的操作。
by＆＃34; iterator＆＃34;我的意思是，当我们应用$unwind时，我们会获得该间隔中涵盖的每个不同月份的原始文档的副本。然后，这允许以下两个$group阶段首先将分组应用于＆＃34;月＆＃34;的共同密钥。和＆＃34;键入＆＃34;为了＆＃34;总计＆＃34;通过$sum进行计数，然后下一个$group使得密钥只是＆＃34;类型＆＃34;并通过$push将结果放入数组中。
这给出了上述数据的结果：
{
"_id" : "HGV",
"monthCounts" : [
{
"month" : 201702,
"count" : 2
},
{
"month" : 201703,
"count" : 2
},
{
"month" : 201704,
"count" : 1
}
]
}
{
"_id" : "CAR",
"monthCounts" : [
{
"month" : 201701,
"count" : 1
},
{
"month" : 201702,
"count" : 1
}
]
}
请注意＆＃34;月＆＃34;的覆盖范围只存在有实际数据的地方。虽然可以在一定范围内产生零值，但这需要相当多的争论并且不太实用。如果您想要零值，那么最好在检索到结果后在客户端的后期处理中添加它。
如果您确实已将心脏设置为零值，则应单独查询$min和$max值，并将这些值传递给＆＃34;暴力＆＃34;管道为每个提供的可能范围值生成副本。
所以这次＆＃34;范围＆＃34;在所有文档外部进行，然后使用$cond语句进入累加器，以查看当前数据是否在生成的分组范围内。此外，由于生成是＆＃34;外部＆＃34;，我们真的不需要$range的MongoDB 3.4运算符，所以这也可以应用于早期版本：
// Get min and max separately
var ranges = db.cars.aggregate(
{ "$group": {
"_id": null,
"startRange": { "$min": "$startDate" },
"endRange": { "$max": "$endDate" }
}}
).toArray()[0]
// Make the range array externally from all possible values
var range = [];
for ( var d = new Date(ranges.startRange.valueOf()); d <= ranges.endRange; d.setUTCMonth(d.getUTCMonth()+1)) {
var v = ( d.getUTCFullYear() * 100 ) + d.getUTCMonth()+1;
range.push(v);
}
// Run conditional aggregation
db.cars.aggregate([
{ "$addFields": { "range": range } },
{ "$unwind": "$range" },
{ "$group": {
"_id": {
"type": "$type",
"month": "$range"
},
"count": {
"$sum": {
"$cond": {
"if": {
"$and": [
{ "$gte": [
"$range",
{ "$add": [
{ "$multiply": [ { "$year": "$startDate" }, 100 ] },
{ "$month": "$startDate" }
]}
]},
{ "$lte": [
"$range",
{ "$add": [
{ "$multiply": [ { "$year": "$endDate" }, 100 ] },
{ "$month": "$endDate" }
]}
]}
]
},
"then": 1,
"else": 0
}
}
}
}},
{ "$sort": { "_id": 1 } },
{ "$group": {
"_id": "$_id.type",
"monthCounts": {
"$push": { "month": "$_id.month", "count": "$count" }
}
}}
])
对所有分组的所有可能月份产生一致的零填充：
{
"_id" : "HGV",
"monthCounts" : [
{
"month" : 201701,
"count" : 0
},
{
"month" : 201702,
"count" : 2
},
{
"month" : 201703,
"count" : 2
},
{
"month" : 201704,
"count" : 1
}
]
}
{
"_id" : "CAR",
"monthCounts" : [
{
"month" : 201701,
"count" : 1
},
{
"month" : 201702,
"count" : 1
},
{
"month" : 201703,
"count" : 0
},
{
"month" : 201704,
"count" : 0
}
]
}
所有版本的MongoDB都支持mapReduce，以及＆＃34; iterator＆＃34;的简单案例如上所述，由映射器中的for循环处理。我们可以通过简单地执行以下操作，将输出生成为从上面生成的第一个$group：
db.cars.mapReduce(
function () {
for ( var d = this.startDate; d <= this.endDate;
d.setUTCMonth(d.getUTCMonth()+1) )
{
var m = new Date(0);
m.setUTCFullYear(d.getUTCFullYear());
m.setUTCMonth(d.getUTCMonth());
emit({ id: this.type, date: m},1);
}
},
function(key,values) {
return Array.sum(values);
},
{ "out": { "inline": 1 } }
)
产生：
{
"_id" : {
"id" : "CAR",
"date" : ISODate("2017-01-01T00:00:00Z")
},
"value" : 1
},
{
"_id" : {
"id" : "CAR",
"date" : ISODate("2017-02-01T00:00:00Z")
},
"value" : 1
},
{
"_id" : {
"id" : "HGV",
"date" : ISODate("2017-02-01T00:00:00Z")
},
"value" : 2
},
{
"_id" : {
"id" : "HGV",
"date" : ISODate("2017-03-01T00:00:00Z")
},
"value" : 2
},
{
"_id" : {
"id" : "HGV",
"date" : ISODate("2017-04-01T00:00:00Z")
},
"value" : 1
}
因此它没有第二个分组复合到数组，但我们确实产生了相同的基本聚合输出。