16mb आकार से ऊपर के दस्तावेज़ के लिए MongoDB वर्कअराउंड?

इस समस्या को ठीक करने के लिए आपको अपनी डेटा संरचना में कुछ छोटे संशोधन करने होंगे। इसकी आवाज़ से, आपके दस्तावेज़ों के लिए 16mb की सीमा से अधिक होने के लिए, आपको अपने सेंसर डेटा को एक ही दस्तावेज़ में एक सरणी में एम्बेड करना होगा।

मैं यहां ग्रिडएफएस का उपयोग करने का सुझाव नहीं दूंगा, मुझे विश्वास नहीं है कि यह सबसे अच्छा समाधान है, और यही कारण है।

बकेटिंग के रूप में जानी जाने वाली एक तकनीक है जिसे आप नियोजित कर सकते हैं जो अनिवार्य रूप से आपके सेंसर रीडिंग को अलग-अलग दस्तावेज़ों में विभाजित कर देगा, जिससे आपके लिए यह समस्या हल हो जाएगी।

इसके काम करने का तरीका यह है:

मान लें कि मेरे पास एक विशेष सेंसर के लिए कुछ एम्बेडेड रीडिंग वाला दस्तावेज़ है जो इस तरह दिखता है:

{
    _id : ObjectId("xxx"),
    sensor : "SensorName1",
    readings : [
        { date : ISODate("..."), reading : "xxx" },
        { date : ISODate("..."), reading : "xxx" },
        { date : ISODate("..."), reading : "xxx" }
    ]
}

ऊपर की संरचना के साथ, पहले से ही एक बड़ी खामी है, रीडिंग सरणी तेजी से बढ़ सकती है, और 16mb दस्तावेज़ सीमा से अधिक हो सकती है।

तो हम क्या कर सकते हैं कि इस तरह दिखने के लिए संरचना को थोड़ा बदल दें, गिनती संपत्ति को शामिल करने के लिए:

{
    _id : ObjectId("xxx"),
    sensor : "SensorName1",
    readings : [
        { date : ISODate("..."), reading : "xxx" },
        { date : ISODate("..."), reading : "xxx" },
        { date : ISODate("..."), reading : "xxx" }
    ],
    count : 3
}

इसके पीछे का विचार यह है, जब आप अपने पढ़ने को अपने एम्बेडेड सरणी में $ पुश करते हैं, तो आप किए गए प्रत्येक पुश के लिए गिनती चर ($ inc) बढ़ाते हैं। और जब आप यह अपडेट (पुश) ऑपरेशन करते हैं, तो आप इस "गिनती" संपत्ति पर एक फ़िल्टर शामिल करेंगे, जो कुछ इस तरह दिख सकता है:

{ count : { $lt : 500} }

फिर, अपने अपडेट विकल्प सेट करें ताकि आप "अप्सर्ट" को "ट्रू" पर सेट कर सकें:

db.sensorReadings.update(
    { name: "SensorName1", count { $lt : 500} },
    {
        //Your update. $push your reading and $inc your count
        $push: { readings: [ReadingDocumentToPush] }, 
        $inc: { count: 1 }
    },
    { upsert: true }
)

MongoDb अपडेट और अप्सर्ट विकल्प के बारे में अधिक जानकारी के लिए यहां देखें:

MongoDB अद्यतन दस्तावेज़ीकरण

क्या होगा, जब फ़िल्टर शर्त पूरी नहीं होती है (यानी जब इस सेंसर के लिए कोई मौजूदा दस्तावेज़ नहीं है, या गिनती 500 से अधिक या बराबर है - क्योंकि आप हर बार किसी आइटम को धक्का देने पर इसे बढ़ा रहे हैं), एक नया दस्तावेज़ बनाया जाएगा, और रीडिंग अब इस नए दस्तावेज़ में एम्बेड की जाएंगी। इसलिए यदि आप इसे ठीक से करते हैं तो आप कभी भी 16mb की सीमा तक नहीं पहुंचेंगे।

अब, किसी विशेष सेंसर की रीडिंग के लिए डेटाबेस से पूछताछ करते समय, आप उस सेंसर के लिए कई दस्तावेज़ वापस प्राप्त कर सकते हैं (इसमें सभी रीडिंग के साथ केवल एक के बजाय), उदाहरण के लिए, यदि आपके पास 10,000 रीडिंग हैं, तो आपको 20 दस्तावेज़ वापस मिलेंगे , प्रत्येक 500 रीडिंग के साथ।

फिर आप अपनी रीडिंग को फ़िल्टर करने के लिए एकत्रीकरण पाइपलाइन और $unwind का उपयोग कर सकते हैं जैसे कि वे उनके स्वयं के व्यक्तिगत दस्तावेज़ हों।

आराम करने के बारे में अधिक जानकारी के लिए यहां देखें, यह बहुत उपयोगी है

MongoDB अनविंड करें

मुझे आशा है कि यह मदद करता है।