MongoDB query முடிவுகளை sort உடன் வரிசைப்படுத்துகிறது மற்றும் limit மற்றும் skip உடன் பக்கங்களாக பிரிக்கிறது — find cursor-ல் chain செய்யப்படுகின்றன. இவை ஒன்றாக முடிவுகளை வரிசைப்படுத்துவதையும் தரவின் பக்கங்களை திரும்பிக் கொடுப்பதையும் கையாளுகின்றன, இது முடிவுகளை காட்டுவதற்கு அத்యாவசியமாகும்.
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 ஒரு document of field:direction (1 восходящий, -1 அவரோகண) எடுக்கிறது. பல 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 செயல்படுத்துகின்றன (page N via skip + limit).
// ❌ 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 வரிசை உத்தரவாதம் இல்லை, எனவே paginated pages சீரற்றதாக இருக்கலாம். pagination செய்யும்போது எப்போதும் ஒரு நிலையான 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.
Sorting மற்றும் pagination MongoDB-ல் தரவை பயன்படுத்தக்கூடிய வகையில் காட்டுவதற்கு அடிப்படையாக உள்ளன — முடிவுகளை வரிசைப்படுத்துவது மற்றும் நிர்வகிக்கக்கூடிய பக்கங்களை திரும்பிக் கொடுப்பது கிட்டத்தட்ட உலகளாவிய தேவைகள் (ஒரு பயன்பாட்டில் ஏதேனும் list, feed, அல்லது table), எனவே அவற்றைப் புரிந்துகொள்வது அத்யாவசிய அன்றாட அறிவாகும்.
sort (fields-ஆல் வரிசைப்படுத்துவது 1/-1 உடன், tie-breaking உடன்) மற்றும் limit/skip (pagination-ற்கு — தரவின் பக்கங்களை திரும்பிக் கொடுப்பதற்கு) ஐ அறிந்துகொள்வது query முடிவுகளை வழங்குவதற்கான பொதுவான தேவைகளை உள்ளடக்குகிறது.
இரண்டு நடைமுறை புள்ளிகள் குறிப்பாக முக்கியமாக உள்ளன: pagination செய்யும்போது எப்போதும் sort செய்யுங்கள் (அதில்லாமல், document வரிசை உத்தரவாதம் இல்லை, சீரற்ற பக்கங்களை ஏற்படுத்துகிறது அவை ஓவர்ல்பாப் அல்லது documents தவிர்க்க முடியும் — ஒரு உண்மையான bug, SQL-ல் இருப்பது போன்ற ஒரே பிரச்சினை), மற்றும் skip ஆழமான பக்கங்களில் மெதுவாக இருக்கிறது என்பதைப் புரிந்துகொள்வது (இது scan மற்றும் முந்தைய அனைத்து documents தவிர்க்க வேண்டும்) — எனவே range-based (cursor) pagination (கடைசி பார்க்கப்பட்ட _idஐ பயன்படுத்தி அடுத்த பக்கத்ஐ fetch செய்வது, skip இல்லாமல் index பயன்படுத்துவது) பெரிய datasets-ற்கு மிகவும் திறமையானதாக உள்ளது, ஒரு மதிப்பবான செயல்திறன் நுட்பம்.
indexed fields-ல் sorting திறமையானது while பெரிய unindexed sorts மெதுவாக இருக்கலாம் அல்லது fail ஆகலாம் (in-memory sort limits) என்பதை அறிந்துகொள்வது முக்கியமாக உள்ளது — sort செய்ய விரும்பும் fields-ஐ index செய்யுங்கள்.
Sorting மற்றும் pagination கிட்டத்தட்ட எந்த தரவு display-ற்கும் தேவையாக உள்ளது, மற்றும் consistency requirement (stable pagination-ற்கான sort) மற்றும் செயல்திறன் பரிசீலনைகள் (skip vs range-based pagination, indexed sorts) சரியான செயல்பாடு மற்றும் வேகம் நேரடியாக பாதிக்கிறது, MongoDB sorting மற்றும் pagination — sort, offset pagination with skip/limit, stable-sort requirement, திறமையான range-based alternative, மற்றும் indexing sort fields — ஐ புரிந்துகொள்வது அத்யாவசிய, அடிக்கடி-பயன்படுத்தப்படும் MongoDB தரவை திறமையாக மற்றும் செயல்திறன் உடன் வழங்கும் பயன்பாடுகளை கட்டியெழுப்புவதற்கான அறிவாகும்.