समुच्चय में किसी फ़ील्ड का सबसे अधिक बार आने वाला मान ज्ञात करने की आवश्यकता है

ठीक है आप सिर्फ "मेकअप" नहीं कर सकते। ऑपरेटरों के रूप में $mode एक एकत्रीकरण ऑपरेटर नहीं है, और केवल वही चीजें हैं जिनका आप उपयोग कर सकते हैं वे हैं जो वास्तव में मौजूद हैं ।

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

    // Filter dates
    { "$match": { 
        "dt": { 
            "$gt": new Date("October 13, 2010 12:00:00"), 
            "$lt": new Date("November 13, 2010 12:00:00")
        } 
    }},

    // Group by hour and category, with avg and count
    { "$group": {
        "_id": {
            "dt": {
                "$add": [
                    {
                        "$subtract": [
                            { "$subtract": ["$dt", new Date(0)] },
                            {
                                "$mod": [
                                    { "$subtract": ["$dt", new Date(0)] },
                                    3600000//1000 * 60 * 60
                                ]
                            }
                        ]
                    },
                    new Date(0)
                ]
            },
            "category": "$category"
        }, 
        "price": { "$avg": "$price" },
        "count": { "$sum": 1 }
    }},
    // Sort on date and count
    { "$sort": { "_id.dt": 1, "count": -1 }},

    // Group on just the date, keeping the avg and the first category
    { "$group": {
        "_id": "$_id.dt",
        "price": { "$avg": "$price"}
        "category": { "$first": "$_id.category" }
    }}

तो $group दिनांक और श्रेणी दोनों पर और श्रेणी गणना को $sum . फिर आप $sort इसलिए प्रत्येक समूहीकृत तिथि के लिए सबसे बड़ी "गिनती" शीर्ष पर है। और अंत में $first का प्रयोग करें जब आप कोई अन्य $group लागू करते हैं यह केवल उस तिथि पर ही लागू होता है, ताकि उस श्रेणी को प्रत्येक तिथि के लिए सबसे बड़ी संख्या के साथ वापस किया जा सके।

$max . जैसे ऑपरेटरों के बहकावे में न आएं क्योंकि वे यहां काम नहीं करते हैं। मुख्य अंतर प्रत्येक श्रेणी मूल्य के लिए उत्पादित "रिकॉर्ड/दस्तावेज़" के लिए "बंधे" संबंध है। तो यह अधिकतम "गिनती" नहीं है जो आप चाहते हैं या अधिकतम "श्रेणी" मान नहीं है, बल्कि इसके बजाय श्रेणी मान है जो सबसे बड़ी गिनती "उत्पादित" करता है। इसलिए एक $sort . है यहां जरूरत है।

अंत में कुछ आदतें जिन्हें आपको "तोड़ना" चाहिए:

• इनपुट के रूप में गैर यूटीसी प्रारूप दिनांक उदाहरण डेटा का उपयोग न करें जब तक कि आप वास्तव में नहीं जानते कि आप क्या कर रहे हैं। तिथियों को हमेशा यूटीसी में परिवर्तित किया जा रहा है, इसलिए कम से कम परीक्षण लिस्टिंग में, आपको इस तरह से दिनांक मान निर्दिष्ट करने की आदत डालनी चाहिए।

• यह दूसरी तरफ थोड़ा साफ दिख सकता है लेकिन 1000 * 60 * 60 . जैसी चीजें 3600000 . की तुलना में यह क्या कर रहा है, इसके बारे में बहुत अधिक वर्णनात्मक कोड हैं . एक ही मान, लेकिन एक रूप एक नज़र में इसकी समय इकाइयों का सूचक है।

• कंपाउंडिंग _id जब केवल एक ही मान होता है तो भी मुद्दों को भ्रमित कर सकता है। इसलिए _id.dt . तक पहुंचने का कोई मतलब नहीं है अगर वह एकमात्र मूल्य मौजूद था। _id . में एक से अधिक प्रॉपर्टी कब होती है तब ठीक है। लेकिन एक मान को सीधे _id . पर वापस असाइन किया जाना चाहिए अकेला। अन्यथा कुछ हासिल नहीं हुआ, और सिंगल बिल्कुल स्पष्ट है।