मोंगोडब कुल, अंतराल मानदंड से दस्तावेजों की गणना कैसे करें?

आप जो चाहते हैं वह है $cond ऑपरेटर और कुछ नेस्टेड स्थितियां $and . लेकिन इससे आपको वही मिलेगा जो आप चाहते हैं।

db.collection.aggregate([
    {"$group": {
      "_id": {"$cond": [
          {"$gte": ["$LoadTime", 2000] },
          "Slowest",                                   // return "Slowest" where true
          {"$cond": [
              {"$and": [
                  {"$lt": ["$LoadTime", 2000] },
                  {"$gte": ["$LoadTime", 1000] }
              ]},
              "Slow",                                  // then "Slow" here where true
              {"$cond": [
                  {"$and": [
                      {"$lt": ["$LoadTime", 1000] },
                      {"$gte": ["$LoadTime", 500 ] }
                  ]},
                  "Medium",                            // then "Medium" where true
                  "Fast"                               // and finally "Fast" < 500
              ]}
          ]}
      ]},
      "count": {"$sum": 1}
    }},
    {"$sort": { "count": 1 }}
])

तो $cond . के रूप में एक टर्नरी है ऑपरेटर, इसमें तीन तर्क होते हैं:

• मूल्यांकन करने के लिए एक शर्त जो एक बूलियन . लौटाती है
• एक वापसी मूल्य जहां शर्त सत्य . है
• एक वापसी मूल्य जहां शर्त गलत है

इसलिए विचार यह है कि आप घोंसला सभी स्थितियों में, अगले . पर जा रहे हैं गलत . पर परीक्षण करें जब तक आपको मिलान करने के लिए एक शर्त और वापस करने के लिए एक मान नहीं मिल जाता है।

$और भाग शर्तों की एक सरणी है शामिल करना। यह आपको श्रेणियां . देता है . तो सबसे लंबे भागों में:

          {"$cond": [                             // Evaluate here
              {"$and": [                          // Within the range of the next 2
                  {"$lt": ["$LoadTime", 2000] },
                  {"$gte": ["$LoadTime", 1000] }
              ]},
              "Slow",                            // true condition - return
              {"$cond": [                        // false - move to next eval

आपके द्वारा कैस्केडिंग करने पर times . के लिए "फास्ट" बचा रहता है 500 मिलीसेकंड से कम।

इनमें से प्रत्येक keys समूह को उत्सर्जित किया जाता है और हम सिर्फ { $sum: 1 } गिनती प्राप्त करने के लिए क्योंकि उन्हें एक साथ समूहीकृत किया जाता है।

यदि आपको अपनी भाषा के कार्यान्वयन में इसकी आवश्यकता है, तो संपूर्ण pipeline

सिर्फ JSON है, इसलिए यदि आप हाथ से अनुवाद करने से बचते हैं, या यदि आप मेरी तरह आलसी हैं, तो आप इसे अपनी मूल डेटा संरचना में पार्स कर सकते हैं।

संपादित करें

टिप्पणियों . के कारण फ़ॉर्म . की व्याख्या करना आवश्यक लगता है प्रस्तुत क्वेरी का। तो यहाँ स्पष्टीकरण के लिए परिशिष्ट संपादित करें।

जब सीखना एकत्रीकरण पाइपलाइन का उपयोग, और वास्तव में अच्छा अभ्यास लिखने और परीक्षण . के लिए चरणों या तर्क की एक जटिल श्रृंखला, मुझे लगता है कि यह कल्पना . के लिए उपयोगी है एक बार में एक कदम . भागों को लागू करके परिणाम . तो ऐसा कुछ लिखने के मामले में मेरा पहले कदम इस प्रकार होगा:

db.collection.aggregate([
    {"$group": {
      "_id": {"$cond": [
          {"$gte": ["$LoadTime", 2000] },
          "Slowest",
          null
       ]}
    }}
])

अब वह मुझे "सबसे धीमी" की गिनती देगा जैसा कि मैं उम्मीद करूंगा और फिर बाल्टी बाकी सब कुछ null . में . तो एक चरण है जहां मैं अब तक के परिणाम देख रहा हूं। लेकिन जब परीक्षण श्रृंखला बनाने के लिए आगे बढ़ने से पहले मैं वास्तव में ऐसा कुछ करूंगा:

db.collection.aggregate([
    {"$group": {
      "_id": {"$cond": [
          {"$and": [
              {"$lt": ["$LoadTime", 2000] },
              {"$gte": ["$LoadTime", 1000] }
          ]},
          "Slow",
          null
      ]}
    }}
])

इसलिए मुझे केवल "धीमे" (बीच . के परिणाम मिल रहे हैं 2000 और 1000) null . में बाकी सभी चीज़ों के साथ बाल्टी। तो मेरी कुल संख्या वही रहती है।

फाइनल . में क्वेरी, जैसा कि बताया गया था, एक ternary में इस तरह की नेस्टेड स्थिति, पहली स्टेज में पहले से . है मूल्यांकन किया गया false अगले . द्वारा परीक्षण किए जा रहे आइटम के लिए ऑपरेटर। इसका मतलब है कि वे नहीं . हैं इससे अधिक वह मान जिसका परीक्षण पहले ही पहले . में किया जा चुका है चरण, और यह उस स्थिति के लिए परीक्षण करने की आवश्यकता को समाप्त करता है, इसलिए यह कर सकता है इस प्रकार लिखा जाए:

db.collection.aggregate([
    {"$group": {
      "_id": {"$cond": [
          {"$gte": ["$LoadTime", 2000] },       // Caught everything over 2000
          "Slowest",
          {"$cond": [
              {"$gte": ["$LoadTime", 1000] }    // Catch things still over 1000
              "Slow",
              {"$cond": [                       // Things under 1000 go here

              // and so on

और वो शॉर्ट सर्किट मूल्यांकन नहीं है क्योंकि कोई वास्तविक नहीं है उन चीजों के लिए परीक्षण करने की आवश्यकता है जो अगली तार्किक स्थिति में नहीं आएंगी।

तो विशुद्ध रूप से दृश्य कारणों . के लिए और काटने और चिपकाने . के सरासर आलस्य के लिए तर्क, हम $और . का उपयोग करके विस्तारित रूप के साथ समाप्त होते हैं लपेटने . के लिए शर्त क्षेत्र। लेकिन उनके लिए अभ्यस्त नहीं टर्नरी का उपयोग प्रपत्र में एक स्पष्ट दृश्य संकेत है कि इस चरण में मिलान किए जा रहे परिणाम बीच में पड़ेंगे 2000ms . के मान और 1000ms , और इसी तरह, प्रत्येक श्रेणी में परिणाम के रूप में आप यही चाहते हैं।

जैसा कि मैंने कहा, तर्क कैसे काम करता है, इसके कारण यह अनावश्यक है, लेकिन यह था एक विकास चरण, और स्पष्ट . है उन लोगों के लिए जो अभी तक अपना सिर घुमाना चाहते हैं टर्नरी का उपयोग फॉर्म है कि $cond प्रदान करता है।