मोंगोडीबी में इंडेक्स काम के साथ सॉर्टिंग कैसे करता है?

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

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

एक SORT एक क्वेरी में स्टेज (यानी इन-मेमोरी सॉर्ट) 32MB मेमोरी उपयोग तक सीमित है। यदि SORT चरण इस सीमा से अधिक है। अनुक्रमणिका की क्रमबद्ध प्रकृति का उपयोग करके इस सीमा को दूर किया जा सकता है, ताकि MongoDB sort() के साथ एक क्वेरी वापस कर सके। इन-मेमोरी सॉर्ट किए बिना पैरामीटर।

आइए मान लें कि क्वेरी आकार की है:

    db.a.find({b:{$gt:100}, c:{$gt:200}}).sort(...)

संग्रह के साथ a का सूचकांक होना:

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

दो संभावित परिदृश्य हैं जब एक sort() चरण क्वेरी में निर्दिष्ट है:

<मजबूत>1. MongoDB अनुक्रमणिका की सॉर्ट की गई प्रकृति का उपयोग नहीं कर सकता है और उसे एक इन-मेमोरी SORT करना होगा मंच ।

यह परिणाम है यदि क्वेरी "इंडेक्स उपसर्ग" का उपयोग नहीं कर सकती है। उदाहरण के लिए:

    db.a.find({b:{$gt:100}, c:{$gt:200}}).sort({c:1})

उपरोक्त क्वेरी में, अनुक्रमणिका {b:1,c:1} के लिए इस्तेमाल किया जा सकता है:

• b वाले दस्तावेज़ों का मिलान करें {b:{$gt:100}} . के लिए 100 से अधिक क्वेरी का हिस्सा।
• हालांकि, इस बात की कोई गारंटी नहीं है कि लौटाए गए दस्तावेज़ों को c के अनुसार क्रमबद्ध किया गया है ।

इसलिए, MongoDB के पास इन-मेमोरी सॉर्ट करने के अलावा कोई विकल्प नहीं है। explain() इस क्वेरी के आउटपुट में एक SORT होगा मंच। यह SORT चरण 32MB स्मृति उपयोग तक सीमित होगा।

<मजबूत>2. MongoDB अनुक्रमणिका की क्रमबद्ध प्रकृति का उपयोग कर सकता है ।

यदि क्वेरी का उपयोग करती है तो यह परिणाम है:

• सूचकांक के क्रम से मेल खाने वाली कुंजियों को क्रमबद्ध करें, और
• अनुक्रमणिका के समान क्रम को निर्दिष्ट करता है (अर्थात अनुक्रमणिका {b:1,c:1} sort({b:1,c:1}) . के लिए इस्तेमाल किया जा सकता है या sort({b:-1,c:-1}) लेकिन sort({b:1,c:-1}) )

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

    db.a.find({b:{$gt:100}, c:{$gt:200}}).sort({b:1})

उपरोक्त क्वेरी में, अनुक्रमणिका {b:1,c:1} के लिए इस्तेमाल किया जा सकता है:

• b वाले दस्तावेज़ों का मिलान करें {b:{$gt:100}} . के लिए 100 से अधिक क्वेरी का हिस्सा।
• इस मामले में, MongoDB गारंटी दे सकता है कि लौटाए गए दस्तावेज़ों को b के अनुसार क्रमबद्ध किया गया है ।

explain() उपरोक्त क्वेरी का आउटपुट नहीं . होगा एक SORT है मंच। साथ ही, explain() sort() के साथ और बिना क्वेरी का आउटपुट समान हैं . संक्षेप में, हमें sort() मिल रहा है मुफ्त में।

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

अनुवर्ती प्रश्नों पर अपडेट करें

1. अधिकांश प्रश्नों के लिए MongoDB केवल एक अनुक्रमणिका का उपयोग करता है। तो उदाहरण के लिए, इन-मेमोरी SORT . से बचने के लिए क्वेरी में चरण

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

   इंडेक्स में a . दोनों शामिल होने चाहिए और b एक ही समय में क्षेत्र; जैसे एक मिश्रित अनुक्रमणिका जैसे {a:1,b:1} आवश्यक है। आपके पास दो अलग-अलग इंडेक्स नहीं हो सकते {a:1} और {b:1} , और {a:1} . की अपेक्षा करें समानता भाग के लिए उपयोग की जाने वाली अनुक्रमणिका, और {b:1} अनुक्रमणिका का उपयोग सॉर्ट भाग के लिए किया जाना है। इस मामले में, MongoDB दो इंडेक्स में से एक का चयन करेगा।

   इसलिए, यह सही है कि परिणामों को क्रमबद्ध किया जाता है क्योंकि उन्हें इंडेक्स के क्रम में देखा और लौटाया जाता है।

2. कंपाउंड इंडेक्स का उपयोग करके इन-मेमोरी सॉर्ट होने से बचने के लिए, इंडेक्स के पहले भाग को समानता वाले हिस्से को पूरा करना चाहिए क्वेरी का, और दूसरे भाग को सॉर्ट भाग को पूरा करना चाहिए (जैसा कि ऊपर (1) के स्पष्टीकरण में दिखाया गया है)।

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

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

   सूचकांक {a:1,b:1} सॉर्ट भाग के लिए उपयोग किया जा सकता है (चूंकि आप मूल रूप से पूरे संग्रह को वापस कर रहे हैं)। और अगर आपकी क्वेरी इस तरह दिखती है:

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

   वही अनुक्रमणिका {a:1,b:1} क्वेरी के दोनों हिस्सों के लिए भी इस्तेमाल किया जा सकता है। इसके अलावा:

   db.a.find({a:1,b:1})
   

   उसी अनुक्रमणिका का उपयोग भी कर सकते हैं {a:1,b:1}

   यहां पैटर्न पर ध्यान दें:find() उसके बाद sort() पैरामीटर इंडेक्स ऑर्डर का पालन करते हैं {a:1,b:1} . इसलिए एक कंपाउंड इंडेक्स को समानता -> सॉर्ट . द्वारा क्रमबद्ध किया जाना चाहिए ।

विभिन्न प्रकार की छँटाई के संबंध में अद्यतन करें

यदि किसी फ़ील्ड में दस्तावेज़ों के बीच भिन्न प्रकार हैं (उदा. यदि a एक दस्तावेज़ में स्ट्रिंग है, दूसरे में संख्या, दूसरे में बूलियन), क्रम कैसे आगे बढ़ता है?

उत्तर मोंगोडीबी बीएसओएन प्रकार तुलना आदेश है। मैनुअल पेज को पैराफ्रेश करने के लिए, आदेश है:

1. मिनकी (आंतरिक प्रकार)
2. शून्य
3. संख्याएं (इंट्स, लॉन्ग, डबल्स, डेसीमल)
4. प्रतीक, स्ट्रिंग
5. वस्तु
6. सरणी
7. बिनडाटा
8. ऑब्जेक्ट आईडी
9. बूलियन
10. तारीख
11. टाइमस्टैम्प
12. नियमित अभिव्यक्ति
13. MaxKey (आंतरिक प्रकार)

तो ऊपर दिए गए उदाहरण से आरोही क्रम का उपयोग करते हुए, संख्या वाले दस्तावेज़ पहले दिखाई देंगे, फिर तार, फिर बूलियन।