MongoDB इंडेक्सिंग के सर्वोत्तम तरीके: परफॉर्मेंस टिप्स और ट्रिक्स

किसी भी डेटाबेस में, MongoDB सहित, इंडेक्स विकास प्रक्रिया का एक अहम हिस्सा होते हैं। इनके बिना, जैसे-जैसे आपका डेटाबेस आकार में बढ़ता है, वैसे-वैसे उसकी परफॉर्मेंस घटती जाएगी। सही इंडेक्स होने पर, डेटा बढ़ने के साथ भी एक्सेस करने की परफॉर्मेंस बेहतर बनी रहती है।

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

MongoDB इंडेक्स कहाँ और क्यों महत्वपूर्ण हैं?

इंडेक्स की बात करें तो हम परफॉर्मेंस की बात कर रहे होते हैं। इंडेक्स यह अंतर पैदा करते हैं कि हमें अपने क्वेरी से मेल खाने के लिए कलेक्शन के हर दस्तावेज़ को देखना पड़ेगा, या हम सीधे अधिक विशिष्ट दस्तावेज़ों के समूह तक पहुँच पाएँगे। यदि हमारा कलेक्शन छोटा है और स्कैन करने के लिए अधिक दस्तावेज़ नहीं हैं, तो दोनों ही स्थितियों में परफॉर्मेंस ठीक रहेगी। लेकिन यदि किसी कलेक्शन में 100,000 दस्तावेज़ हैं और उनमें से 100 हमारे क्वेरी से मेल खाते हैं, तो बिना इंडेक्स के उन 100,000 में से वही 100 खोजने में समय लगेगा।

MongoDB में इंडेक्स के कई प्रकार होते हैं:

• सिंगल फील्ड: दस्तावेज़ के किसी एक विशेष फील्ड पर इंडेक्स। डिफ़ॉल्ट _id फील्ड इंडेक्स को सिंगल फील्ड इंडेक्स माना जा सकता है।
• कंपाउंड: दस्तावेज़ के एक से अधिक फील्ड पर आधारित इंडेक्स, जहाँ क्वेरी और इंडेक्स में फील्ड के क्रम का महत्व होता है।
• मल्टीकी: एरे फील्ड पर उपयोग होने वाला इंडेक्स।
• वाइल्डकार्ड: ऐसा इंडेक्स जो उन फील्ड का समर्थन करता है जिनके नाम दस्तावेज़ों के बीच थोड़े अलग हो सकते हैं। यह इंडेक्स अन्य इंडेक्स जितना तेज़ प्रदर्शन नहीं करेगा।
• जियोस्पैशियल: अक्षांश और देशांतर के समन्वय डेटा का उपयोग करने वाली स्थान-आधारित क्वेरियों के प्रदर्शन को बेहतर करने के लिए इंडेक्स।
• हैश्ड: ऐसा इंडेक्स जो शार्ड कीज़ के साथ सबसे बेहतर काम करता है।

विभिन्न इंडेक्स प्रकारों के बारे में अधिक जानकारी के लिए MongoDB दस्तावेज़ देखें।

अक्सर आप सिंगल फील्ड, कंपाउंड या मल्टीकी इंडेक्स का उपयोग करेंगे, लेकिन अंततः यह आपके एप्लिकेशन, क्वेरियों और डेटा के प्रकार पर निर्भर करता है।

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

केवल find और findOne ही ऐसे रिट्रीवल ऑपरेटर नहीं हैं जो इंडेक्स से लाभ उठाते हैं। यदि आप अपने एग्रीगेशन पाइपलाइन के पहले चरण के रूप में $match का उपयोग करते हैं, तो इंडेक्स चीज़ों को नाटकीय रूप से तेज़ कर देगा।

सफलता के लिए MongoDB इंडेक्सिंग टिप्स और ट्रिक्स

MongoDB में बिना सोचे-समझे इंडेक्स बनाना, इंडेक्स न बनाने जितना ही अकार्यकुशल हो सकता है। इसके बजाय, कुछ बातों पर विचार करें जो आपको अधिक कुशल एप्लिकेशन बनाने में मदद करेंगी।

कंपाउंड इंडेक्स के लिए Equality, Sort, Range (ESR)

कंपाउंड इंडेक्स बनाते समय मूल नियम यह है कि आप तय करें कि अपनी क्वेरी में प्रत्येक फील्ड का उपयोग कैसे करेंगे और यह सुनिश्चित करें कि वह ESR सर्वोत्तम प्रथा का पालन करे।

ESR का अर्थ क्या है? आइए इसे समझें:

• Equality: वे फील्ड जिनका सटीक मिलान होगा, ढीला नहीं। उदाहरण के लिए, किसी के बिल्कुल सही नाम पर मैच करना equality स्टेज होगा।
• Sort: वे फील्ड जिनका उपयोग आप आरोही या अवरोही क्रम में सॉर्टिंग के लिए करेंगे।
• Range: वे फील्ड जिन पर मैच सटीक नहीं होगा। उदाहरण के लिए, $lt या $gt ऑपरेटर का उपयोग एक रेंज के भीतर दस्तावेज़ों से मैच करेगा, न कि किसी विशिष्ट मान से।

इसे बेहतर समझने के लिए निम्नलिखित क्वेरी देखें:

db.employee.find(
	{
		"department": "Developer Relations",
		"salary": {
			"$lt": 80000
		}
	}
).sort(
	{ 
		"name": 1 
	}
);

ऊपर दी गई क्वेरी विभाग पर equality मैच करती है, वेतन पर रेंज मैच करती है, और नाम के अनुसार परिणामों को सॉर्ट करती है।

ESR नियमों का पालन करते हुए, इंडेक्स कुछ इस तरह दिखेगा:

db.employee.createIndex({
	"department": 1,
	"name": 1,
	"salary": 1
});

हम इन-मेमोरी सॉर्ट से बचने और तेज़ क्वेरी निष्पादन के लिए सर्च स्पेस को सीमित करने हेतु ESR नियमों का पालन करना चाहते हैं।

कवर्ड क्वेरियाँ

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

यहाँ कुछ शर्तें हैं, जिन पर आपकी एप्लिकेशन में कवर्ड क्वेरियाँ संभव हो भी सकती हैं या नहीं भी:

• मैच मानदंड और सॉर्ट बिल्कुल उसी प्रकार होने चाहिए जिस प्रकार आपका इंडेक्स बनाया गया है।
• आपके परिणाम सेट में जिन फील्ड की माँग की गई है, वे भी आपके इंडेक्स से मेल खाने चाहिए।
• शार्डिंग के समय, शार्ड की आपके इंडेक्स का हिस्सा होना आवश्यक है।

तो इसका अर्थ क्या हुआ?

उदाहरण के लिए निम्न इंडेक्स पर ध्यान दें:

db.department.createIndex({
	"country": 1,
	"salary": 1
});

ऊपर के उदाहरण में, हम अपने दस्तावेज़ों को country और salary फील्ड पर इंडेक्स करना चाहते हैं। फिर, हम निम्नलिखित क्वेरी चला सकते हैं:

db.department.find(
	{
		"country": "US"
	},
	{
		"country": 1,
		"salary": 1
	}
);

ऊपर दी गई क्वेरी, जो एक प्रोजेक्शन शामिल करती है, हमारा इंडेक्स तो उपयोग करेगी, लेकिन यह कवर्ड क्वेरी नहीं होगी। MongoDB में डिफ़ॉल्ट रूप से _id फील्ड लौटाया जाता है और इस उदाहरण में, _id फील्ड हमारे इंडेक्स में जोड़ा नहीं गया था। अतः हम या तो अपना इंडेक्स बदल सकते हैं, या क्वेरी बदल सकते हैं। क्वेरी बदलने के उदाहरण में, हम ऐसा कर सकते हैं:

db.department.find(
	{
		"country": "US"
	},
	{
		"country": 1,
		"salary": 1,
		"_id": 0
	}
);

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

आप यह जाँच सकते हैं कि कवर्ड क्वेरी उपयोग हो रही है या नहीं, इसके लिए नीचे दिए गए explain ऑपरेटर में executionStats आर्ग्युमेंट का उपयोग करें। totalDocsExamined परिणाम बताएगा कि क्या उपयोग हो रहा है। यदि मान शून्य है, तो आप कवर्ड क्वेरी का उपयोग कर रहे हैं।

अनावश्यक इंडेक्स को कम करना या हटाना

सर्वर संसाधनों के संदर्भ में इंडेक्स मुफ्त नहीं होते। हर इंडेक्स को सर्वर द्वारा मेंटेन करना पड़ता है और इस मेंटेनेंस में CPU, RAM और डिस्क का उपयोग होता है। जैसे-जैसे आप अधिक इंडेक्स बनाएँगे, ओवरहेड बढ़ेगा, जिससे उच्च लागत या कम-प्रोविज़न्ड सर्वर की स्थिति में परफॉर्मेंस घट सकती है। यह घटती परफॉर्मेंस केवल रीड ही नहीं, बल्कि राइट्स और डिलीट्स तक भी फैल सकती है, क्योंकि MongoDB अधिक संसाधन उपभोग कर रहा होता है।

अच्छा विचार यह है कि केवल हाई-फ़्रीक्वेंसी क्वेरियों के लिए ही इंडेक्स बनाएँ। जो क्वेरी महीने में केवल एक बार चलती है, क्या उसे सचमुच इंडेक्स चाहिए? शायद नहीं। जो क्वेरी हर 10 सेकंड चलती है, क्या उसे इंडेक्स चाहिए? निश्चित रूप से!

इंडेक्सिंग के कुछ और सर्वोत्तम तरीके MongoDB ब्लॉग पर जानें।

क्या आपका MongoDB इंडेक्स काम कर रहा है?

सिर्फ इसलिए कि आपने MongoDB में एक इंडेक्स बना दिया है, इसका अर्थ नहीं कि आपकी क्वेरी वास्तव में उसका उपयोग कर रही है। MongoDB में, हम किसी भी विशेष क्वेरी के लिए यह जाँच सकते हैं कि कौन सा इंडेक्स उपयोग हो रहा है।

उदाहरण के लिए यह इंडेक्स लें:

db.people.createIndex({
	"name": 1,
	"is_active": 1
});

ऊपर के उदाहरण में, हम name और is_active फील्ड पर इंडेक्स बना रहे हैं। अब, हम निम्नलिखित क्वेरी चलाना चाहते हैं:

db.people.find({
	"is_active": true
});

ऊपर दी गई क्वेरी वैध इंडेक्स हो या न हो, दोनों स्थितियों में चलेगी, और यदि डेटा सेट छोटा है तो वैसे भी तेज़ चलेगी। हालाँकि, यदि हम देखना चाहें कि क्या यह हमारे इंडेक्स का उपयोग कर रही है, तो हम क्वेरी में यह बदलाव कर सकते हैं:

db.people.find({
	"is_active": true
}).explain();

इस बार हम क्वेरी का एक्ज़ीक्यूशन प्लान जानने के लिए explain मेथड का उपयोग कर रहे हैं। एक्ज़ीक्यूशन प्लान में हम यह देख सकते हैं:

winningPlan: {
	isCached: false,
	stage: 'COLLSCAN',
	filter: { is_active: { '$eq': true } },
	direction: 'forward'
}

इस विशेष क्वेरी के लिए, MongoDB ने "COLLSCAN" का उपयोग किया, जिसका मतलब है कि हमारे इंडेक्स का उपयोग नहीं हुआ, भले ही क्वेरी में हमारे फील्ड में से एक शामिल था। यदि हम अपनी क्वेरी को कुछ इस प्रकार बदल दें:

db.people.find({
	"name": "Nic Raboy",
	"is_active": true
}).explain();

हमारे explain का परिणाम बदल गया है:

winningPlan: {
	isCached: false,
	stage: 'FETCH',
	inputStage: {
		stage: 'IXSCAN',
		keyPattern: { name: 1, is_active: 1 },
		indexName: 'name_1_is_active_1',
		isMultiKey: false,
		multiKeyPaths: { name: [], is_active: [] },
		isUnique: false,
		isSparse: false,
		isPartial: false,
		indexVersion: 2,
		direction: 'forward',
		indexBounds: {
			name: [ '["Nic Raboy", "Nic Raboy"]' ],
			is_active: [ '[true, true]' ]
		}
	}
},

इस बार, एक्ज़ीक्यूशन प्लान में "IXSCAN" दिखा और उपयोग किए गए इंडेक्स का नाम भी बताया, जो इस केस में name_1_is_active_1 है। इंडेक्स बनाते समय यह नाम अपने-आप निर्धारित हुआ था।

update ऑपरेशन के लिए प्रक्रिया समान है, बस अंतर यह है कि explain फ़ंक्शन कहाँ लगाया जाता है।

एक update ऑपरेशन कुछ इस प्रकार दिख सकता है:

db.people.explain().update(
    {
        “name”: “Nic Raboy”,
        “Is_active”: true
    },
    {
        “$set”: { “is_active”: false }
    }
);

ध्यान दें कि ऊपर के उदाहरण में, explain update फ़ंक्शन से पहले आता है।

यदि आप अपने अपडेट ऑपरेशन में अपेक्षित इंडेक्स का उपयोग कर रहे हैं, तो आपको "IXSCAN" मान के साथ इंडेक्स नाम दिखाई देगा। अपडेट ऑपरेशंस और उनमें इंडेक्स के उपयोग पर अधिक जानकारी पाएँ।

अपने क्वेरी के एक्ज़ीक्यूशन प्लान के विवरण जानने का एक वैकल्पिक तरीका है डेटाबेस पर runCommand का उपयोग करना। दिखने में यह उतना सुगठित नहीं है, लेकिन काफ़ी शक्तिशाली है और कुछ इस तरह दिखता है:

db.runCommand({
    "explain": {
        "update": "people",
        "updates": [
            {
                "q": { 
                    "name": "Nic Raboy",
                    "is_active": true
                },
                "u": {
                    "$set": { "is_active": false }
                }
            }
        ]
    },
    "verbosity": "allPlansExecution"
});

ऊपर दिया गया तरीका explain फ़ंक्शन के साथ वाले अपडेट ऑपरेशन जैसा ही काम करेगा।

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

निष्कर्ष

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

कुछ बातों को पुनः दोहराएँ:

• जहाँ संभव हो, equality, sort, range (ESR) नियम का पालन करें।
• यदि संभव हो, तो कवर्ड क्वेरी करने का प्रयास करें।
• बिना सोचे-समझे इंडेक्स न बनाएँ; इसके बजाय यह समझें कि कौन सी क्वेरियाँ सबसे अधिक उपयोग होंगी और उनमें कितना डेटा फ़ेच होता है।
• अपने इंडेक्स और उनकी परफॉर्मेंस के परीक्षण के लिए explain ऑपरेटर का सहारा लें।

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

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