दिनांक अंतराल के अनुसार समूहित करें

MongoDB के एकत्रीकरण ढांचे के लिए दिनांक एकत्रीकरण ऑपरेटर उपलब्ध हैं। तो उदाहरण के लिए एक $dayOfYear ऑपरेटर का उपयोग समूहीकरण में उपयोग की तिथि से उस मान को प्राप्त करने के लिए किया जाता है:

db.collection.aggregate([
    { "$group": {
        "_id": { "$dayOfYear": "$datetime" },
        "total": { "$sum": "$count" }
    }}
])

या आप इसके बजाय दिनांक गणित दृष्टिकोण का उपयोग कर सकते हैं। युग की तारीख को लागू करके आप तारीख वस्तु को उस संख्या में बदल देते हैं जहां गणित लागू किया जा सकता है:

db.collection.aggregate([
    { "$group": {
        "_id": { 
            "$subtract": [
                { "$subtract": [ "$datetime", new Date("1970-01-01") ] },
                { "$mod": [
                    { "$subtract": [ "$datetime", new Date("1970-01-01") ] },
                    1000 * 60 * 60 * 24
                ]}
            ]
        },
        "total": { "$sum": "$count" }
    }}
])

यदि आप जो चाहते हैं वह वर्तमान समय से अंतराल है तो आप जो चाहते हैं वह मूल रूप से दिनांक गणित दृष्टिकोण है और $cond के माध्यम से कुछ शर्तों में काम कर रहा है। ऑपरेटर:

db.collection.aggregate([
    { "$match": {
        "datetime": { 
            "$gte": new Date(new Date().valueOf() - ( 1000 * 60 * 60 * 24 * 365 ))
        }
    }},
    { "$group": {
        "_id": null,
        "24hours": { 
            "$sum": {
                "$cond": [
                    { "$gt": [
                        { "$subtract": [ "$datetime", new Date("1970-01-01") ] },
                        new Date().valueOf() - ( 1000 * 60 * 60 * 24 )
                    ]},
                    "$count",
                    0
                ]
            }
        },
        "30days": { 
            "$sum": {
                "$cond": [
                    { "$gt": [
                        { "$subtract": [ "$datetime", new Date("1970-01-01") ] },
                        new Date().valueOf() - ( 1000 * 60 * 60 * 24 * 30 )
                    ]},
                    "$count",
                    0
                ]
            }
        },
        "OneYear": { 
            "$sum": {
                "$cond": [
                    { "$gt": [
                        { "$subtract": [ "$datetime", new Date("1970-01-01") ] },
                        new Date().valueOf() - ( 1000 * 60 * 60 * 24 * 365 )
                    ]},
                    "$count",
                    0
                ]
            }
        }
    }}
])

यह अनिवार्य रूप से SQL उदाहरण के समान दृष्टिकोण है, जहां क्वेरी सशर्त रूप से मूल्यांकन करती है कि दिनांक मान आवश्यक सीमा के भीतर आता है या नहीं और यह तय करता है कि मान को योग में जोड़ना है या नहीं।

यहां एक अतिरिक्त $match है चरण केवल उन मदों पर कार्रवाई करने के लिए क्वेरी को प्रतिबंधित करने के लिए है जो संभवतः अधिकतम एक वर्ष की सीमा के भीतर होंगे जो आप मांग रहे हैं। यह प्रस्तुत एसक्यूएल से थोड़ा बेहतर बनाता है जिसमें उन मानों को फ़िल्टर करने के लिए एक इंडेक्स का उपयोग किया जा सकता है और आपको संग्रह में गैर-मिलान डेटा के माध्यम से "बलपूर्वक" करने की आवश्यकता नहीं है।

इनपुट को $match . के साथ प्रतिबंधित करना हमेशा एक अच्छा विचार है एकत्रीकरण पाइपलाइन का उपयोग करते समय।