सॉर्ट किए गए पेजिंग के लिए दिए गए रिकॉर्ड के लिए स्किप वैल्यू की गणना करें

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

जावास्क्रिप्ट तर्क शामिल है (क्योंकि यह शेल में काम करता है), लेकिन अनुवाद करना कठिन नहीं है।

सामान्य तौर पर अवधारणा:

{ "_id": 1, "a": 3 },
{ "_id": 2, "a": 3 },
{ "_id": 3, "a": 3 },
{ "_id": 4, "a": 2 },
{ "_id": 5, "a": 1 },
{ "_id": 6, "a": 0 }

उन "पहले से छांटे गए" दस्तावेज़ों (सुविधा के लिए) पर उन परिणामों के उदाहरण के रूप में विचार करें जिन्हें हम प्रति पृष्ठ "दो" आइटम द्वारा "पृष्ठ" करना चाहते हैं।

पहली बार में आप कुछ इस तरह करते हैं:

var lastVal = null,
    lastSeen = [];

db.collection.find().sort({ "a": -1 }).limit(2).forEach(function(doc) {
    if ( lastVal != doc.a ) {
        lastSeen = [];
    }
    lastVal = doc.a;
    lastSeen.push( doc._id );
    // do something useful with each document matched
});

अब वे lastVal और lastSeen वेब अनुप्रयोगों के संदर्भ में अगले अनुरोध पर पहुँचा जा सकने वाले "सत्र चर" जैसे किसी चीज़ में आप कुछ संग्रहीत करते हैं, या अन्यथा कुछ ऐसा ही है जहाँ नहीं।

हालांकि उनमें क्या शामिल होना चाहिए, वे अंतिम मूल्य हैं जिन पर आप सॉर्ट कर रहे थे और "अद्वितीय" _id की सूची मूल्य जो उस मूल्य के बाद से देखे गए थे, नहीं बदले। इसलिए:

lastVal = 3,
lastSeen = [1,2];

मुद्दा यह है कि जब "अगले पृष्ठ" के लिए अनुरोध आता है तो आप उन चरों का उपयोग कुछ इस तरह करना चाहते हैं:

var lastVal = 3,
    lastSeen = [1,2];

db.collection.find({ 
    "_id": { "$nin": lastSeen }, 
    "a": { "$lte": lastVal }
}).sort({ "a": -1 }).limit(2).forEach(function(doc) {
    if ( lastVal != doc.a ) {
        lastSeen = [];
    }
    lastVal = doc.a;
    lastSeen.push( doc._id );
    // do something useful with each document matched
});

वह क्या करता है _id . के सभी मानों को "बहिष्कृत" करता है जो lastSeen . में रिकॉर्ड किए गए हैं परिणामों की सूची से, साथ ही सुनिश्चित करें कि सभी परिणाम lastVal से "कम या बराबर" (अवरोही क्रम) होने चाहिए सॉर्ट फ़ील्ड "a" के लिए रिकॉर्ड किया गया।

यह संग्रह में अगले दो परिणाम देता है:

{ "_id": 3, "a": 3 },
{ "_id": 4, "a": 2 },

लेकिन हमारे मूल्यों को संसाधित करने के बाद अब इस तरह दिखते हैं:

lastVal = 2,
lastSeen = [4];

तो अब तर्क यह है कि आपको अन्य _id . को बाहर करने की आवश्यकता नहीं है पहले देखे गए मान क्योंकि आप केवल "a" के मानों की तलाश कर रहे हैं, जो lastVal से "कम या बराबर" हैं और चूंकि केवल "एक" था _id उस मान पर देखे जाने वाले मान को केवल उसी को बाहर करें।

यह निश्चित रूप से ऊपर के समान कोड का उपयोग करने पर अगला पृष्ठ उत्पन्न करता है:

{ "_id": 5, "a": 1 },
{ "_id": 6, "a": 0 }

यह सामान्य रूप से परिणामों के माध्यम से "अग्रेषित पृष्ठ" का सबसे प्रभावशाली तरीका है और विशेष रूप से "क्रमबद्ध" परिणामों के कुशल पेजिंग के लिए उपयोगी है।

अगर फिर भी आप पेज पर "कूदना" चाहते हैं 20 या किसी भी स्तर पर इसी तरह की कार्रवाई तो यह आपके लिए नहीं है। आप पारंपरिक .skip() . के साथ फंस गए हैं और .limit() "पृष्ठ संख्या" द्वारा ऐसा करने में सक्षम होने के लिए दृष्टिकोण क्योंकि इसकी "गणना" करने का कोई अन्य तर्कसंगत तरीका नहीं है।

तो यह सब इस बात पर निर्भर करता है कि आपका एप्लिकेशन "पेजिंग" को कैसे कार्यान्वित कर रहा है और आप किसके साथ रह सकते हैं। .skip() और .limit() दृष्टिकोण "छोड़ने" के प्रदर्शन से ग्रस्त है और यहां दृष्टिकोण का उपयोग करके इससे बचा जा सकता है।

दूसरी ओर, यदि आप "जंप टू पेज" चाहते हैं तो "स्किपिंग" आपका एकमात्र वास्तविक विकल्प है जब तक कि आप परिणामों का "कैश" नहीं बनाना चाहते। लेकिन यह पूरी तरह से एक और मुद्दा है।