MongoDB Academy · पाठ

बकेट और गणित पैटर्न

शिक्षार्थी टाइम सीरीज़ डेटा को बकेट दस्तावेज़ों में समूहित करके इंडेक्स का आकार घटाएँगे और महँगी रीयल-टाइम गणनाओं से बचने के लिए एकत्रित मानों की पूर्व-गणना करेंगे।

पाठ 1, कुल 4 में से13 चरण

बकेट और गणित पैटर्न, CoddyKit पर MongoDB Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह MongoDB Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। MongoDB Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

स्कीमा डिज़ाइन पैटर्न का परिचय

विशेषज्ञ MongoDB इंजीनियर सहज अनुमान से स्कीमा डिज़ाइन नहीं करते — वे बार-बार आने वाली चुनौतियों का समाधान करने वाली सिद्ध पैटर्नों की लाइब्रेरी का उपयोग करते हैं। ये पैटर्न MongoDB के स्टोरेज इंजन, index संरचना और एग्रीगेशन पाइपलाइन के अलग-अलग दस्तावेज़ आकारों के साथ व्यवहार से मिले कठिन अनुभवों को समाहित करते हैं। Bucket Pattern और Computed Pattern प्रदर्शन-संवेदनशील एप्लिकेशनों के लिए सबसे प्रभावशाली दो पैटर्न हैं।

समस्या: बहुत अधिक छोटे दस्तावेज़

एक ऐसे IoT सिस्टम पर विचार करें जिसमें प्रत्येक सेंसर रीडिंग एक अलग दस्तावेज़ हो। हर सेकंड एक रीडिंग देने वाला सेंसर प्रतिदिन 86,400 दस्तावेज़ बनाता है। इसका अर्थ है कि प्रत्येक सेंसर के लिए प्रतिदिन 86,400 index प्रविष्टियाँ, बहुत बड़े index आकार और एक दिन के डेटा की क्वेरी करते समय बड़ी संख्या में कार्रवाइयाँ। 24 घंटे का डेटा पढ़ने के लिए दसियों हज़ार छोटे दस्तावेज़ लाने पड़ते हैं — यह बहुत अक्षम है।

// Anti-pattern: one document per reading
{
  _id: ObjectId(),
  sensorId: 'sensor-42',
  timestamp: ISODate('2024-06-01T10:00:01Z'),
  temperature: 23.1
}
// 86,400 such documents per sensor per day
// 86,400 index entries per sensor per day

Bucket Pattern: बकेट में समूह बनाना

Bucket Pattern संबंधित छोटे दस्तावेज़ों को एक बड़े दस्तावेज़ (जिसे 'बकेट' कहते हैं) में समूहित करता है। प्रत्येक रीडिंग के लिए एक दस्तावेज़ रखने के बजाय, एक दस्तावेज़ में एक घंटे की रीडिंग रखी जाती हैं — इससे 3,600 दस्तावेज़ घटकर 1 और 3,600 index प्रविष्टियाँ घटकर 1 हो जाती हैं। बकेट दस्तावेज़ में मापों की एक सारणी और लिखते समय गणना किए गए सारांश आँकड़े होते हैं। इससे index का आकार बहुत कम होता है और रेंज क्वेरी का प्रदर्शन बेहतर होता है।

// Bucket Pattern: one document per sensor per hour
{
  _id: ObjectId(),
  sensorId: 'sensor-42',
  date: ISODate('2024-06-01T10:00:00Z'),  // hour bucket boundary
  count: 3600,
  measurements: [
    { ts: ISODate('2024-06-01T10:00:01Z'), temp: 23.1 },
    { ts: ISODate('2024-06-01T10:00:02Z'), temp: 23.2 },
    // ... 3598 more readings ...
  ],
  // Pre-computed summaries
  avgTemp: 23.15,
  maxTemp: 24.1,
  minTemp: 22.8
}

$push और $inc से बकेट में जोड़ना

जब कोई नया माप प्राप्त हो, तो सेंसर और घंटे के लिए वर्तमान बकेट दस्तावेज़ खोजें और $push का उपयोग करके measurements सारणी में नया मान जोड़ने तथा $inc का उपयोग करके count बढ़ाने के लिए उसे परमाणु रूप से अपडेट करें। upsert: true का उपयोग करें, ताकि यदि वर्तमान घंटे का बकेट अभी मौजूद न हो, तो MongoDB अपने आप नया बकेट दस्तावेज़ बना दे।

const now = new Date()
const hourBucket = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours())

db.sensorBuckets.updateOne(
  {
    sensorId: 'sensor-42',
    date: hourBucket,
    count: { $lt: 3600 }  // don't overfill a bucket
  },
  {
    $push: { measurements: { ts: now, temp: 23.5 } },
    $inc: { count: 1 },
    $min: { minTemp: 23.5 },
    $max: { maxTemp: 23.5 }
  },
  { upsert: true }
)

बकेट के बीच क्वेरी करना

किसी समय-सीमा में सेंसर की सभी रीडिंग प्राप्त करने के लिए, बकेट दस्तावेज़ों में sensorId और date की सीमा के आधार पर क्वेरी करें। फिर समग्र परिणामों के लिए पहले से गणना किए गए सारांश का उपयोग करें, या प्रत्येक रीडिंग तक पहुँचने के लिए measurements सारणी पर $unwind लागू करें। अब 24 घंटे के डेटा को क्वेरी करने पर 86,400 अलग-अलग दस्तावेज़ों के बजाय 24 बकेट दस्तावेज़ पढ़े जाते हैं — प्राप्त किए जाने वाले दस्तावेज़ों में 3,600 गुना कमी।

// Get hourly summaries for a day (reads 24 bucket docs)
db.sensorBuckets.find(
  {
    sensorId: 'sensor-42',
    date: {
      $gte: ISODate('2024-06-01T00:00:00Z'),
      $lt:  ISODate('2024-06-02T00:00:00Z')
    }
  },
  { _id: 0, date: 1, avgTemp: 1, maxTemp: 1, minTemp: 1, count: 1 }
).sort({ date: 1 })

Computed Pattern: परिणामों की पहले से गणना करना

Computed Pattern महँगी समग्र गणनाओं को लिखने के समय पहले ही कर लेता है और परिणाम को सीधे दस्तावेज़ में संग्रहीत करता है। पढ़ने के समय किसी product की औसत रेटिंग निकालने के लिए सभी समीक्षाओं का योग करने के बजाय, जब भी नई समीक्षा जोड़ी जाए तब इसकी गणना करें और product दस्तावेज़ में reviewCount के साथ avgRating संग्रहीत करें। पढ़ना बहुत सस्ता हो जाता है — केवल पहले से गणना किए गए फ़ील्ड को लौटाना होता है।

// Product document with pre-computed stats
{
  _id: ObjectId(),
  name: 'Wireless Headphones',
  price: 149.99,
  // Pre-computed at write time
  reviewCount: 1247,
  avgRating: 4.3,
  ratingSum: 5362.1  // stored to recompute avg without fetching all reviews
}

Computed फ़ील्ड को क्रमिक रूप से अपडेट करना

जब नई समीक्षा प्राप्त हो, तो शुरुआत से दोबारा गणना करने के बजाय उसी ऑपरेशन में computed फ़ील्ड को परमाणु रूप से अपडेट करें। $inc से reviewCount और ratingSum बढ़ाएँ, फिर avgRating की दोबारा गणना करें। MongoDB में यह pipeline-जैसे update से किया जा सकता है (MongoDB 4.2+), जिसमें अपडेट किए गए count और sum से औसत निर्धारित करने के लिए $divide का उपयोग होता है।

// Atomic incremental update of computed stats
db.products.updateOne(
  { _id: productId },
  [
    {
      $set: {
        reviewCount: { $add: ['$reviewCount', 1] },
        ratingSum: { $add: ['$ratingSum', newRating] }
      }
    },
    {
      $set: {
        avgRating: { $divide: ['$ratingSum', '$reviewCount'] }
      }
    }
  ]
)

Computed Pattern का उपयोग कब करें

Computed Pattern तब सबसे अधिक उपयोगी होता है जब लेखन की तुलना में पढ़ने की संख्या बहुत अधिक हो और पढ़ने के समय गणना महँगी हो। Product की औसत रेटिंग, लीडरबोर्ड स्कोर, लेख के देखे जाने की संख्या और कुल आय — ये सभी इसके उत्कृष्ट उपयोग-प्रकरण हैं। इसका लाभ लेने के बदले लिखने की जटिलता थोड़ी बढ़ती है और स्रोत डेटा बदलने पर computed मानों को सुसंगत रखने की आवश्यकता होती है। यदि पढ़ना और लिखना दोनों ही बार-बार होते हैं, तो समकालिक अपडेट के बजाय समय-समय पर दोबारा गणना करने वाले पृष्ठभूमि कार्यों पर विचार करें।

दोनों पैटर्न को मिलाना

Bucket और Computed पैटर्न का अक्सर साथ में उपयोग किया जाता है। कोई सेंसर डेटा सिस्टम रीडिंग को प्रति घंटे के बकेट दस्तावेज़ों में समूहित कर सकता है (Bucket Pattern) और पूरे दिन के लिए min/max/avg संग्रहीत करने वाला पहले से गणना किया गया दैनिक सारांश दस्तावेज़ बनाए रख सकता है (Computed Pattern)। इस स्तरीकृत तरीके से दैनिक रुझान दिखाने वाले डैशबोर्ड को केवल एक दस्तावेज़ पढ़ना पड़ता है, जबकि विस्तृत क्वेरी केवल 24 प्रति-घंटे वाले बकेट दस्तावेज़ों को स्कैन करती है।

// Daily summary document (Computed Pattern on top of Bucket Pattern)
{
  _id: ObjectId(),
  sensorId: 'sensor-42',
  date: ISODate('2024-06-01T00:00:00Z'),
  totalReadings: 86400,
  dailyAvgTemp: 22.8,
  dailyMaxTemp: 28.4,
  dailyMinTemp: 18.2,
  peakHour: 14  // hour with highest average temperature
}

बकेट के आकार का संतुलन

बकेट दस्तावेज़ों का आकार बिना सीमा के नहीं बढ़ना चाहिए — MongoDB में दस्तावेज़ के आकार की सीमा 16 MB है। उच्च डेटा दर वाले सेंसर के लिए समय-सीमित बकेट का उपयोग करें (जैसे, प्रति घंटा या प्रति दिन एक)। अपडेट फ़िल्टर में दिया गया count: { $lt: 3600 } सुरक्षा-नियम बकेट को जरूरत से अधिक भरने से रोकता है। यदि कोई बकेट अपनी क्षमता तक पहुँच जाता है, तो upsert अपने आप नया बकेट बना देता है। उत्पादन परिवेश में बकेट भरने की दर पर नज़र रखें, ताकि आपके डेटा की दर के अनुसार बकेट का आकार ठीक किया जा सके।

Bucket Pattern का अनुक्रमणिका पर प्रभाव

बकेट संग्रह की प्राथमिक अनुक्रमणिका को क्वेरी पैटर्न को कवर करना चाहिए: { sensorId: 1, date: 1 }। इस संयुक्त अनुक्रमणिका के कारण सेंसर और समय-सीमा के आधार पर फ़िल्टर करने वाली क्वेरी सीधे अनुक्रमणिका तक पहुँचती हैं। 86,400 अलग-अलग दस्तावेज़ों के timestamp फ़ील्ड को अनुक्रमित करने की तुलना में, बकेट संग्रह की अनुक्रमणिका में प्रति सेंसर प्रति दिन केवल 24 प्रविष्टियाँ होती हैं — अनुक्रमणिका के आकार में 3,600 गुना कमी, जिससे सक्रिय डेटा का RAM में समा पाना बहुत बेहतर हो जाता है।

// Create supporting index for bucket pattern queries
db.sensorBuckets.createIndex({ sensorId: 1, date: 1 })

// Explain query to verify IXSCAN usage
db.sensorBuckets.find({ sensorId: 'sensor-42', date: { $gte: ISODate('2024-06-01T00:00:00Z') } }).explain('executionStats')

त्वरित जाँच

इस पाठ में MongoDB और NoSQL Database की अवधारणाओं के बारे में अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन

इस पाठ में आपने सीखा: Bucket Pattern कई छोटे दस्तावेज़ों को कम संख्या वाले बड़े दस्तावेज़ों में समूहित करता है, जिससे अनुक्रमणिका का आकार बहुत घटता है और सीमा-आधारित क्वेरी का प्रदर्शन बेहतर होता है; Computed Pattern महँगी समग्र गणनाओं को लिखने के समय पहले ही कर लेता है, ताकि पढ़ने पर पहले से संग्रहीत मान तुरंत लौटाए जा सकें; और समय-श्रृंखला की बहु-स्तरीय pipelines के लिए दोनों पैटर्न प्रभावी रूप से साथ काम करते हैं। आगे हम Extended Reference और Subset Patterns का अध्ययन करेंगे।

शुरुआत निःशुल्क

एआई शिक्षक के साथ JavaScript सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 30
पाठ: 120

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “बकेट और गणित पैटर्न” पाठ निःशुल्क है?

हाँ—“बकेट और गणित पैटर्न” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और MongoDB Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। MongoDB Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“बकेट और गणित पैटर्न” में मैं क्या सीखूँगा?

शिक्षार्थी टाइम सीरीज़ डेटा को बकेट दस्तावेज़ों में समूहित करके इंडेक्स का आकार घटाएँगे और महँगी रीयल-टाइम गणनाओं से बचने के लिए एकत्रित मानों की पूर्व-गणना करेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ MongoDB Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या MongoDB Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर MongoDB Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“बकेट और गणित पैटर्न” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस MongoDB Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर MongoDB Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← MongoDB Academy पर वापस जाएँ