समय के अंतराल के भीतर मोंगो एकत्रीकरण

इस पर पहुंचने के कुछ तरीके हैं जो इस पर निर्भर करते हैं कि कौन सा आउटपुट स्वरूप आपकी आवश्यकताओं के लिए सबसे उपयुक्त है। मुख्य नोट यह है कि "aggregation Framework" स्वयं, आप वास्तव में किसी तिथि के रूप में कुछ "कास्ट" वापस नहीं कर सकते हैं, लेकिन आप ऐसे मान प्राप्त कर सकते हैं जिन्हें आसानी से Date में पुनर्निर्मित किया जाता है। आपके एपीआई में परिणाम संसाधित करते समय ऑब्जेक्ट करें।

पहला तरीका "Date Aggregation Operators" का उपयोग करना है। एकत्रीकरण ढांचे के लिए उपलब्ध:

db.collection.aggregate([
    { "$match": {
        "time": { "$gte": startDate, "$lt": endDate }
    }},
    { "$group": {
        "_id": {
            "year": { "$year": "$time" },
            "dayOfYear": { "$dayOfYear": "$time" },
            "hour": { "$hour": "$time" },
            "minute": {
                "$subtract": [
                    { "$minute": "$time" },
                    { "$mod": [ { "$minute": "$time" }, 10 ] }
                ]
            }
        },
        "count": { "$sum": 1 }
    }}
])

जो _id . के लिए एक संयुक्त कुंजी देता है "तारीख" के लिए आप जो सभी मान चाहते हैं, उनमें शामिल हैं। वैकल्पिक रूप से यदि केवल "घंटे" के भीतर हमेशा "मिनट" भाग का उपयोग करें और startDate के आधार पर वास्तविक तिथि निर्धारित करें आपके श्रेणी चयन का।

या आप "युग" के बाद से मिलीसेकंड प्राप्त करने के लिए सादे "दिनांक गणित" का उपयोग कर सकते हैं जिसे फिर से सीधे दिनांक निर्माता को खिलाया जा सकता है।

db.collection.aggregate([
    { "$match": {
        "time": { "$gte": startDate, "$lt": endDate }
    }},
    { "$group": {
        "_id": {
            "$subtract": [
               { "$subtract": [ "$time", new Date(0) ] },
               { "$mod": [
                   { "$subtract": [ "$time", new Date(0) ] },
                   1000 * 60 * 10
               ]}
            ]
        },
        "count": { "$sum": 1 }
    }}
])

सभी मामलों में जो आप नहीं . करते हैं करना चाहते हैं $project वास्तव में लागू करने से पहले $group . "पाइपलाइन चरण" के रूप में, $प्रोजेक्ट हालांकि सभी दस्तावेजों को "चक्र" करना चाहिए और सामग्री को "रूपांतरित" करना चाहिए।

इसमें समय लगता है , और क्वेरी के कुल निष्पादन में जोड़ता है। आप बस $group . पर आवेदन कर सकते हैं सीधे जैसा दिखाया गया है।

या यदि आप वास्तव में दिनांक . के बारे में "शुद्ध" हैं ऑब्जेक्ट पोस्ट प्रोसेसिंग के बिना लौटाया जा रहा है, तो आप हमेशा "mapReduce" , चूंकि जावास्क्रिप्ट फ़ंक्शन वास्तव में एक तिथि के रूप में पुनर्रचना की अनुमति देते हैं, लेकिन एकत्रीकरण ढांचे की तुलना में धीमी और निश्चित रूप से एक कर्सर प्रतिक्रिया के बिना:

db.collection.mapReduce(
   function() {
       var date = new Date(
           this.time.valueOf() 
           - ( this.time.valueOf() % ( 1000 * 60 * 10 ) )
       );
       emit(date,1);
   },
   function(key,values) {
       return Array.sum(values);
   },
   { "out": { "inline": 1 } }
)

आपका सबसे अच्छा दांव हालांकि एकत्रीकरण का उपयोग करना है, क्योंकि प्रतिक्रिया को बदलना काफी आसान है:

db.collection.aggregate([
    { "$match": {
        "time": { "$gte": startDate, "$lt": endDate }
    }},
    { "$group": {
        "_id": {
            "year": { "$year": "$time" },
            "dayOfYear": { "$dayOfYear": "$time" },
            "hour": { "$hour": "$time" },
            "minute": {
                "$subtract": [
                    { "$minute": "$time" },
                    { "$mod": [ { "$minute": "$time" }, 10 ] }
                ]
            }
        },
        "count": { "$sum": 1 }
    }}
]).forEach(function(doc) {
    doc._id = new Date(doc._id);
    printjson(doc);
})

और फिर आपके पास वास्तविक दिनांक . के साथ आपका अंतराल समूहन आउटपुट है वस्तुओं।