MongoDb . में 15 मिनट के समय अंतराल से समूह परिणाम

ऐसा करने के कुछ तरीके हैं।

पहला दिनांक एकत्रीकरण ऑपरेटरों के साथ है, जो आपको दस्तावेज़ों में "तारीख" मानों को विच्छेदित करने की अनुमति देता है। विशेष रूप से प्राथमिक उद्देश्य के रूप में "समूहीकरण" के लिए:

db.collection.aggregate([
  { "$group": {
    "_id": {
      "year": { "$year": "$created_at" },
      "dayOfYear": { "$dayOfYear": "$created_at" },
      "hour": { "$hour": "$created_at" },
      "interval": {
        "$subtract": [ 
          { "$minute": "$created_at" },
          { "$mod": [{ "$minute": "$created_at"}, 15] }
        ]
      }
    }},
    "count": { "$sum": 1 }
  }}
])

दूसरा तरीका यह है कि जब किसी दिनांक वस्तु को किसी अन्य दिनांक वस्तु से घटाया जाता है (या अन्य प्रत्यक्ष गणित संचालन) की एक छोटी सी चाल का उपयोग किया जाता है, तो परिणाम दो वस्तुओं के बीच युग टाइमस्टैम्प मिलीसेकंड का प्रतिनिधित्व करने वाला एक संख्यात्मक मान होता है। तो बस युग की तारीख का उपयोग करके आपको युग मिलीसेकंड का प्रतिनिधित्व मिलता है। फिर अंतराल के लिए दिनांक गणित का उपयोग करें:

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

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

आप ग्रुपिंग _id . के बाद "ग्रुपिंग ऑपरेटर" भाग में अपनी इच्छानुसार कुछ भी डाल सकते हैं . आप वास्तव में क्या करना चाहते हैं, इसके लिए मैं आपके किसी भी वास्तविक कथन के स्थान पर मूल "गिनती" उदाहरण का उपयोग कर रहा हूं।

MongoDB 4.x और ऊपर की ओर

मूल लेखन के बाद से दिनांक एकत्रीकरण ऑपरेटरों में कुछ जोड़ दिए गए थे, लेकिन मोंगोडीबी 4.0 से बीएसओएन दिनांक रूपांतरण के साथ यहां किए गए मूल गणित ट्रिक्स के विपरीत वास्तविक "प्रकार की वास्तविक कास्टिंग" होगी।

उदाहरण के लिए हम $toLong . का उपयोग कर सकते हैं और $toDate यहां नए सहायकों के रूप में:

db.collection.aggregate([
  { "$group": {
    "_id": {
      "$toDate": {
        "$subtract": [
          { "$toLong": "$created_at" },
          { "$mod": [ { "$toLong": "$created_at" }, 1000 * 60 * 15 ] }
        ]
      }
    },
    "count": { "$sum": 1 }
  }}
])

यह थोड़ा छोटा है और पाइपलाइन को परिभाषित करने में स्थिरांक के रूप में "युग" मान के लिए बाहरी बीएसओएन तिथि को परिभाषित करने की आवश्यकता नहीं है, इसलिए यह सभी भाषा कार्यान्वयन के लिए काफी सुसंगत है।

वे प्रकार रूपांतरण के लिए "सहायक" विधियों में से केवल दो हैं जो सभी $convert से वापस जुड़ते हैं विधि, जो कार्यान्वयन का एक "लंबा" रूप है जो null . पर कस्टम हैंडलिंग की अनुमति देता है या रूपांतरण में त्रुटि।

ऐसी कास्टिंग के साथ Date . प्राप्त करना भी संभव है ObjectId . से जानकारी प्राथमिक कुंजी का, क्योंकि यह "निर्माण" तिथि का एक विश्वसनीय स्रोत होगा:

db.collection.aggregate([
  { "$group": {
    "_id": {
      "$toDate": {
        "$subtract": [
          { "$toLong": { "$toDate": "$_id" }  },
          { "$mod": [ { "$toLong": { "$toDate": "$_id" } }, 1000 * 60 * 15 ] }
        ]
      }
    },
    "count": { "$sum": 1 }
  }}
])

तो इस प्रकार के रूपांतरण के साथ "कास्टिंग प्रकार" बहुत शक्तिशाली उपकरण हो सकता है।

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