MongoDB एकत्रीकरण:पिछली पंक्तियों के योग से रनिंग टोटल की गणना करें

यह वही करता है जो आपको चाहिए। मैंने डेटा में समय को सामान्य कर दिया है ताकि वे एक साथ समूह कर सकें (आप ऐसा कुछ कर सकते हैं)। विचार $group . के लिए है और time को पुश करें और total अलग सरणियों में है। फिर $unwind time सरणी, और आपने totals . की एक प्रति बना ली है प्रत्येक time . के लिए सरणी दस्तावेज़। फिर आप runningTotal . की गणना कर सकते हैं (या रोलिंग औसत जैसा कुछ) अलग-अलग समय के लिए सभी डेटा वाले सरणी से। $unwind . द्वारा जनरेट किया गया 'इंडेक्स' total . के लिए सरणी अनुक्रमणिका है उस time . के अनुरूप . $sort . करना महत्वपूर्ण है $unwind . से पहले क्योंकि यह सुनिश्चित करता है कि सरणियाँ सही क्रम में हैं।

db.temp.aggregate(
    [
        {
            '$group': {
                '_id': '$time',
                'total': { '$sum': '$value' }
            }
        },
        {
            '$sort': {
                 '_id': 1
            }
        },
        {
            '$group': {
                '_id': 0,
                'time': { '$push': '$_id' },
                'totals': { '$push': '$total' }
            }
        },
        {
            '$unwind': {
                'path' : '$time',
                'includeArrayIndex' : 'index'
            }
        },
        {
            '$project': {
                '_id': 0,
                'time': { '$dateToString': { 'format': '%Y-%m-%d', 'date': '$time' }  },
                'total': { '$arrayElemAt': [ '$totals', '$index' ] },
                'runningTotal': { '$sum': { '$slice': [ '$totals', { '$add': [ '$index', 1 ] } ] } },
            }
        },
    ]
);

मैंने ~ 80,000 दस्तावेजों के साथ एक संग्रह पर कुछ इसी तरह का उपयोग किया है, जो 63 परिणामों को मिलाकर है। मुझे यकीन नहीं है कि यह बड़े संग्रहों पर कितनी अच्छी तरह काम करेगा, लेकिन मैंने पाया है कि समेकित डेटा पर प्रदर्शन रूपांतरण (अनुमान, सरणी जोड़तोड़) एक बार डेटा को प्रबंधनीय आकार में कम करने के बाद बड़ी प्रदर्शन लागत नहीं लगती है।