प्रारंभ और समाप्ति सीमा पर समूह और गणना करें

यह उपरोक्त डेटा पर परिणाम देता है:

{
        "_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
                }
        ]
}

ध्यान दें कि "महीनों" का कवरेज केवल वहीं मौजूद होता है जहां वास्तविक डेटा होता है। जबकि एक सीमा पर शून्य मान उत्पन्न करना संभव है, ऐसा करने के लिए काफी तकरार की आवश्यकता होती है और यह बहुत व्यावहारिक नहीं है। यदि आप शून्य मान चाहते हैं तो परिणाम प्राप्त होने के बाद क्लाइंट में पोस्ट प्रोसेसिंग में जोड़ना बेहतर होगा।

यदि आपका दिल वास्तव में शून्य मानों पर सेट है, तो आपको $मिनट और $max मान, और इन्हें प्रत्येक आपूर्ति किए गए संभावित श्रेणी मान के लिए प्रतियां उत्पन्न करने के लिए पाइपलाइन को "बलपूर्वक" करने के लिए पास करें।

तो इस बार "रेंज" को सभी दस्तावेज़ों के लिए बाहरी रूप से बनाया गया है, और फिर आप $cond संचायक में यह देखने के लिए कि क्या वर्तमान डेटा उत्पादित समूहीकृत सीमा के भीतर है। इसके अलावा चूंकि पीढ़ी "बाहरी" है, हमें वास्तव में $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
                }
        ]
}

MapReduce

MongoDB के सभी संस्करण mapReduce का समर्थन करते हैं, और जैसा कि ऊपर बताया गया है, "इटरेटर" का साधारण मामला के लिए द्वारा नियंत्रित किया जाता है मैपर में लूप। हम पहले $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
}

इसलिए इसमें सरणियों के लिए कंपाउंड करने के लिए दूसरा समूह नहीं है, लेकिन हमने समान मूल समेकित आउटपुट का उत्पादन किया।