मोंगोडीबी कंपाउंड इंडेक्स - क्या सॉर्ट ऑर्डर मायने रखता है?

आप MongoDB सिंगल-फ़ील्ड इंडेक्स को एक सरणी के रूप में सोच सकते हैं, जिसमें पॉइंटर्स टू डॉक्यूमेंट लोकेशन हैं। उदाहरण के लिए, यदि आपके पास संग्रह है (ध्यान दें कि अनुक्रम जानबूझकर आउट-ऑफ-ऑर्डर है):

[collection]
1: {a:3, b:2}
2: {a:1, b:2}
3: {a:2, b:1}
4: {a:1, b:1}
5: {a:2, b:2}

एकल-फ़ील्ड अनुक्रमणिका

अब अगर आप करते हैं:

db.collection.createIndex({a:1})

सूचकांक लगभग ऐसा दिखता है:

[index a:1]
1: {a:1} --> 2, 4
2: {a:2} --> 3, 5
3: {a:3} --> 1

तीन महत्वपूर्ण बातों पर ध्यान दें:

• इसे a . द्वारा क्रमित किया जाता है आरोही
• प्रत्येक प्रविष्टि उस स्थान की ओर इशारा करती है जहां प्रासंगिक दस्तावेज़ रहते हैं
• इंडेक्स केवल a . के मानों को रिकॉर्ड करता है खेत। b अनुक्रमणिका में फ़ील्ड बिल्कुल भी मौजूद नहीं है

तो अगर आप कोई प्रश्न करते हैं जैसे:

db.collection.find().sort({a:1})

इसे केवल इतना करना है कि सूचकांक को ऊपर से नीचे तक ले जाना है, प्रविष्टियों द्वारा इंगित दस्तावेज़ को लाना और आउटपुट करना है। ध्यान दें कि आप इंडेक्स को नीचे से भी चला सकते हैं, जैसे:

db.collection.find().sort({a:-1})

और फर्क सिर्फ इतना है कि आप सूचकांक को उल्टा चलते हैं।

क्योंकि b इंडेक्स में बिल्कुल नहीं है, b . के बारे में कुछ भी पूछने पर आप इंडेक्स का उपयोग नहीं कर सकते हैं ।

यौगिक अनुक्रमणिका

कंपाउंड इंडेक्स में जैसे:

db.collection.createIndex({a:1, b:1})

इसका मतलब है कि आप a . के आधार पर छाँटना चाहते हैं पहले, फिर b . के आधार पर छाँटें . सूचकांक इस तरह दिखेगा:

[index a:1, b:1]
1: {a:1, b:1} --> 4
2: {a:1, b:2} --> 2
3: {a:2, b:1} --> 3
4: {a:2, b:2} --> 5
5: {a:3, b:2} --> 1

ध्यान दें कि:

• इंडेक्स को a . से क्रमबद्ध किया गया है
• प्रत्येक a . के भीतर आपके पास एक क्रमबद्ध b . है
• आपके पास पिछले एकल-फ़ील्ड उदाहरण में 5 अनुक्रमणिका प्रविष्टियाँ बनाम केवल तीन हैं

इस अनुक्रमणिका का उपयोग करके, आप एक प्रश्न कर सकते हैं जैसे:

db.collection.find({a:2}).sort({b:1})

यह आसानी से पता लगा सकता है कि a:2 . कहां है फिर इंडेक्स को आगे बढ़ाएं। उस अनुक्रमणिका को देखते हुए, आप ऐसा नहीं कर सकते :

db.collection.find().sort({b:1})
db.collection.find({b:1})

दोनों प्रश्नों में आप आसानी से b नहीं ढूंढ सकते हैं चूंकि यह पूरे सूचकांक में फैला हुआ है (अर्थात सन्निहित प्रविष्टियों में नहीं)। हालांकि आप कर सकते हैं करो:

db.collection.find({a:2}).sort({b:-1})

चूंकि आप अनिवार्य रूप से पा सकते हैं कि a:2 . कहां है हैं, और b . पर चलते हैं प्रविष्टियाँ पीछे की ओर।

संपादित करें :टिप्पणी में @marcospgp के प्रश्न का स्पष्टीकरण:

सूचकांक का उपयोग करने की संभावना {a:1, b:1} संतुष्ट करने के लिए find({a:2}).sort({b:-1}) वास्तव में समझ में आता है यदि आप इसे क्रमबद्ध तालिका के दृष्टिकोण से देखते हैं। उदाहरण के लिए, इंडेक्स {a:1, b:1} के रूप में सोचा जा सकता है:

a | b
--|--
1 | 1
1 | 2
2 | 1
2 | 2
2 | 3
3 | 1
3 | 2

ढूंढें({a:2}).सॉर्ट करें({b:1})

इंडेक्स {a:1, b:1} मतलब sort by a, then within each a, sort the b values . यदि आप find({a:2}).sort({b:1}) करते हैं तो , सूचकांक जानता है कि सभी a=2 हैं। a=2 . के इस ब्लॉक में , b आरोही क्रम में क्रमबद्ध किया जाएगा (सूचकांक युक्ति के अनुसार), ताकि क्वेरी find({a:2}).sort({b:1}) द्वारा संतुष्ट किया जा सकता है:

a | b
--|--
1 | 1
1 | 2
2 | 1 <-- walk this block forward to satisfy
2 | 2 <-- find({a:2}).sort({b:1})
2 | 3 <--
3 | 1
3 | 2

ढूंढें({a:2}).सॉर्ट करें({b:-1})

चूंकि सूचकांक को आगे या पीछे चलाया जा सकता है, इसी तरह की प्रक्रिया का पालन किया गया था, जिसके अंत में एक छोटा सा मोड़ था:

a | b
--|--
1 | 1
1 | 2
2 | 1  <-- walk this block backward to satisfy
2 | 2  <-- find({a:2}).sort({b:-1})
2 | 3  <--
3 | 1
3 | 2

तथ्य यह है कि सूचकांक को आगे या पीछे चलाया जा सकता है, यह महत्वपूर्ण बिंदु है जो क्वेरी को सक्षम करता है find({a:2}).sort({b:-1}) अनुक्रमणिका का उपयोग करने में सक्षम होने के लिए {a:1, b:1} ।

क्वेरी प्लानर समझाएं

db.collection.explain().find(....) का उपयोग करके आप देख सकते हैं कि क्वेरी प्लानर क्या योजना बना रहा है . मूल रूप से यदि आप एक stage देखते हैं COLLSCAN . का , किसी अनुक्रमणिका का उपयोग नहीं किया गया था या क्वेरी के लिए उपयोग नहीं किया जा सकता था। देखें परिणाम समझाएं कमांड के आउटपुट के विवरण के लिए।