A MongoDB lekérdezési eredményeit a sort rendezi, és az limit valamint a skip segítségével végez oldalszámozást — ezeket egy find kurzorhoz láncol. Együtt kezelik az eredmények rendezését és az adatlapok visszaadását, ami alapvető a találatok megjelenítéséhez.
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)
A sort egy dokumentumot vesz fel, amely mező:irány párosításokat tartalmaz (1 növekvő, -1 csökkenő). Több mező döntéseket lehet biztosít.
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)
A limit(n) legfeljebb n dokumentumot ad vissza; a skip(m) az első m dokumentumot kihagyja. Együtt az offset oldalszámozást valósítják meg (N. lapot a skip + limit segítségével).
// ❌ 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);
Rendezés nélkül a dokumentumok sorrendje nem garantált, így az oldalszámozás lapjai inconsistent lehetnek. Mindig rendezz egy stabil mező szerint (például _id) oldalszámozáskor.
// ⚠️ 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.
A rendezés és az oldalszámozás alapvetőek a MongoDB-ben az adatok hasznos megjelenítésében — az eredmények rendezése és az kezelhető lapok visszaadása szinte univerzális igény (bármilyen lista, feed vagy táblázat egy alkalmazásban), ezért az ezek megértése alapvető mindennapi tudás.
A sort (rendezés mezők szerint 1/-1 értékekkel, döntésekkel) és a limit/skip (az offset oldalszámozáshoz — adatlapok visszaadásához) ismerete az átlagos lekérdezési eredmények bemutatásának szükségleteit fedezi.
Két praktikus pont különösen fontos: mindig rendezz oldalszámozáskor (nélküle a dokumentumok sorrendje nem garantált, ami inconsistent lapokat okoz, amelyek átfedésben lehetnek vagy kihagyhatnak dokumentumokat — valós hiba, amely megegyezik az SQL problémájával), és annak megértése, hogy a skip lassú a mély lapoknál (az összes megelőző dokumentumot be kell olvasnia és ki kell hagynia) — ezért a tartományon alapuló (kurzor) oldalszámozás (az utolsó látott _id használata a következő lap lekérdezéséhez, az indexet kihasználva anélkül, hogy kihagyná) sokkal hatékonyabb nagyobb adathalmazoknál, egy értékes teljesítménytechnika.
Annak ismerete, hogy az indexelt mezőkön végzett rendezés hatékony, míg a nagy, indexeletlen rendezések lassúak lehetnek vagy meghiúsulhatnak (memóriabeli rendezési korlátok), szintén fontos — indexeld azt a mezőt, amely szerint rendezed.
Mivel a rendezés és az oldalszámozás szinte bármilyen adatmegjelenítéshez szükséges, és mivel a konzisztencia követelménye (rendezés az stabil oldalszámozáshoz) és a teljesítménybeli megfontolások (skip vs. tartományon alapuló oldalszámozás, indexelt rendezések) közvetlenül befolyásolják a helyességet és a sebességet, a MongoDB rendezés és oldalszámozás megértése — sort, offset oldalszámozás skip/limit-tel, a stabil rendezési követelmény, a hatékony tartományon alapuló alternatíva és az oldalszámozás mezőinek indexelése — alapvető, gyakran alkalmazott tudás a MongoDB adatokat hatékonyan és teljesítményesen megjelenítő alkalmazások építéséhez.