MongoDB एक उप-दस्तावेज़ पर प्रत्येक कुंजी का कुल योग

जैसा कि कहा गया है, इस तरह के दस्तावेजों को संसाधित करना एकत्रीकरण ढांचे के साथ संभव नहीं है जब तक कि आप वास्तव में सभी चाबियों की आपूर्ति नहीं करने जा रहे हैं, जैसे:

db.events.aggregate([
   { "$group": {
       "_id": "$app_id",
       "event_count": { "$sum": "$event_count" },
       "0": { "$sum": "$event_count_per_type.0" },
       "10": { "$sum": "$event_count_per_type.10" }
       "20": { "$sum": "$event_count_per_type.20" }
       "30": { "$sum": "$event_count_per_type.30" }
   }}
])

लेकिन आपको निश्चित रूप से प्रत्येक . को स्पष्ट रूप से निर्दिष्ट करना होगा कुंजी जिस पर आप काम करना चाहते हैं। यह MongoDB में एकत्रीकरण ढांचे और सामान्य क्वेरी संचालन दोनों के लिए सच है, क्योंकि इस "उप-दस्तावेज़" फ़ॉर्म में नोट किए गए तत्वों तक पहुँचने के लिए आपको तत्व के साथ कुछ भी करने के लिए "सटीक पथ" निर्दिष्ट करने की आवश्यकता है।

एकत्रीकरण ढांचे और सामान्य प्रश्नों में "ट्रैवर्सल" की कोई अवधारणा नहीं है, जिसका अर्थ है कि वे किसी दस्तावेज़ की "प्रत्येक कुंजी" को संसाधित नहीं कर सकते हैं। ऐसा करने के लिए एक भाषा निर्माण की आवश्यकता है जो इन इंटरफेस में प्रदान नहीं किया गया है।

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

{
    "app_id": "DHJFK67JDSJjdasj909",
    "date: ISODate("2014-08-07T00:00:00.000Z"),
    "event_count": 32423,
    "events": [
        { "type": 0,  "value": 322  },
        { "type": 10, "value": 4234 },
        { "type": 20, "value": 653  },
        { "type": 30, "value": 7562 }
    ]
}

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

db.events.aggregate([
    { "$unwind": "$events" },
    { "$group": {
        "_id": { 
            "app_id": "$app_id",
            "type": "$events.type"
        },
        "event_count": { "$sum": "$event_count" },
        "value": { "$sum": "$value" }
    }},
    { "$group": {
        "_id": "$_id.app_id",
        "event_count": { "$sum": "$event_count" },
        "events": { "$push": { "type": "$_id.type", "value": "$value" } }
    }}
]) 

यह एक दो चरण समूह दिखाता है जो पहले प्रत्येक "कुंजी" को निर्दिष्ट किए बिना प्रति "प्रकार" का योग प्राप्त करता है क्योंकि अब आपके पास नहीं है, फिर एक सरणी में परिणामों के साथ "app_id" प्रति एकल दस्तावेज़ के रूप में लौटाता है क्योंकि वे मूल रूप से संग्रहीत किए गए थे। यह डेटा प्रपत्र आम तौर पर एक निश्चित सीमा के भीतर कुछ "प्रकार" या यहां तक ​​कि "मान" को देखने के लिए अधिक लचीला होता है।

जहां आप संरचना नहीं बदल सकते हैं तो आपका एकमात्र विकल्प mapReduce है। यह आपको चाबियों के ट्रैवर्सल को "कोड" करने की अनुमति देता है, लेकिन चूंकि इसके लिए जावास्क्रिप्ट व्याख्या और निष्पादन की आवश्यकता होती है, यह एकत्रीकरण ढांचे जितना तेज़ नहीं है:

db.events.mapReduce(
    function() {
        emit(
            this.app_id,
            {
                "event_count": this.event_count,
                "event_count_per_type": this.event_count_per_type
            }
        );
    },
    function(key,values) {

        var reduced = { "event_count": 0, "event_count_per_type": {} };

        values.forEach(function(value) {
            for ( var k in value.event_count_per_type ) {
                if ( !redcuced.event_count_per_type.hasOwnProperty(k) )
                    reduced.event_count_per_type[k] = 0;
                reduced.event_count_per_type += value.event_count_per_type;
            }
            reduced.event_count += value.event_count;
        })
    },
    {
        "out": { "inline": 1 }
    }
)

यह अनिवार्य रूप से "कुंजी" को पार करेगा और संयोजित करेगा और हर एक के लिए मूल्यों को जोड़ देगा।

तो आपके पास या तो विकल्प हैं:

1. संरचना बदलें और मानक प्रश्नों और एकत्रीकरण के साथ काम करें।
2. संरचना के साथ बने रहें और JavaScript संसाधन और mapReduce की आवश्यकता है।

यह आपकी वास्तविक जरूरतों पर निर्भर करता है, लेकिन ज्यादातर मामलों में पुनर्रचना से लाभ मिलता है।