MongoDB સોર્ટ કરે છે sort સાથે અને પેજિનેશન કરે છે limit અને skip સાથે — find કર્સર પર સાંકળી કરવામાં આવે છે. એક સાથે તેઓ ક્રમમાં દેતા હોય છે અને ડેટાના પૃષ્ઠો પરત કરે છે, જે પરિણામો દર્શાવવા માટે આવશ્યક છે.
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 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 વિના, દસ્તાવેજ ક્રમ ખાતરી આપી શકાતો નથી, તેથી પેજિંગ પૃષ્ઠો અસંગત હોઈ શકે છે. પેજિનેશન કરતી વખતે હંમેશા સ્થિર ફીલ્ડ (જેવા કે _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 (ઑફસેટ પેજિનેશન માટે — ડેટાના પૃષ્ઠો પરત કરવા) જાણવાથી સામાન્ય જરૂરિયાતો આવરી લે છે કે જે પ્રશ્ન પરિણામો પસ્તુત કરવા માટે છે.
દુ specific વ્યવહારિક બિંદુ ખાસ કરીને મહત્વપૂર્ણ છે: પેજિનેશન કરતી વખતે હંમેશા સોર્ટ કરો (તેના વિના, દસ્તાવેજ ક્રમ ખાતરી આપી શકાતો નથી, અસંગત પૃષ્ઠોનું કારણ બને છે જે ઓવરલેપ કરે છે અથવા દસ્તાવેજ છોડી દે છે — વાસ્તવિક બગ, SQL માં સમાન સમસ્યા), અને skip ઊંડા પૃષ્ઠોમાં ધીમો છે તે સમજવું (તેણે બધા અગાઉના દસ્તાવેજોને સ્કેન અને છોડવા પડે છે) — તેથી શ્રેણી-આધારિત (કર્સર) પેજિનેશન (છેલ્લો જોયેલ _id દ્વારા આગલું પૃષ્ઠ લાવવા, ઇન્ડેક્સ છાંટી કર્યા વિના) મોટા ડેટાસેટ માટે વધુ કાર્યક્ષમ છે, એક મૂલ્યવાન પ્રદર્શન તકનીક.
જાણવું કે ઇન્ડેક્સ્ડ ફીલ્ડ પર સોર્ટ કરવું કાર્યક્ષમ છે જ્યારે મોટી અનિન્ડેક્સ્ડ સોર્ટ ધીમી અથવા નિષ્ફળ (ઇન-મેમોરી સોર્ટ લક્ષણો) હોઈ શકે તે પણ મહત્વપૂર્ણ છે — તમે જે ફીલ્ડ પર સોર્ટ કરો તેને ઇન્ડેક્સ કરો.
સોર્ટિંગ અને પેજિનેશન લગભગ કોઈપણ ડેટા પ્રદર્શનને જરૂરી છે, અને સુસંગતતા જરૂરિયાત (સ્થિર પેજિનેશન માટે સોર્ટ કરો) અને પ્રદર્શન વિચારણા (skip વર્સેસ શ્રેણી-આધારિત પેજિનેશન, ઇન્ડેક્સ્ડ સોર્ટ) સીધા જ સુધાર અને ગતિને અસર કરે છે, MongoDB સોર્ટિંગ અને પેજિનેશન સમજવું — sort, skip/limit સાથે ઑફસેટ પેજિનેશન, સ્થિર-સોર્ટ જરૂરિયાત, કાર્યક્ષમ શ્રેણી-આધારિત વિકલ્પ, અને સોર્ટ ફીલ્ડને ઇન્ડેક્સ કરવું — MongoDB ડેટા અસરકારક અને કાર્યક્ષમતાથી પસ્તુત કરતી એપ્લિકેશનો બનાવવા માટે આવશ્યક, વારવાર લાગુ થતું જ્ઞાન છે.