MongoDB का उपयोग करते समय, उदाहरण के लिए पृष्ठांकित दृश्य बनाने के लिए कोई विशेष पैटर्न हैं? एक ऐसा ब्लॉग कहें जो उन 10 नवीनतम पोस्टों को सूचीबद्ध करता है जहाँ आप पुराने पोस्टों पर वापस नेविगेट कर सकते हैं।
या कोई इसे जैसे कि blogpost.publishdate पर एक सूचकांक के साथ हल करते हैं और परिणाम को छोड़ और सीमित करते हैं?
जवाबों:
स्किपिंग + सीमा का उपयोग करना एक अच्छा तरीका नहीं है जब प्रदर्शन एक मुद्दा है, या बड़े संग्रह के साथ पेजिंग करना है; जैसे ही आप पृष्ठ संख्या बढ़ाते हैं, यह धीमा और धीमा होता जाएगा। स्किप का उपयोग करने के लिए सर्वर को चलने की आवश्यकता होती है, हालांकि सभी दस्तावेज़ (या सूचकांक मान) 0 से ऑफसेट (छोड़ें) मान तक।
जहां आप अंतिम पृष्ठ के श्रेणी मान में पास होते हैं, वहां क्वेरी (+ सीमा) का उपयोग करना बेहतर होता है। उदाहरण के लिए यदि आप "publishdate" के आधार पर छंटनी कर रहे हैं, तो आप डेटा के अगले पृष्ठ को प्राप्त करने के लिए क्वेरी के मानदंड के रूप में अंतिम "publishdate" मान को पास कर देंगे।
संभावित समाधान: यह सोचकर कि हम केवल आईडी या कुछ अनूठे मूल्य के आधार पर छाँट सकते हैं, desgin को सरल बनाने का प्रयास करें?
और अगर हम कर सकते हैं, तो रेंज आधारित पेजिंग का उपयोग किया जा सकता है।
सामान्य तरीके का उपयोग किया जाता है सॉर्ट (), स्किप () और सीमा () को पेजिंग को लागू करने के लिए जो ऊपर वर्णित है।
{ _id: { $gt: ... } }... यह कस्टम आदेश का उपयोग करते हुए बस काम नहीं करता है - जैसे .sort(...)।
जब मेरे संग्रह में एक ही क्वेरी में वापसी करने के लिए बहुत बड़ा हो जाता है तो यह समाधान। यह _idक्षेत्र के निहित आदेश का लाभ उठाता है और आपको निर्दिष्ट बैच आकार द्वारा संग्रह के माध्यम से लूप करने की अनुमति देता है।
यहाँ यह एक npm मॉड्यूल के रूप में है, मैंगोज़-पेजिंग , पूर्ण कोड नीचे है:
function promiseWhile(condition, action) {
return new Promise(function(resolve, reject) {
process.nextTick(function loop() {
if(!condition()) {
resolve();
} else {
action().then(loop).catch(reject);
}
});
});
}
function findPaged(query, fields, options, iterator, cb) {
var Model = this,
step = options.step,
cursor = null,
length = null;
promiseWhile(function() {
return ( length===null || length > 0 );
}, function() {
return new Promise(function(resolve, reject) {
if(cursor) query['_id'] = { $gt: cursor };
Model.find(query, fields, options).sort({_id: 1}).limit(step).exec(function(err, items) {
if(err) {
reject(err);
} else {
length = items.length;
if(length > 0) {
cursor = items[length - 1]._id;
iterator(items, function(err) {
if(err) {
reject(err);
} else {
resolve();
}
});
} else {
resolve();
}
}
});
});
}).then(cb).catch(cb);
}
module.exports = function(schema) {
schema.statics.findPaged = findPaged;
};
इसे अपने मॉडल से इस तरह संलग्न करें:
MySchema.plugin(findPaged);
फिर इस तरह प्रश्न करें:
MyModel.findPaged(
// mongoose query object, leave blank for all
{source: 'email'},
// fields to return, leave blank for all
['subject', 'message'],
// number of results per page
{step: 100},
// iterator to call on each set of results
function(results, cb) {
console.log(results);
// this is called repeatedly while until there are no more results.
// results is an array of maximum length 100 containing the
// results of your query
// if all goes well
cb();
// if your async stuff has an error
cb(err);
},
// function to call when finished looping
function(err) {
throw err;
// this is called once there are no more results (err is null),
// or if there is an error (then err is set)
}
);
श्रेणी आधारित पेजिंग करने योग्य है, लेकिन आपको क्वेरी के न्यूनतम / अधिकतम होने के बारे में स्मार्ट होने की आवश्यकता है।
यदि आप खर्च कर सकते हैं, तो आपको एक अस्थायी फ़ाइल या संग्रह में किसी क्वेरी के परिणामों को कैशिंग करने की कोशिश करनी चाहिए। MongoDB में TTL संग्रह के लिए धन्यवाद आप अपने परिणाम दो संग्रहों में सम्मिलित कर सकते हैं।
टीटीएल वर्तमान समय के पास होने पर दोनों आश्वासनों का उपयोग करने से आपको आंशिक परिणाम नहीं मिलेंगे। जब आप उस बिंदु पर एक बहुत ही सरल श्रेणी क्वेरी करने के लिए परिणाम संग्रहीत करते हैं तो आप एक साधारण काउंटर का उपयोग कर सकते हैं।
आधिकारिक सी # ड्राइवर का उपयोग Userकरके CreatedDate(जहां pageIndexशून्य-आधारित है) दस्तावेजों के आदेश की एक सूची प्राप्त करने का एक उदाहरण यहां दिया गया है ।
public void List<User> GetUsers()
{
var connectionString = "<a connection string>";
var client = new MongoClient(connectionString);
var server = client.GetServer();
var database = server.GetDatabase("<a database name>");
var sortBy = SortBy<User>.Descending(u => u.CreatedDate);
var collection = database.GetCollection<User>("Users");
var cursor = collection.FindAll();
cursor.SetSortOrder(sortBy);
cursor.Skip = pageIndex * pageSize;
cursor.Limit = pageSize;
return cursor.ToList();
}
सभी सॉर्टिंग और पेजिंग ऑपरेशन सर्वर साइड पर किए जाते हैं। हालाँकि यह C # में एक उदाहरण है, मुझे लगता है कि इसे अन्य भाषा पोर्ट पर भी लागू किया जा सकता है।
// file:ad-hoc.js
// an example of using the less binary as pager in the bash shell
//
// call on the shell by:
// mongo localhost:27017/mydb ad-hoc.js | less
//
// note ad-hoc.js must be in your current directory
// replace the 27017 wit the port of your mongodb instance
// replace the mydb with the name of the db you want to query
//
// create the connection obj
conn = new Mongo();
// set the db of the connection
// replace the mydb with the name of the db you want to query
db = conn.getDB("mydb");
// replace the products with the name of the collection
// populate my the products collection
// this is just for demo purposes - you will probably have your data already
for (var i=0;i<1000;i++ ) {
db.products.insert(
[
{ _id: i, item: "lamp", qty: 50, type: "desk" },
],
{ ordered: true }
)
}
// replace the products with the name of the collection
cursor = db.products.find();
// print the collection contents
while ( cursor.hasNext() ) {
printjson( cursor.next() );
}
// eof file: ad-hoc.js