MongoDB query results को sort के साथ sort करता है और limit तथा skip के साथ paginate करता है — जो एक find cursor पर chain किए जाते हैं। साथ में वे ordering और डेटा के pages लौटाने को संभालते हैं, जो results प्रदर्शित करने के लिए आवश्यक है।
MongoDB query results को sort के साथ sort करता है और limit तथा skip के साथ paginate करता है — जो एक find cursor पर chain किए जाते हैं। साथ में वे ordering और डेटा के pages लौटाने को संभालते हैं, जो results प्रदर्शित करने के लिए आवश्यक है।
db.users.find().sort({ age: 1 }); // ascending by age (1 = asc)
db.users.find().sort({ age: -1 }); // descending (-1 = desc)
db.users.find().sort({ country: 1, name: 1 }); // by country, then name (tie-break)
db.users.find().sort({ createdAt: -1 }); // newest first (common)
sort field:direction का एक document लेता है (1 ascending, -1 descending)। कई fields tie-breaking प्रदान करते हैं।
db.users.find().sort({ name: 1 }).limit(10); // first 10 (page 1)
db.users.find().sort({ name: 1 }).skip(10).limit(10); // skip 10, take 10 (page 2)
// page N: .skip((N-1) * pageSize).limit(pageSize)
limit(n) अधिकतम n documents लौटाता है; skip(m) पहले m को छोड़ देता है। साथ में वे offset pagination (skip + limit के माध्यम से page N) को लागू करते हैं।
// ❌ pagination without sort → inconsistent order (pages may overlap/skip)
db.users.find().skip(10).limit(10);
// ✅ sort by a stable field for consistent pages
db.users.find().sort({ _id: 1 }).skip(10).limit(10);
sort के बिना, document order की गारंटी नहीं होती, इसलिए paginated pages असंगत हो सकते हैं। Paginate करते समय हमेशा एक stable field (जैसे _id) के अनुसार sort करें।
// ⚠️ skip(1000000) must scan/skip a million docs → slow on deep pages
// ✅ range-based (cursor) pagination — far more efficient for large datasets
db.users.find({ _id: { $gt: lastSeenId } }).sort({ _id: 1 }).limit(10);
// → use the last document's _id to fetch the next page (uses the index, no skipping)
Sorting on an INDEXED field is efficient. Sorting a large result set WITHOUT an index
requires an in-memory sort (limited size — can fail/be slow for big sorts).
→ Index fields you sort by.
MongoDB में डेटा को उपयोगी रूप से प्रदर्शित करने के लिए sorting और pagination मौलिक हैं — results को order करना और प्रबंधनीय pages लौटाना लगभग सार्वभौमिक आवश्यकताएँ हैं (किसी application में कोई भी list, feed, या table), इसलिए उन्हें समझना आवश्यक रोज़मर्रा का ज्ञान है।
sort (fields के अनुसार 1/-1 के साथ ordering, tie-breaking के साथ) और limit/skip (offset pagination के लिए — डेटा के pages लौटाना) को जानना query results प्रस्तुत करने की सामान्य आवश्यकताओं को कवर करता है।
दो व्यावहारिक बिंदु विशेष रूप से महत्वपूर्ण हैं: paginate करते समय हमेशा sort करें (इसके बिना, document order की गारंटी नहीं होती, जिससे असंगत pages होते हैं जो documents को overlap या skip करते हैं — एक वास्तविक bug, SQL जैसी ही समस्या), और यह समझना कि गहरे pages पर skip धीमा होता है (इसे सभी पूर्ववर्ती documents को scan और skip करना होगा) — इसलिए range-based (cursor) pagination (अगला page प्राप्त करने के लिए अंतिम देखे गए _id का उपयोग करना, बिना skipping के index का लाभ उठाना) बड़े datasets के लिए कहीं अधिक कुशल है, एक मूल्यवान performance तकनीक।
यह जानना कि indexed fields पर sorting कुशल है जबकि बड़े unindexed sorts धीमे या विफल हो सकते हैं (in-memory sort सीमाएँ) भी महत्वपूर्ण है — जिन fields के अनुसार आप sort करते हैं उन्हें index करें।
चूँकि किसी भी डेटा प्रदर्शन के लिए sorting और pagination आवश्यक हैं, और चूँकि consistency आवश्यकता (stable pagination के लिए sort करें) और performance विचार (skip बनाम range-based pagination, indexed sorts) सीधे correctness और गति को प्रभावित करते हैं, MongoDB sorting और pagination को समझना — sort, skip/limit के साथ offset pagination, stable-sort आवश्यकता, कुशल range-based विकल्प, और sort fields को indexing करना — MongoDB डेटा को प्रभावी और performant ढंग से प्रस्तुत करने वाली applications बनाने के लिए आवश्यक, बार-बार लागू किया जाने वाला ज्ञान है।