MongoDB క్వెరీ ఫలితాలను sort ఉపయోగించి సార్ట్ చేస్తుంది మరియు limit మరియు skip ఉపయోగించి పేజినేట్ చేస్తుంది — find కర్సర్పై చైన్ చేయబడింది. కలిసి అవి ఆర్డరింగ్ మరియు డేటా పేజ్లను రిటర్న్ చేయడాన్ని నిర్వహిస్తాయి, ఫలితాలను ప్రదర్శించడానికి ఎంపరార్థవంతమైనవి.
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 ఫీల్డ్:దిశ (1 ఆరోహణ, -1 అవరోహణ) యొక్క డాక్యుమెంట్ తీసుకుంటుంది. బహుళ ఫీల్డ్లు టై-ब్రేకింగ్ ప్రదానం చేస్తాయి.
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 డాక్యుమెంట్లను రిటర్న్ చేస్తుంది; skip(m) మొదటి m లను స్కిప్ చేస్తుంది. కలిసి అవి ఆఫ్సెట్ పేజినేషన్ (పేజ్ 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 లేకుండా, డాక్యుమెంట్ క్రమం గ్యారంటీ ఇవ్వబడదు, కాబట్టి పేజీనేట్ చేసిన పేజ్లు అస్థిరంగా ఉండవచ్చు. పేజినేషన్ చేస్తున్నప్పుడు ఎల్లప్పుడు స్థిర ఫీల్డ్ (లాగా _id) ద్వారా సార్ట్ చేయండి.
// ⚠️ 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 లో డేటాను ఉపయోగకరంగా ప్రదర్శించడానికి సార్టింగ్ మరియు పేజినేషన్ ప్రాథమికమైనవి — ఫలితాలను ఆర్డర్ చేయడం మరియు నిర్వహించదగిన పేజ్లను రిటర్న్ చేయడం సరిగ్గా సార్వత్రిక కావలసినవి (ఏదైనా జాబితా, ఫీడ్ లేదా అనువర్తనంలో పట్టిక), కాబట్టి వాటిని అర్థం చేసుకోవడం ఎంపరార్థవంతమైన రోజువారీ జ్ఞానం.
sort (ఫీల్డ్ల ద్వారా ఆర్డర్ చేయడం 1/-1 తో, టై-బ్రేకింగ్ కోసం) మరియు limit/skip (ఆఫ్సెట్ పేజినేషన్ కోసం — డేటా పేజ్లను రిటర్న్ చేయడం) తెలుసుకోవడం సాధారణ కావలసిన సమస్యలను కవర్ చేస్తుంది.
మూడు ఆచరణాత్మక పాయింట్లు ప్రత్యేకంగా ముఖ్యమైనవి: పేజినేషన్ చేస్తున్నప్పుడు ఎల్లప్పుడు సార్ట్ చేయండి (లేకుండా, డాక్యుమెంట్ క్రమం గ్యారంటీ ఇవ్వబడదు, అస్థిర పేజ్లకు కారణమవుతుంది, ఇవి అతిక్రమణం లేదా డాక్యుమెంట్లను స్కిప్ చేస్తాయి — నిజమైన బగ్, SQL లో ఇదే సమస్య), మరియు skip డీప్ పేజ్లలో నెమ్మదిగా ఉందని అర్థం చేసుకోవడం (ఇది సూచించిన డాక్యుమెంట్లన్నింటిని స్కాన్ మరియు స్కిప్ చేయవలసి ఉంది) — కాబట్టి రేంజ్-ఆధారిత (కర్సర్) పేజినేషన్ (చివరి కనిపించిన _id ఉపయోగించి తదుపరి పేజ్ ఫెచ్ చేయడం, స్కిపింగ్ లేకుండా ఇండెక్సను ఉపయోగించడం) పెద్ద డేటా సెట్ల కోసం చాలా మరింత సమర్థవంతమైనది, విలువైన పనితీరు విధానం.
ఇండెక్స్ చేసిన ఫీల్డ్లలో సార్టింగ్ సమర్థవంతమైనది అయితే పెద్ద ఇండెక్స్ చేయని సార్టులు నెమ్మదిగా ఉండవచ్చు లేదా విఫలం కావచ్చు (ఇన్-మెమరీ సార్ట్ లిమిట్లు) అని తెలుసుకోవడం కూడా ముఖ్యమైనది — సార్ట్ చేసే ఫీల్డ్ల ఇండెక్స్.
సార్టింగ్ మరియు పేజినేషన్ సరిగ్గా ఏదైనా డేటా ప్రదర్శన కోసం అవసరమైనవి కాబట్టి, మరియు స్థిరత్వ కావలస (సస్థిర పేజినేషన్ కోసం సార్ట్) మరియు పనితీరు విచారణలు (స్కిప్ వర్సెస్ రేంజ్-ఆధారిత పేజినేషన్, ఇండెక్స్ చేసిన సార్టులు) సరిదిద్దడం మరియు వేగానికి నేరుగా ప్రభావం చేస్తాయి కాబట్టి, MongoDB సార్టింగ్ మరియు పేజినేషన్ అర్థం చేసుకోవడం — sort, స్కిప్/లిమిట్ తో ఆఫ్సెట్ పేజినేషన్, స్థిర-సార్ట్ కావలస, సమర్థవంతమైన రేంజ్-ఆధారిత ప్రత్యామ్నాయం, మరియు ఇండెక్సింగ్ సార్ట్ ఫీల్డ్లు — MongoDB డేటాను ప్రభావవంతంగా మరియు పనితీరు కోసం ఎంపరార్థవంతమైన మరియు తరచుగా ఉపయోగించిన జ్ఞానం.