MongoDB Academy · पाठ

एलिमेंट ऑपरेटर और प्रकार जाँच

शिक्षार्थी वैकल्पिक या मिश्रित-प्रकार वाले डेटा को संभालने के लिए $exists और $type से फ़ील्ड की मौजूदगी या प्रकार पर क्वेरी करेंगे।

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

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

लचीली स्कीमा में वैकल्पिक फ़ील्ड

MongoDB की लचीली स्कीमा का अर्थ है कि किसी collection के कुछ दस्तावेज़ों में ऐसे फ़ील्ड हो सकते हैं जो अन्य दस्तावेज़ों में नहीं हैं। किसी उपयोगकर्ता के दस्तावेज़ में वैकल्पिक phoneNumber फ़ील्ड हो सकता है—कुछ उपयोगकर्ताओं ने इसे दिया है, जबकि अन्य ने नहीं दिया। एसक्यूएल में, आप हर पंक्ति में NULL मान के माध्यम से इसे संभालते। MongoDB में, कुछ दस्तावेज़ों में यह फ़ील्ड बस मौजूद नहीं होता।

क्वेरी के लिए इस अंतर के महत्वपूर्ण परिणाम हैं। MongoDB के तत्व ऑपरेटर—मुख्य रूप से $exists और $type—आपको फ़ील्ड के मान के बजाय उसकी मौजूदगी या प्रकार के आधार पर क्वेरी करने देते हैं।

$exists: फ़ील्ड की मौजूदगी जाँचना

$exists: true उन दस्तावेज़ों से मेल खाता है जिनमें निर्दिष्ट फ़ील्ड मौजूद है (उसके मान की परवाह किए बिना, भले ही मान null हो)। $exists: false उन दस्तावेज़ों से मेल खाता है जिनमें फ़ील्ड पूरी तरह अनुपस्थित है।

यह अंतर सूक्ष्म लेकिन महत्वपूर्ण है: { phone: null } वाला दस्तावेज़ { phone: { $exists: true } } से मेल खाता है, क्योंकि फ़ील्ड मौजूद है—बस उसका मान null है। केवल ऐसा दस्तावेज़ जिसमें phone फ़ील्ड बिल्कुल न हो, { phone: { $exists: false } } से मेल खाता है।

// Find users who have provided a phone number (field exists)
db.users.find({ phone: { $exists: true } });

// Find users who never provided a phone number (field absent)
db.users.find({ phone: { $exists: false } });

// Key distinction:
// { phone: null }    => $exists: true (field exists, value is null)
// { name: 'Alice' }  => $exists: false (no phone field at all)

// Combined: field exists AND is not null
db.users.find({ phone: { $exists: true, $ne: null } });

null बनाम अनुपस्थित फ़ील्ड की क्वेरी

null के साथ MongoDB के समानता फ़िल्टर का दोहरा व्यवहार होता है, जो अक्सर शुरुआती शिक्षार्थियों को चौंका देता है: { phone: null } उन दस्तावेज़ों से मेल खाता है जिनमें phone स्पष्ट रूप से null है और उन दस्तावेज़ों से भी जिनमें phone बिल्कुल मौजूद नहीं है। ऐसा इसलिए है क्योंकि समानता की तुलना में MongoDB अनुपस्थित फ़ील्ड को निहित रूप से null मानता है।

यदि आप 'फ़ील्ड null है' और 'फ़ील्ड अनुपस्थित है' के बीच अंतर करना चाहते हैं, तो $exists को $eq: null के साथ मिलाएँ। अधिकांश व्यावहारिक मामलों में, दोनों स्थितियों का अर्थ 'फ़ोन नंबर नहीं दिया गया' होता है और आप उन्हें एक ही तरह से संभाल सकते हैं।

// Matches BOTH null and missing field:
db.users.find({ phone: null });
// Returns: { name: 'Alice', phone: null }
//      AND: { name: 'Bob' }  (no phone field)

// Only where field is explicitly null:
db.users.find({ phone: { $eq: null, $exists: true } });
// Returns: { name: 'Alice', phone: null }
// NOT: { name: 'Bob' } (missing field)

// Only where field is missing:
db.users.find({ phone: { $exists: false } });

$type: BSON प्रकार के आधार पर क्वेरी करना

MongoDB की स्कीमा लचीली होती है, जिसका अर्थ है कि price जैसा फ़ील्ड अधिकांश दस्तावेज़ों में Number हो सकता है, लेकिन पुराने रिकॉर्ड में गलती से String के रूप में संग्रहीत हो सकता है। $type ऑपरेटर आपको किसी फ़ील्ड के मान के BSON प्रकार के आधार पर दस्तावेज़ों को फ़िल्टर करने देता है।

आप प्रकारों को नाम से (जैसे, 'string', 'int', 'date') या BSON प्रकार संख्या से (जैसे, String के लिए 2, Int32 के लिए 16) निर्दिष्ट कर सकते हैं। प्रकार के नाम अधिक पठनीय और वरीयता योग्य होते हैं।

// Find documents where price is a string (data quality issue)
db.products.find({ price: { $type: 'string' } });
// These need to be fixed - price should be a number

// Find documents where price is a number (any numeric type)
db.products.find({ price: { $type: ['double', 'int', 'long', 'decimal'] } });
// $type accepts an array - matches any of the listed types

// Check for boolean
db.settings.find({ enabled: { $type: 'bool' } });

सामान्य BSON प्रकार नाम

$type क्वेरी के लिए सबसे अधिक उपयोग किए जाने वाले BSON प्रकार नाम ये हैं:

'double' — 64-बिट फ़्लोटिंग-पॉइंट संख्या (JS की डिफ़ॉल्ट संख्या)
'string' — UTF-8 स्ट्रिंग
'object' — एम्बेड किया गया दस्तावेज़ (उप-ऑब्जेक्ट)
'array' — सारणी
'binData' — बाइनरी डेटा
'objectId' — ObjectId
'bool' — बूलियन
'date' — दिनांक
'null' — null मान
'int' — 32-बिट पूर्णांक
'long' — 64-बिट पूर्णांक
'decimal' — Decimal128

// Real-world use: find documents where tags is an array
db.products.find({ tags: { $type: 'array' } });

// Find docs where createdAt is a date (not a string)
db.events.find({ createdAt: { $type: 'date' } });

// Audit: find any document where _id is not an ObjectId
db.users.find({ _id: { $not: { $type: 'objectId' } } });
// These might be docs with custom string _ids

'number' उपनाम

एक उपयोगी शॉर्टकट 'number' प्रकार का उपनाम है, जो किसी भी संख्यात्मक BSON प्रकार से मेल खाता है: double, int, long और decimal। यह सभी चार संख्यात्मक प्रकार नामों की सारणी लिखने के बराबर है, लेकिन कहीं अधिक साफ़ है।

जब आप ऐसे सभी दस्तावेज़ ढूँढना चाहते हैं जिनमें कोई फ़ील्ड किसी भी प्रकार की संख्या हो, चाहे उसकी सटीकता कुछ भी हो, तब 'number' का उपयोग करें। यह डेटा गुणवत्ता जाँच के लिए विशेष रूप से उपयोगी है, जब आप उन फ़ील्ड की पहचान करना चाहते हैं जो संख्यात्मक होने चाहिए थे, लेकिन गलती से स्ट्रिंग के रूप में संग्रहीत हो गए।

// 'number' alias matches double, int, long, decimal
db.products.find({ price: { $type: 'number' } });
// Same as: { price: { $type: ['double', 'int', 'long', 'decimal'] } }

// Data quality check: find price fields that are strings
// These should be numbers:
db.products.find({ price: { $type: 'string' } });

// Fix those docs:
db.products.find({ price: { $type: 'string' } }).forEach(doc => {
  db.products.updateOne(
    { _id: doc._id },
    { $set: { price: parseFloat(doc.price) } }
  );
});

स्कीमा माइग्रेशन में $exists का उपयोग

MongoDB में स्कीमा माइग्रेशन में अक्सर मौजूदा दस्तावेज़ों में नए आवश्यक फ़ील्ड जोड़ना शामिल होता है। $exists आपको ऐसे दस्तावेज़ ढूँढने में मदद करता है जिन्हें अभी अपडेट करना बाकी है—या जिनका माइग्रेशन पहले ही हो चुका है।

एक सामान्य माइग्रेशन प्रवाह यह है: पहले { newField: { $exists: false } } का उपयोग करके सभी पुराने दस्तावेज़ ढूँढें, फिर डिफ़ॉल्ट मान के साथ नया फ़ील्ड जोड़ें। यह गिनकर प्रगति जाँचें कि कितने दस्तावेज़ों में अभी भी $exists: false है। यह क्रमिक माइग्रेशन तरीका बिना डाउनटाइम के काम करता है, क्योंकि MongoDB की लचीली स्कीमा पुराने और नए दस्तावेज़-रूपों को कुछ समय तक साथ रहने देती है।

// Migration: add 'timezone' field with default value to legacy users
async function migrateTimezone() {
  const batchSize = 1000;
  let processed = 0;

  while (true) {
    const result = await db.collection('users').updateMany(
      { timezone: { $exists: false } },  // Legacy docs without field
      { $set: { timezone: 'UTC' } },     // Add default
      { limit: batchSize }               // Process in batches
    );
    processed += result.modifiedCount;
    if (result.modifiedCount === 0) break;
  }
  console.log('Migrated:', processed);
}

$exists और $type को संयोजित करना

आप एक ही क्वेरी में $exists और $type को मिलाकर ऐसे दस्तावेज़ ढूँढ सकते हैं जिनमें कोई फ़ील्ड मौजूद हो और उसका प्रकार विशिष्ट हो। यह डेटा गुणवत्ता ऑडिट के लिए उपयोगी है, जब आप उन दस्तावेज़ों की पहचान करना चाहते हैं जिनमें फ़ील्ड का प्रकार गलत है और उन दस्तावेज़ों से अलग करना चाहते हैं जिनमें फ़ील्ड बस अनुपस्थित है।

उदाहरण के लिए, किसी ऐसी collection में जहाँ age संख्या होना चाहिए, आप अलग-अलग इनकी गिनती करना चाह सकते हैं: (1) ऐसे दस्तावेज़ जिनमें age फ़ील्ड पूरी तरह अनुपस्थित है, (2) ऐसे दस्तावेज़ जिनमें age एक स्ट्रिंग है (डेटा प्रविष्टि की त्रुटि), और (3) ऐसे दस्तावेज़ जिनमें age एक मान्य संख्या है।

// Audit 'age' field data quality
const total = await db.collection('users').countDocuments({});

const missingAge = await db.collection('users')
  .countDocuments({ age: { $exists: false } });

const ageIsString = await db.collection('users')
  .countDocuments({ age: { $type: 'string' } });

const ageIsNumber = await db.collection('users')
  .countDocuments({ age: { $type: 'number' } });

console.log(`Total: ${total}, Missing: ${missingAge}, String: ${ageIsString}, Number: ${ageIsNumber}`);

$expr: फ़ील्डों के बीच तुलना

$expr ऑपरेटर आपको सामान्य find() फ़िल्टर के अंदर एग्रीगेशन अभिव्यक्तियों का उपयोग करने देता है। इससे अलग-अलग फ़ील्ड की तुलना संभव हो जाती है—जो मानक क्वेरी ऑपरेटरों के साथ संभव नहीं है।

उदाहरण के लिए: 'ऐसे ऑर्डर खोजें जिनमें छूट मूल कीमत के 50% से अधिक हो' के लिए discount की तुलना originalPrice के गणना किए गए अंश से करनी पड़ती है—एक ही दस्तावेज़ में मौजूद दो फ़ील्ड। $expr $gt, $multiply और $divide जैसे अभिव्यक्ति ऑपरेटरों का उपयोग करके इन संबंधों को संभव बनाता है।

// Find products where salePrice < originalPrice * 0.7 (>30% off)
db.products.find({
  $expr: {
    $lt: [
      '$salePrice',
      { $multiply: ['$originalPrice', 0.7] }
    ]
  }
});

// Find orders where quantity ordered > quantity in stock
db.orders.find({
  $expr: { $gt: ['$quantityOrdered', '$quantityInStock'] }
});

$exists क्वेरी के लिए इंडेक्सिंग

$exists का उपयोग करने वाली क्वेरीज़ में इंडेक्स का समर्थन मिश्रित होता है। किसी फ़ील्ड पर बना इंडेक्स { field: { $exists: false } } में सहायता नहीं करता—यदि फ़ील्ड मौजूद नहीं है, तो वह इंडेक्स में भी नहीं होती—इसलिए MongoDB को हर दस्तावेज़ स्कैन करना पड़ता है। हालांकि, { field: { $exists: true } } एक स्पार्स इंडेक्स का उपयोग कर सकता है: स्पार्स इंडेक्स केवल उन दस्तावेज़ों की प्रविष्टियाँ संग्रहीत करता है जिनमें इंडेक्स की गई फ़ील्ड मौजूद होती है, जिससे मौजूद दस्तावेज़ों को तेज़ी से खोजा जा सकता है।

जब आप अक्सर ऐसे दस्तावेज़ खोजते हों जिनमें कोई वैकल्पिक फ़ील्ड मौजूद है, तो स्पार्स इंडेक्स बनाने के लिए db.collection.createIndex({ field: 1 }, { sparse: true }) का उपयोग करें।

// Sparse index: only indexes docs where 'proSubscriptionId' exists
db.users.createIndex(
  { proSubscriptionId: 1 },
  { sparse: true }
);

// This query now uses the sparse index efficiently:
db.users.find({ proSubscriptionId: { $exists: true } });
// Only pro subscribers are in the index

// Regular (non-sparse) index would include null entries for all users
// Sparse index is smaller and faster for optional-field queries

डेटा गुणवत्ता ऑडिट कार्यप्रवाह

और का उपयोग करने वाला व्यावहारिक डेटा गुणवत्ता ऑडिट कार्यप्रवाह यह है: पहले अपनी collection में मौजूद सभी अलग-अलग फ़ील्ड पैटर्न पहचानें ताकि असंगतियों का पता चल सके, फिर दस्तावेज़ों को उनके फ़ील्ड प्रकारों के अनुसार वर्गीकृत करें, और अंत में डेटा को सामान्य रूप देने के लिए लक्षित updateMany कॉल लिखें।

MongoDB की एग्रीगेशन पाइपलाइन ऑडिट को आसान बनाती है: प्रत्येक प्रकार वाले दस्तावेज़ों की संख्या गिनने के लिए किसी फ़ील्ड पर द्वारा । इससे सुधार शुरू करने से पहले डेटा गुणवत्ता की समस्याओं की स्पष्ट तस्वीर मिलती है।

// Audit: how many docs have price as each type?
db.products.aggregate([
  {
    : {
      _id: { : '' },  // Group by BSON type of price
      count: { : 1 }
    }
  }
]);
// Results like:
// [{ _id: 'double', count: 4820 },
//  { _id: 'string', count: 3 },
//  { _id: 'missing', count: 12 }]
// Now you know exactly what to fix!

त्वरित जाँच

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

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

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

इस पाठ में आपने सीखा: फ़ील्ड की मौजूदगी या अनुपस्थिति जाँचने के लिए $exists क्वेरीज़—गायब फ़ील्ड और null फ़ील्ड अलग होते हैं और $exists: true को $ne: null के साथ मिलाकर इनमें अंतर किया जा सकता है; $type BSON प्रकार के नाम के आधार पर फ़िल्टर करता है (string, number, date, array आदि) और स्कीमा-लचीली collections में डेटा गुणवत्ता ऑडिट के लिए आवश्यक है; तथा स्पार्स इंडेक्स केवल उन दस्तावेज़ों को इंडेक्स करके वैकल्पिक फ़ील्ड पर $exists: true क्वेरीज़ का कुशलतापूर्वक समर्थन करते हैं जिनमें वह फ़ील्ड मौजूद होती है। आगे हम लचीली टेक्स्ट खोजों के लिए रेगेक्स क्वेरीज़ और पैटर्न मिलान का अध्ययन करेंगे।

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

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

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

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

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

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

क्या “एलिमेंट ऑपरेटर और प्रकार जाँच” पाठ निःशुल्क है?

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

“एलिमेंट ऑपरेटर और प्रकार जाँच” में मैं क्या सीखूँगा?

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

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

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

“एलिमेंट ऑपरेटर और प्रकार जाँच” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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