MongoDB स्कीमा वैलिडेशन: उदाहरणों के साथ एक व्यावहारिक गाइड

MongoDB भले ही स्कीमा-लेस हो, लेकिन इसका मतलब यह नहीं कि आपका डेटा बिखरा हुआ हो।

इस लेख में, आप $jsonSchema ऑपरेटर का उपयोग करते हुए स्कीमा वैलिडेशन की बुनियाद से लेकर उन्नत उपयोग मामलों तक सब कुछ सीखेंगे। आप जानेंगे कि आवश्यक फ़ील्ड कैसे लागू करें, डेटा प्रकारों को कैसे सीमित करें, पैटर्न कैसे लगाएँ, और नेस्टेड दस्तावेज़ों को कैसे वैलिडेट करें। 

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

अंत तक, आप अपनी MongoDB कलेक्शंस पर स्कीमा वैलिडेशन लागू करने में आत्मविश्वास महसूस करेंगे—अपना डेटा साफ़ और पूर्वानुमेय रखते हुए, बिना उस लचीलापन छोड़े जिसके लिए MongoDB जानी जाती है। आप और जानने के लिए हमारा स्कीमा वैलिडेशन पर वीडियो भी देख सकते हैं।

MongoDB में स्कीमा वैलिडेशन क्यों महत्वपूर्ण है

MongoDB का डायनेमिक डॉक्यूमेंट मॉडल एक ही कलेक्शन में अलग-अलग फ़ील्ड्स या संरचनाएँ रखने की अनुमति देकर गति और लचीलापन प्रदान करता है। शुरुआती विकास या तेज़ इटरेशन के दौरान यह बड़ा फायदा है। हालांकि, यही लचीलापन आपके एप्लिकेशन के बढ़ने के साथ असंगत, अपूर्ण, या अवैध डेटा का कारण बन सकता है।

यहीं पर स्कीमा वैलिडेशन काम आता है। यह आपको अपने दस्तावेज़ों के लिए नियम परिभाषित करने देता है—जैसे आवश्यक फ़ील्ड्स, विशेष डेटा प्रकार, या नेस्टेड संरचनाएँ—और फिर भी MongoDB की लचीली प्रकृति को अपनाए रखता है।

इस लेख में, आप MongoDB के शक्तिशाली $jsonSchema ऑपरेटर का उपयोग करके ये नियम अपनी कलेक्शंस पर कैसे लागू करें, यह सीखेंगे। चाहे आप नए एप्लिकेशन में गलत इंसर्ट्स को रोक रहे हों या किसी पुरानी डेटाबेस पर वैलिडेशन नियम जोड़ रहे हों, स्कीमा वैलिडेशन आपके डेटा को साफ़, क्वेरीज़ को पूर्वानुमेय, और एप्लिकेशन को स्थिर बनाए रखने में मदद करता है।

यदि आप MongoDB और Python के साथ काम करने में नए हैं, तो यह MongoDB परिचयात्मक कोर्स स्कीमा वैलिडेशन में उतरने से पहले क्वेरीज़ और इंटिग्रेशंस पर व्यावहारिक पकड़ बनाने का एक अच्छा तरीका है।

शुरू करने से पहले

इस गाइड का अधिकतम लाभ उठाने के लिए, आपको एक MongoDB Atlas क्लस्टर तक पहुंच चाहिए। फ्री टियर साथ चलने के लिए पर्याप्त है।

संकल्पनाओं को यथासंभव स्पष्ट और लागू करने योग्य बनाने के लिए, हम एक MongoDB Atlas सैंपल डेटासेट—विशेष रूप से sample_mflix डेटाबेस—का उपयोग करेंगे। इस डेटासेट में movies, comments, users, और theaters जैसी कलेक्शंस शामिल हैं, जिन्हें हम प्रत्येक उदाहरण दिखाने के लिए पूरे लेख में संदर्भित करेंगे। इस डेटासेट में नेस्टेड ऑब्जेक्ट्स, एरेज़, स्ट्रिंग्स, नंबर्स, और वैकल्पिक फ़ील्ड्स जैसे फ़ील्ड्स वाले दस्तावेज़ शामिल हैं।

सैंपल डेटासेट लोड करें (यदि आवश्यक हो)

1. अपने MongoDB Atlas डैशबोर्ड पर जाएँ।

2. अपना क्लस्टर चुनें, “…” बटन पर क्लिक करें, और Load Sample Dataset चुनें।

3. कुछ मिनट प्रतीक्षा करें जब तक कि sample_mflix डेटाबेस उपलब्ध न हो जाए।

स्कीमा वैलिडेशन के साथ शुरुआत

एक बार आपका डेटासेट लोड हो जाने पर, MongoDB Shell (mongosh) या MongoDB Compass का उपयोग करके अपने क्लस्टर से कनेक्ट करें, फिर डेटासेट पर स्विच करें:

use sample_mflixसंचालित द्वारा

findOne() के साथ डेटासेट की जाँच

आइए movies कलेक्शन के एक दस्तावेज़ का निरीक्षण करें:

db.movies.findOne()संचालित द्वारा

आपको कुछ इस तरह का सरल संस्करण दिखाई दे सकता है:

चित्र 1. यह क्वेरी sample_mflix डेटाबेस की movies कलेक्शन से findOne() का उपयोग कर एक सैंपल दस्तावेज़ प्राप्त करती है। परिणाम में कई फ़ील्ड्स दिखते हैं, जिनमें title, year, genres, और imdb व tomatoes.viewer जैसे नेस्टेड ऑब्जेक्ट्स शामिल हैं।

यह दस्तावेज़ स्केलर मानों, एरेज़, और नेस्टेड ऑब्जेक्ट्स का मिश्रण रखता है, जो वैलिडेशन तकनीकों की एक श्रृंखला प्रदर्शित करने के लिए आदर्श है। अगला, हम इसी संरचना पर आधारित एक नया कलेक्शन बनाएँगे और $jsonSchema का उपयोग करके अपना पहला वैलिडेशन स्कीमा परिभाषित करेंगे।

समर्थित कीवर्ड, एक्सटेंशन, और सीमाएँ

MongoDB का $jsonSchema वैलिडेशन JSON Schema Draft 4 स्पेसिफिकेशन पर आधारित है, कुछ संशोधनों और छोड़े गए हिस्सों के साथ। मूल स्पेक की सभी विशेषताएँ समर्थित नहीं हैं, लेकिन MongoDB BSON दस्तावेज़ों के वैलिडेशन के लिए उपयुक्त एक केंद्रित और व्यावहारिक सबसेट प्रदान करता है।

यहाँ कुछ सबसे आम उपयोग में आने वाले कीवर्ड हैं:

• bsonType: MongoDB-विशिष्ट प्रकार का कीवर्ड (जैसे "string", "int", "array", "object")
• required: बताता है कि कौन-से फ़ील्ड्स अनिवार्य हैं
• minimum/maximum: संख्यात्मक रेंज वैलिडेशन के लिए
• pattern: रेगुलर एक्सप्रेशंस का उपयोग कर स्ट्रिंग फ़ॉर्मेट वैलिडेशन के लिए
• enum: किसी फ़ील्ड को अनुमत मानों के सेट तक सीमित करता है
• items, minItems, maxItems: एरे वैलिडेशन के लिए
• properties: किसी ऑब्जेक्ट के अंदर फ़ील्ड्स के नियम परिभाषित करता है
• additionalProperties: नियंत्रित करता है कि अतिरिक्त (अपरिभाषित) फ़ील्ड्स की अनुमति है या नहीं

MongoDB पूर्ण JSON Schema से कुछ उन्नत सुविधाएँ जानबूझकर छोड़ता है, जैसे:

• स्कीमा रेफरेंसेज़ ($ref)।
• कंडीशनल लॉजिक (if/then/else)।
• कंपोज़िशन ऑपरेटर्स (oneOf, allOf, anyOf)।

समर्थित विकल्पों की पूरी सूची के लिए, यह आधिकारिक MongoDB $jsonSchema दस्तावेज़ देखें।

इस लेख में, हम सबसे व्यावहारिक और व्यापक रूप से समर्थित कीवर्ड्स पर ध्यान देंगे—इतना कि आम वास्तविक-जीवन वैलिडेशन आवश्यकताओं को बिना अनावश्यक जटिलता के कवर किया जा सके।

यह समझने के लिए कि MongoDB व्यापक NoSQL परिदृश्य में कैसे फ़िट बैठता है, यह विस्तृत ट्यूटोरियल देखें।

बेसिक वैलिडेशन के साथ कलेक्शन बनाना

अब जब हमने movies दस्तावेज़ की संरचना देख ली है, तो आइए $jsonSchema का उपयोग करके कुछ बुनियादी नियम लागू करने वाला एक नया कलेक्शन बनाएँ। हम कुछ सामान्य बाधाओं से शुरू करेंगे:

• title: स्ट्रिंग होना चाहिए और आवश्यक है
• year: इन्टीजर होना चाहिए और आवश्यक है
• genres: स्ट्रिंग्स की एरे होनी चाहिए
• runtime: पॉज़िटिव इन्टीजर होना चाहिए

हम इस नए कलेक्शन को validated_movies कहेंगे।

कलेक्शन बनाना

वैलिडेशन के साथ कलेक्शन बनाने के लिए निम्न कमांड चलाएँ:

db.createCollection("validated_movies", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["title", "year", "runtime"],
      properties: {
        title: {
          bsonType: "string",
          description: "must be a string and is required"
        },
        year: {
          bsonType: "int",
          minimum: 1888,
          description: "must be an integer >= 1888 (year of the first film)"
        },
        runtime: {
          bsonType: "int",
          minimum: 1,
          description: "must be a positive integer and is required"
        },
        genres: {
          bsonType: "array",
          items: {
            bsonType: "string"
          },
          description: "must be an array of strings"
        }
      }
    }
  },
  validationLevel: "strict",
  validationAction: "error"
});संचालित द्वारा

मान्य दस्तावेज़ डालना

अब, आइए एक दस्तावेज़ डालें जो स्कीमा का पालन करता है:

db.validated_movies.insertOne({
  title: "Inception",
  year: 2010,
  runtime: 148,
  genres: ["Action", "Sci-Fi", "Thriller"]
});संचालित द्वारा

✅ यह सफल होना चाहिए।

अमान्य दस्तावेज़ डालना

ऐसा दस्तावेज़ डालने का प्रयास करें जिसमें title फ़ील्ड अनुपस्थित हो:

db.validated_movies.insertOne({
  year: 2020,
  runtime: 95,
  genres: ["Drama"]
});संचालित द्वारा

❌ यह वैलिडेशन त्रुटि के साथ विफल होगा क्योंकि title आवश्यक है।

चित्र 2. पहला कमांड validated_movies कलेक्शन में एक मान्य मूवी दस्तावेज़ इन्सर्ट करता है, जो सभी आवश्यक फ़ील्ड्स और डेटा प्रकारों को पास करता है। दूसरा कमांड आवश्यक title फ़ील्ड के बिना दस्तावेज़ इन्सर्ट करने का प्रयास करता है, जिसके परिणामस्वरूप वैलिडेशन त्रुटि आती है।

मौजूदा कलेक्शंस के साथ काम करना

स्कीमा वैलिडेशन का उपयोग करने के लिए आपको शुरुआत से शुरू करने की ज़रूरत नहीं है। MongoDB आपको collMod कमांड का उपयोग करके मौजूदा कलेक्शंस पर वैलिडेशन नियम लागू करने देता है। यह विशेष रूप से तब उपयोगी है जब आप किसी लेगेसी डेटासेट में संरचना जोड़ना चाहते हैं, बिना मौजूदा दस्तावेज़ों को प्रभावित किए।

इस खंड में, हम sample_mflix डेटाबेस की movies कलेक्शन पर एक वैलिडेटर लागू करेंगे।

collMod के साथ वैलिडेटर जोड़ना

आइए एक बुनियादी नियम लागू करें: हर मूवी दस्तावेज़ में स्ट्रिंग प्रकार का title फ़ील्ड होना चाहिए।

db.runCommand({
  collMod: "movies",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["title"],
      properties: {
        title: {
          bsonType: "string",
          description: "must be a string and is required"
        }
      }
    }
  },
  validationLevel: "moderate",
  validationAction: "warn"
});संचालित द्वारा

कलेक्शन पर वैलिडेशन नियमों का निरीक्षण

collMod कमांड का उपयोग कर movies कलेक्शन में बदलाव करने के बाद, आप यह पुष्टि करना चाहेंगे कि वर्तमान में कौन-से वैलिडेशन नियम सक्रिय हैं।

वर्तमान स्कीमा वैलिडेटर की जाँच करने के लिए, यह चलाएँ:

db.getCollectionInfos({ name: "movies" })[0].options.validatorसंचालित द्वारा

यह उस $jsonSchema ऑब्जेक्ट को लौटाता है जो कलेक्शन पर वैलिडेशन नियमों को परिभाषित करता है। यह यह सत्यापित करने का एक उपयोगी तरीका है कि आपका कॉन्फ़िगरेशन सही तरीके से लागू हुआ है, खासकर तब जब आप warn से error जैसे मोड बदलते हैं, या आवश्यक फ़ील्ड्स की संरचना अपडेट करते हैं।

validationLevel और validationAction को समझना

• validationLevel: "moderate": केवल डाले जा रहे या अपडेट किए जा रहे दस्तावेज़ों को वैलिडेट करता है। मौजूदा दस्तावेज़ जो स्कीमा से मेल नहीं खाते, वे त्रुटियाँ ट्रिगर नहीं करेंगे।

• validationAction: "warn": अवैध राइट्स को अस्वीकार करने के बजाय, MongoDB एक चेतावनी लॉग करता है। यह प्रोडक्शन में तब उपयोगी होता है जब आप नियम लागू करने से पहले स्कीमा उल्लंघनों की निगरानी करना चाहते हैं।

स्कीमा का उल्लंघन करने वाला दस्तावेज़ डालने का प्रयास करें:

db.movies.insertOne({
  year: 2023
});संचालित द्वारा

आप लॉग्स में एक चेतावनी देखेंगे, लेकिन राइट सफल हो जाएगा। जब आप आश्वस्त हो जाएँ, तो बाद में एक्शन को "error" में बदलकर नियम को सख्ती से लागू कर सकते हैं।

चित्र 3. insertOne() कमांड स्कीमा नियम का उल्लंघन करने वाला दस्तावेज़ सफलतापूर्वक जोड़ देता है, क्योंकि वैलिडेशन एक्शन "warn" पर सेट है। MongoDB राइट स्वीकार करता है, लेकिन यदि "error" लागू होता, तो गायब title फ़ील्ड वैलिडेशन त्रुटि ट्रिगर कर देता।

नेस्टेड दस्तावेज़ों और एरेज़ का वैलिडेशन

MongoDB दस्तावेज़ों में अक्सर नेस्टेड संरचनाएँ होती हैं, जैसे ऑब्जेक्ट्स के भीतर ऑब्जेक्ट्स और मानों की एरेज़। सौभाग्य से, $jsonSchema दोनों का वैलिडेशन सपोर्ट करता है। आइए movies कलेक्शन के फ़ील्ड्स का उपयोग करते हुए सबडॉक्यूमेंट्स और एरे कंटेंट पर नियम लागू करना सीखें।

नेस्टेड दस्तावेज़ का वैलिडेशन

movies कलेक्शन में, प्रत्येक दस्तावेज़ में एक एम्बेडेड imdb ऑब्जेक्ट होता है, जिसमें rating, votes, और id जैसे फ़ील्ड्स होते हैं। आइए यह नियम लागू करें कि:

• imdb एक ऑब्जेक्ट हो (यदि मौजूद हो)।
• imdb.rating 0 और 10 के बीच की संख्या हो।

इसे आप इस प्रकार परिभाषित करेंगे:

db.createCollection("validated_nested", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      properties: {
        imdb: {
          bsonType: "object",
          properties: {
            rating: {
              bsonType: "double",
              minimum: 0,
              maximum: 10,
              description: "Must be a number between 0 and 10"
            }
          }
        }
      }
    }
  }
});संचालित द्वारा

नेस्टेड दस्तावेज़ का परीक्षण

✅ मान्य इन्सर्ट:

db.validated_nested.insertOne({
  title: "Interstellar",
  imdb: { rating: 8.6 }
});संचालित द्वारा

❌ अमान्य इन्सर्ट (रेटिंग सीमा से बाहर):

db.validated_nested.insertOne({
  title: "Bad Movie",
  imdb: { rating: 12.5 }
});संचालित द्वारा

यह वैलिडेशन त्रुटि देगा क्योंकि रेटिंग 10 से अधिक है।      चित्र 4. यह इन्सर्ट ऑपरेशन विफल होता है क्योंकि नेस्टेड imdb ऑब्जेक्ट के अंदर rating फ़ील्ड स्कीमा में परिभाषित 10 के अधिकतम मान से अधिक है। $jsonSchema नियम के उल्लंघन के कारण MongoDB वैलिडेशन त्रुटि फेंकता है।

एरेज़ का वैलिडेशन

आप एरे बाधाएँ भी लागू कर सकते हैं। मान लीजिए आप यह सुनिश्चित करना चाहते हैं कि:

• genres स्ट्रिंग्स की एरे हो।
• एरे में कम से कम एक आइटम हो।

इसे अपने स्कीमा में जोड़ें:

genres: {
  bsonType: "array",
  minItems: 1,
  items: {
    bsonType: "string"
  },
  description: "Must be a non-empty array of strings"
}संचालित द्वारा

एकाधिक बाधाओं को संयोजित करना

वास्तविक-जीवन के एप्लिकेशंस में, आपके दस्तावेज़ों को अक्सर एक साथ कई वैलिडेशन नियमों को पूरा करना होता है—जिनमें आवश्यक फ़ील्ड्स, अनुमत मान, प्रकार, और नेस्टेड संरचनाएँ शामिल हैं। $jsonSchema के साथ, आप एक ही स्कीमा परिभाषा में आसानी से कई बाधाएँ जोड़ सकते हैं।

आइए movies दस्तावेज़ संरचना का उपयोग कर एक अधिक पूर्ण उदाहरण बनाते हैं। हम निम्न नियम लागू करेंगे:

• title: आवश्यक, स्ट्रिंग होना चाहिए
• year: आवश्यक, इन्टीजर, ≥ 1888
• rated: वैकल्पिक, पर पूर्वपरिभाषित मानों के सेट से मेल खाना चाहिए
• genres: स्ट्रिंग्स की non-empty एरे होनी चाहिए
• imdb.rating: 0 और 10 के बीच की संख्या
• tomatoes.viewer.rating: वैकल्पिक, 0 और 5 के बीच की संख्या

वैलिडेटेड कलेक्शन बनाना

db.createCollection("validated_full", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["title", "year"],
      properties: {
        title: {
          bsonType: "string",
          description: "Title is required and must be a string"
        },
        year: {
          bsonType: "int",
          minimum: 1888,
          description: "Year must be an integer >= 1888"
        },
        rated: {
          enum: ["G", "PG", "PG-13", "R", "NC-17"],
          description: "Must be a valid MPAA rating"
        },
        genres: {
          bsonType: "array",
          minItems: 1,
          items: { bsonType: "string" },
          description: "Must be a non-empty array of strings"
        },
        imdb: {
          bsonType: "object",
          properties: {
            rating: {
              bsonType: "double",
              minimum: 0,
              maximum: 10,
              description: "IMDB rating must be between 0 and 10"
            }
          }
        },
        tomatoes: {
          bsonType: "object",
          properties: {
            viewer: {
              bsonType: "object",
              properties: {
                rating: {
                  bsonType: "double",
                  minimum: 0,
                  maximum: 5,
                  description: "Viewer rating must be between 0 and 5"
                }
              }
            }
          }
        }
      }
    }
  }
});संचालित द्वारा

मान्य दस्तावेज़ डालना: 

db.validated_full.insertOne({
  title: "The Matrix",
  year: 1999,
  rated: "R",
  genres: ["Action", "Sci-Fi"],
  imdb: { rating: 8.7 },
  tomatoes: { viewer: { rating: 4.2 } }
});संचालित द्वारा

अमान्य दस्तावेज़ डालना:

db.validated_full.insertOne({
  title: "Untitled Project",
  year: 2025,
  rated: "Unrated",
  genres: [],
  imdb: { rating: 15 },
  tomatoes: { viewer: { rating: 6.1 } }
});संचालित द्वारा

यह निम्न कारणों से विफल होगा:

• अमान्य rated मान।
• खाली genres एरे।
• imdb.rating 10 से अधिक।
• tomatoes.viewer.rating 5 से अधिक।

चित्र 5. validated_full कलेक्शन में यह इन्सर्ट ऑपरेशन कई स्कीमा उल्लंघनों के कारण विफल होता है। rated फ़ील्ड में enum द्वारा अनुमत नहीं मान है, genres minItems नियम के विरुद्ध खाली है, imdb.rating 10 की अधिकतम सीमा से अधिक है और गलत प्रकार है, और tomatoes.viewer.rating अनुमत अधिकतम 5 से अधिक है। MongoDB विस्तृत वैलिडेशन त्रुटि के साथ इन्सर्ट को अस्वीकार करता है।

वैलिडेशन लेवल्स और एक्शंस की व्याख्या

MongoDB आपको यह नियंत्रित करने का सूक्ष्म स्तर देता है कि स्कीमा वैलिडेशन कैसे और कब लागू हो। वैलिडेशन नियम परिभाषित करते समय, दो विकल्प आपके डेटाबेस के व्यवहार को प्रभावित करते हैं:

• validationLevel: नियम कब लागू होना चाहिए
• validationAction: जब कोई दस्तावेज़ नियम से मेल नहीं खाता, तब क्या होता है

validationLevel

यह विकल्प नियंत्रित करता है कि कौन-से ऑपरेशंस स्कीमा वैलिडेशन के अधीन हैं।

• strict: सभी इंसर्ट्स और अपडेट्स स्कीमा के अनुरूप होने चाहिए। यह डिफ़ॉल्ट और सबसे सुरक्षित मोड है।
• moderate: केवल डाले या अपडेट किए जा रहे दस्तावेज़ों का वैलिडेशन होता है। मौजूदा दस्तावेज़, भले ही अमान्य हों, अपरिवर्तित रहते हैं।

कब उपयोग करें:

• strict का उपयोग नए कलेक्शंस के लिए करें, जहाँ आप शुरू से ही स्कीमा को पूरी तरह लागू करना चाहते हैं।
• moderate का उपयोग तब करें जब आप उन कलेक्शंस पर वैलिडेशन लागू कर रहे हों जिनमें पहले से लेगेसी या असंरचित डेटा हो।

validationAction

यह विकल्प नियंत्रित करता है कि जब कोई दस्तावेज़ वैलिडेशन नियमों का उल्लंघन करता है, तो MongoDB कैसे प्रतिक्रिया देता है।

• error: राइट ऑपरेशन अस्वीकार कर दिया जाता है और वैलिडेशन त्रुटि लौटती है।
• warn: राइट स्वीकार कर लिया जाता है, लेकिन सर्वर के अंदरूनी लॉग में चेतावनी दर्ज होती है।

महत्वपूर्ण: MongoDB Atlas पर, warn से आने वाली चेतावनियाँ उपयोगकर्ताओं को दिखाई नहीं देतीं—आप उन्हें UI या मानक लॉग्स में नहीं देखेंगे।

कब उपयोग करें:

• warn का उपयोग विकास में या क्रमिक रोलआउट के दौरान करें ताकि राइट्स को रोके बिना उल्लंघनों की निगरानी हो सके।
• जब आप आश्वस्त हों कि आपका एप्लिकेशन मान्य दस्तावेज़ लिख रहा है और आप स्कीमा को सख्ती से लागू करना चाहते हैं, तो error पर स्विच करें।

उदाहरण: Warn से Error पर स्विच करना

मान लीजिए आपने इससे शुरुआत की:

db.runCommand({
  collMod: "validated_full",
  validationAction: "warn",
  validationLevel: "moderate"
});संचालित द्वारा

अपने एप्लिकेशन के व्यवहार को देखने के बाद, आप सख्त प्रवर्तन पर स्विच कर सकते हैं:

db.runCommand({
  collMod: "validated_full",
  validationAction: "error",
  validationLevel: "strict"
});संचालित द्वारा

चित्र 6. validated_full कलेक्शन के वैलिडेशन व्यवहार को बदलने के लिए दो collMod कमांड्स का उपयोग किया गया है। पहला validationAction को "warn" और validationLevel को "moderate" पर सेट करता है, जिससे अवैध दस्तावेज़ इन्सर्ट हो जाते हैं जबकि अंदरूनी चेतावनियाँ लॉग होती हैं। दूसरा कमांड validationAction को "error" और validationLevel को "strict" पर सेट कर सख्त प्रवर्तन सक्षम करता है, यह सुनिश्चित करते हुए कि सभी इंसर्ट्स और अपडेट्स को परिभाषित स्कीमा का पूरी तरह पालन करना होगा।

अब कोई भी अमान्य इंसर्ट या अपडेट एक त्रुटि संदेश के साथ ब्लॉक हो जाएगा।

सामान्य गलतियाँ और डीबगिंग टिप्स

स्कीमा वैलिडेशन के साथ काम करते समय, छोटी-छोटी गलतियाँ भ्रमित करने वाली त्रुटियों—या इससे भी बुरा, दस्तावेज़ों का चुपचाप आपके नियमों को बायपास कर जाना—का कारण बन सकती हैं। यहाँ कुछ सामान्य समस्याएँ और उनसे बचने के तरीके दिए गए हैं:

गलत bsonType मान

$jsonSchema का उपयोग करते समय सबसे आम गलतियों में से एक JSON प्रकारों को MongoDB के “bsonType” से भ्रमित करना है। जहाँ "string" और "array" सीधे-सीधे हैं, वहीं संख्या और बूलियन जैसे अन्य प्रकार पेचीदा हो सकते हैं।

उदाहरण के लिए:

• पूर्णांकों के लिए "int" या "long" का उपयोग करें।
• फ्लोटिंग पॉइंट संख्याओं के लिए "double" का उपयोग करें।
• true/false मानों के लिए "bool" ("boolean" नहीं) का उपयोग करें।
• सबडॉक्यूमेंट्स के लिए "object" का उपयोग करें ("dict" या "map" नहीं)।
• सूचियों के लिए "array" का उपयोग करें।

यदि आप सुनिश्चित नहीं हैं कि कोई फ़ील्ड किस प्रकार में स्टोर है, तो आप Mongo shell में typeof का उपयोग करके दस्तावेज़ का निरीक्षण कर सकते हैं या MongoDB Compass में डेटा की समीक्षा कर सकते हैं।

पार्शियल अपडेट्स में आवश्यक फ़ील्ड्स का गायब होना

जब आप $set का उपयोग करते हैं, तो वैलिडेशन केवल संशोधित फ़ील्ड्स की जाँच करता है। यदि आप पूर्ण स्कीमा जाँच की अपेक्षा कर रहे हैं, तो सुनिश्चित करें कि आप पूर्ण दस्तावेज़ प्रतिस्थापन कर रहे हैं या validationLevel: "strict" के साथ एप्लिकेशन लॉजिक से पूर्ण संरचना लागू कर रहे हैं।

खाली एरेज़ गलती से पास हो जाना

यदि आप minItems निर्दिष्ट करना भूल जाते हैं, तो खाली एरे पास हो जाएगी:

	genres: {
	  bsonType: "array",
	  items: { bsonType: "string" }
	}
	// Accepts empty arrays by defaultसंचालित द्वारा

कम से कम एक मान सुनिश्चित करने के लिए minItems: 1 का उपयोग करें।

warn मोड में त्रुटि न दिखना

जैसा कि पहले बताया गया, validationAction: "warn" राइट्स को ब्लॉक नहीं करता या MongoDB Atlas में त्रुटियाँ नहीं दिखाता। यह केवल अंदरूनी लॉग करता है, इसलिए वैलिडेशन “काम न करने” जैसा लग सकता है।

विकास या परीक्षण वातावरण में मुद्दों को जल्दी पकड़ने के लिए "error" मोड का उपयोग करें।

यदि पैरेंट ऑब्जेक्ट गायब हो तो नेस्टेड फ़ील्ड पथों की जाँच नहीं होती

यदि imdb.rating आवश्यक है, लेकिन imdb पूरी तरह गायब है, तो MongoDB rating की जाँच नहीं करेगा।

नेस्टेड फ़ील्ड्स पर वैलिडेशन लागू करने के लिए, सुनिश्चित करें कि उनका पैरेंट ऑब्जेक्ट या तो आवश्यक है या उसका bsonType: "object" है।

ऐसे दस्तावेज़ों को क्वेरी या अपडेट करना जो स्कीमा से मेल नहीं खाते

किसी मौजूदा कलेक्शन पर वैलिडेशन लागू करने के बाद, उन दस्तावेज़ों की पहचान करना उपयोगी होता है जो नए स्कीमा के अनुरूप नहीं हैं। आप $nor या $not के साथ क्वेरी में $jsonSchema ऑपरेटर का उपयोग करके यह कर सकते हैं।

उदाहरण: movies कलेक्शन में अमान्य दस्तावेज़ खोजें

मान लीजिए आपके स्कीमा में "string" प्रकार का title आवश्यक है। जो दस्तावेज़ मेल नहीं खाते उन्हें खोजने के लिए आप यह चला सकते हैं:

db.movies.find({
  $nor: [
    { $jsonSchema: {
        bsonType: "object",
        required: ["title"],
        properties: {
          title: { bsonType: "string" }
        }
      }
    }
  ]
});संचालित द्वारा

यह उन दस्तावेज़ों को लौटाएगा जिनमें title अनुपस्थित है या जिनका title गलत प्रकार का है।

चित्र 7. $nor को $jsonSchema के साथ उपयोग कर यह क्वेरी movies कलेक्शन में उन दस्तावेज़ों को खोजती है जिनमें string प्रकार का title फ़ील्ड नहीं है। परिणाम _id: 683ce0050bd195c35e417534 वाला दस्तावेज़ दिखाता है जिसमें केवल year फ़ील्ड है, जो यह पुष्टि करता है कि यह title आवश्यक होने वाले स्कीमा का उल्लंघन करता है। सख़्त वैलिडेशन नियम लागू करने से पहले अमान्य दस्तावेज़ों की पहचान करने के लिए यह तकनीक उपयोगी है।

आप इस तरीके का उपयोग इन कार्यों के लिए भी कर सकते हैं:

• "warn" से "error" पर स्विच करने से पहले लेगेसी दस्तावेज़ों का ऑडिट करना।
• अमान्य दस्तावेज़ों को प्रोग्रामेटिक तरीके से साफ़ या ठीक करना।
• स्कीमा अनुपालन पर रिपोर्ट तैयार करना।

समापन: लचीलेपन के साथ साफ़ डेटा

MongoDB का स्कीमा-लेस डिज़ाइन इसकी सबसे बड़ी ताकतों में से एक है, लेकिन इसका मतलब यह नहीं कि आप अपना डेटा बिना जाँचे छोड़ दें। $jsonSchema के साथ, आप शक्तिशाली वैलिडेशन नियम परिभाषित कर सकते हैं जो संरचना लागू करते हैं और साथ ही MongoDB के लचीलेपन का लाभ उठाते हैं।

इस लेख के दौरान, आपने सीखा कि कैसे:

• वैलिडेशन नियमों के साथ कलेक्शंस बनाएँ।
• नई और मौजूदा कलेक्शंस पर बाधाएँ लागू करें।
• ऑब्जेक्ट्स और एरेज़ के लिए नेस्टेड वैलिडेशन का उपयोग करें।
• वैलिडेशन मोड्स और एक्शंस कॉन्फ़िगर करें।
• अपने स्कीमा को आत्मविश्वास के साथ डीबग और परिष्कृत करें।

चाहे आप एक नया ऐप बना रहे हों या किसी लेगेसी सिस्टम में संरचना जोड़ रहे हों, स्कीमा वैलिडेशन आपको अपना डेटा सुरक्षित रखने के उपकरण देता है—विकास को धीमा किए बिना।

अगले कदम और संसाधन

और गहराई में जाना चाहते हैं? ये संसाधन देखें:

• MongoDB स्कीमा वैलिडेशन दस्तावेज़ 
• MongoDB JSON Schema दस्तावेज़
• MongoDB Atlas पर सैंपल डेटा

इंटरव्यू की तैयारी कर रहे हैं? ये शीर्ष MongoDB प्रश्न आपके स्कीमा वैलिडेशन जैसे विषयों की समझ को परखेंगे। अपने कौशल को वैलिडेट करना चाहते हैं? यह सर्टिफ़िकेशन गाइड MongoDB में प्रमाणित होने के लिए आपको जानने के लिए आवश्यक हर चीज़ बताता है।

ध्यान रखें, छोटे से शुरू करें, "warn" के साथ परीक्षण करें, और जब आप आश्वस्त हों तो "error" पर जाएँ—आपका भविष्य का स्व (और आपका डेटा) आपको धन्यवाद देगा।