$group: समूहीकरण और कुल की गणना
शिक्षार्थी कुंजी के आधार पर दस्तावेज़ों को समूहित करेंगे और $group से योग, औसत, गिनती तथा अन्य संचयक मानों की गणना करेंगे।
$group: समूहीकरण और कुल की गणना, CoddyKit पर MongoDB Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह MongoDB Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। MongoDB Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
$group क्या करता है?
$group चरण ग्रुपिंग कुंजी के आधार पर कई इनपुट दस्तावेज़ों को कम आउटपुट दस्तावेज़ों में समेट देता है। जिन दस्तावेज़ों की कुंजी का मान समान होता है, उन्हें एक आउटपुट दस्तावेज़ में मिला दिया जाता है और संचायक ऑपरेटर प्रत्येक समूह के लिए समेकित मान निकालते हैं। इसे MongoDB में SQL के GROUP BY क्लॉज़ और SUM तथा COUNT जैसे समेकित फ़ंक्शन के समकक्ष समझें।
// Count orders per user
db.orders.aggregate([
{ $group: {
_id: '$userId', // group by userId
orderCount: { $sum: 1 } // count each document as 1
}}
]);
// Output: one doc per unique userId with their order count$group में _id फ़ील्ड
हर $group चरण में एक _id फ़ील्ड आवश्यक होता है, जो ग्रुपिंग कुंजी निर्धारित करता है। _id किसी फ़ील्ड का संदर्भ ('$field'), कोई गणना किया गया एक्सप्रेशन, कई फ़ील्ड वाली ऑब्जेक्ट (संयुक्त ग्रुपिंग के लिए), या null (पूरे संग्रह को एक दस्तावेज़ में समेकित करने के लिए) हो सकता है। आउटपुट में _id का मान समूह की कुंजी होता है।
// Group by single field
{ $group: { _id: '$status' } }
// Group by multiple fields (compound key)
{ $group: { _id: { year: { $year: '$createdAt' }, status: '$status' } } }
// Group all documents into one (grand total)
{ $group: { _id: null, grandTotal: { $sum: '$amount' } } }
// Group by computed expression
{ $group: { _id: { $toLower: '$category' } } }$sum: गिनती और योग
$sum सबसे अधिक उपयोग किया जाने वाला संचायक है। प्रत्येक समूह में दस्तावेज़ों की गिनती करने के लिए 1 दें, या संख्यात्मक फ़ील्ड के मानों का योग निकालने के लिए फ़ील्ड संदर्भ दें। आप ऐसा एक्सप्रेशन भी दे सकते हैं जिसका परिणाम कोई संख्या हो। $sum गैर-संख्यात्मक मानों और अनुपस्थित फ़ील्ड को नज़रअंदाज़ करता है (वे शून्य माने जाते हैं), इसलिए वैकल्पिक संख्यात्मक फ़ील्ड पर इसका उपयोग सुरक्षित है।
db.sales.aggregate([{
$group: {
_id: '$region',
// Count documents in each group
transactionCount: { $sum: 1 },
// Sum the 'amount' field
totalRevenue: { $sum: '$amount' },
// Sum a computed expression
totalWithTax: { $sum: { $multiply: ['$amount', 1.1] } }
}
}]);$avg, $min, $max
$avg अंकगणितीय माध्य निकालता है, $min सबसे छोटा मान ढूँढता है और $max किसी समूह के सभी दस्तावेज़ों में सबसे बड़ा मान ढूँढता है। तीनों संख्यात्मक मानों पर काम करते हैं तथा $min और $max स्ट्रिंग और दिनांक पर भी काम करते हैं। ये null और अनुपस्थित फ़ील्ड के मानों को नज़रअंदाज़ करते हैं।
db.orders.aggregate([{
$group: {
_id: '$productId',
avgRating: { $avg: '$rating' }, // average rating
minPrice: { $min: '$price' }, // lowest price ever sold
maxPrice: { $max: '$price' }, // highest price ever sold
firstOrder: { $min: '$createdAt' }, // earliest date
latestOrder: { $max: '$createdAt' } // most recent date
}
}]);$group में $count
हालाँकि आम तौर पर $group चरण में { $sum: 1 } का उपयोग करके गिनती की जाती है, MongoDB दस्तावेज़ों की धारा में कुल दस्तावेज़ों की संख्या गिनने के लिए एक स्वतंत्र $count चरण भी देता है। $count चरण आपके द्वारा निर्दिष्ट फ़ील्ड नाम के अंतर्गत गिनती वाला एक ही दस्तावेज़ निकालता है। यह _id: null वाले $group और $sum: 1 के समकक्ष है।
// Count total published articles
db.articles.aggregate([
{ $match: { status: 'published' } },
{ $count: 'totalPublished' } // emits { totalPublished: N }
]);
// Equivalent using $group:
db.articles.aggregate([
{ $match: { status: 'published' } },
{ $group: { _id: null, totalPublished: { $sum: 1 } } }
]);संयुक्त ग्रुपिंग कुंजियाँ
एक साथ कई फ़ील्ड के आधार पर समूह बनाने के लिए _id के रूप में कोई ऑब्जेक्ट दें। ऑब्जेक्ट की प्रत्येक कुंजी संयुक्त समूह-कुंजी का एक भाग बन जाती है। आउटपुट दस्तावेज़ों में नेस्ट की गई _id ऑब्जेक्ट होती है। 'क्षेत्र और माह के अनुसार राजस्व' जैसे बहुआयामी एग्रीगेशन तैयार करने का यह मानक तरीका है।
// Revenue breakdown by region AND year-month
db.sales.aggregate([
{ $group: {
_id: {
region: '$region',
year: { $year: '$saleDate' },
month: { $month: '$saleDate' }
},
revenue: { $sum: '$amount' },
count: { $sum: 1 }
}},
{ $sort: { '_id.year': 1, '_id.month': 1, '_id.region': 1 } }
]);
// Output: { _id: { region: 'EMEA', year: 2024, month: 3 }, revenue: 50000, count: 120 }$push के साथ ऐरे में मान जमा करना
$push संचायक समूहित दस्तावेज़ों में किसी फ़ील्ड से मिले सभी मानों को एक ऐरे में एकत्र करता है। यह किसी उपयोगकर्ता के सभी ऑर्डर आईडी, किसी श्रेणी के सभी टैग या किसी उत्पाद को खरीदने वाले सभी उपयोगकर्ता आईडी एकत्र करने के लिए उपयोगी है। परिणामस्वरूप बनी ऐरे में दोहराए गए मान हो सकते हैं; विशिष्ट मान एकत्र करने के लिए इसके बजाय $addToSet का उपयोग करें।
// Collect all order IDs per user
db.orders.aggregate([{
$group: {
_id: '$userId',
orderIds: { $push: '$_id' }, // all order IDs for this user
amounts: { $push: '$amount' }, // all amounts
// Collect whole sub-documents
orderSummaries: {
$push: { orderId: '$_id', amount: '$amount', status: '$status' }
}
}
}]);$first और $last संचायक
$first और $last प्रत्येक समूह के लिए दस्तावेज़ों के प्रोसेस होने के क्रम में मिलने वाला पहला और अंतिम फ़ील्ड मान लौटाते हैं। चूँकि पहले क्रमबद्ध किए बिना MongoDB दस्तावेज़ों का क्रम सुनिश्चित नहीं करता, इसलिए $first/$last को सार्थक बनाने के लिए $group चरण से पहले $sort चरण जोड़ना चाहिए—उदाहरण के लिए, 'प्रत्येक ग्राहक की पहली ऑर्डर तिथि'।
// Most and least recent order per customer
db.orders.aggregate([
{ $sort: { createdAt: 1 } }, // sort BEFORE group for meaningful first/last
{ $group: {
_id: '$customerId',
firstOrder: { $first: '$createdAt' },
firstOrderId: { $first: '$_id' },
lastOrder: { $last: '$createdAt' },
lastAmount: { $last: '$amount' }
}}
]);गणना किए गए एक्सप्रेशन पर ग्रुपिंग
$group में _id केवल फ़ील्ड संदर्भ ही नहीं, बल्कि कोई भी एक्सप्रेशन हो सकता है। आप कटे हुए दिनांक (वर्ष-सप्ताह), गणना की गई श्रेणी, गणितीय बकेट या किसी फ़ील्ड के उपस्ट्रिंग के आधार पर समूह बना सकते हैं। इससे संग्रहीत दस्तावेज़ों में पहले से गणना किए गए बकेट फ़ील्ड की आवश्यकता के बिना लचीले विश्लेषणात्मक समूह बनाए जा सकते हैं।
// Group orders by price bucket: 0-99, 100-499, 500+
db.orders.aggregate([{
$group: {
_id: {
$switch: {
branches: [
{ case: { $lt: ['$amount', 100] }, then: 'small' },
{ case: { $lt: ['$amount', 500] }, then: 'medium' }
],
default: 'large'
}
},
count: { $sum: 1 },
totalRevenue: { $sum: '$amount' }
}
}]);दो-चरणीय ग्रुपिंग
जटिल विश्लेषण के लिए अक्सर क्रम से दो $group चरणों की आवश्यकता होती है: पहला विस्तृत स्तर (जैसे उपयोगकर्ता के अनुसार) पर समूह बनाता है और दूसरा पहले चरण के परिणामों को उच्च स्तर (जैसे क्षेत्र के अनुसार) पर समूहित करता है। यह दो-चरणीय तरीका नेस्ट किए गए $group एक्सप्रेशन से बचाता है और अधिक साफ़ तथा आसानी से समझी जाने वाली pipeline तैयार करता है।
// Average orders per user, per region
db.orders.aggregate([
// Stage 1: sum per user
{ $group: {
_id: { userId: '$userId', region: '$region' },
userOrderCount: { $sum: 1 }
}},
// Stage 2: average of those sums, per region
{ $group: {
_id: '$_id.region',
avgOrdersPerUser: { $avg: '$userOrderCount' },
uniqueUsers: { $sum: 1 }
}}
]);$group का प्रदर्शन: इंडेक्स उपलब्ध नहीं
$match के विपरीत, $group चरण इंडेक्स का उपयोग नहीं कर सकता—इसे भेजे गए सभी दस्तावेज़ों को संसाधित करना पड़ता है। इसी कारण शुरुआती $match से इनपुट को कम करना अत्यंत महत्वपूर्ण है। बहुत बड़े डेटासेट में, जहाँ $group बहुत अधिक मेमोरी का उपयोग करता है, डिस्क पर अस्थायी रूप से डेटा लिखने के लिए allowDiskUse: true सेट करें। एक अन्य विकल्प है कि एग्रीगेट किए गए मानों की पहले से गणना करके उन्हें संग्रहीत किया जाए (Computed Pattern), जिससे बार-बार उपयोग होने वाले पथों पर रनटाइम ग्रुपिंग से बचा जा सके।
// Allow disk use for large aggregations
db.orders.aggregate(
[
{ $match: { year: 2024 } },
{ $group: { _id: '$productId', revenue: { $sum: '$amount' } } },
{ $sort: { revenue: -1 } }
],
{ allowDiskUse: true } // spill to disk if memory limit exceeded
);त्वरित जाँच
एग्रीगेशन पाइपलाइन में $group चरण की अपनी समझ जाँचें।
पाठ का सारांश
इस पाठ में आपने सीखा: $group दस्तावेज़ों को _id फ़ील्ड में परिभाषित कुंजी के आधार पर समूहीकृत करता है, $sum, $avg, $min, $max, $push जैसे संचायक प्रत्येक समूह के लिए एग्रीगेट किए गए मानों की गणना करते हैं, और दो-चरणीय ग्रुपिंग पदानुक्रमित विश्लेषण सक्षम करती है। आगे हम एग्रीगेशन परिणामों को क्रमबद्ध करने और पृष्ठों में बाँटने के लिए $sort, $limit और $skip देखेंगे।
एआई शिक्षक के साथ JavaScript सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “$group: समूहीकरण और कुल की गणना” पाठ निःशुल्क है?
हाँ—“$group: समूहीकरण और कुल की गणना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और MongoDB Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। MongoDB Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“$group: समूहीकरण और कुल की गणना” में मैं क्या सीखूँगा?
शिक्षार्थी कुंजी के आधार पर दस्तावेज़ों को समूहित करेंगे और $group से योग, औसत, गिनती तथा अन्य संचयक मानों की गणना करेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ MongoDB Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या MongoDB Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर MongoDB Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।
“$group: समूहीकरण और कुल की गणना” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस MongoDB Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर MongoDB Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- डेटा-प्रवाह की अवधारणाएँ: चरण, ऑपरेटर और अभिव्यक्तियाँ
- $match और $project: फ़िल्टर करना और नया आकार देना
- $group: समूहीकरण और कुल की गणना
- डेटा-प्रवाह में $sort, $limit और $skip