MongoDB sorteert queryresultaten met sort en pagineert met limit en skip — gekoppeld aan een find cursor. Samen behandelen ze ordening en retournering van datapagina's, essentieel voor het weergeven van resultaten.
MongoDB sorteert queryresultaten met sort en pagineert met limit en skip — gekoppeld aan een find cursor. Samen behandelen ze ordening en retournering van datapagina's, essentieel voor het weergeven van resultaten.
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 neemt een document van veld:richting (1 oplopend, -1 aflopend). Meerdere velden bieden 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) retourneert maximaal n documenten; skip(m) slaat de eerste m over. Samen implementeren ze offset-paginering (pagina 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);
Zonder sort is documentvolgorde niet gegarandeerd, dus gepagineerde pagina's kunnen inconsistent zijn. Sorteer altijd op een stabiel veld (zoals _id) bij paginering.
// ⚠️ 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.
Sorteren en paginering zijn fundamenteel voor het nuttig weergeven van gegevens in MongoDB — het ordenen van resultaten en retournering van hanteerbare pagina's zijn bijna universele behoeften (elke lijst, feed of tabel in een toepassing), dus begrip ervan is essentiële dagelijkse kennis.
Kennis van sort (ordenen op velden met 1/-1, met tie-breaking) en limit/skip (voor offset-paginering — retournering van datapagina's) dekt de gemeenschappelijke behoeften voor presentatie van queryresultaten.
Twee praktische punten zijn bijzonder belangrijk: sorteer altijd bij paginering (zonder het is documentvolgorde niet gegarandeerd, wat leidt tot inconsistente pagina's die overlappen of documenten overslaan — een echte bug, hetzelfde probleem als in SQL), en inzicht dat skip traag is op diepe pagina's (het moet alle voorgaande documenten scannen en overslaan) — dus op bereik gebaseerde (cursor) paginering (de laatst geziene _id gebruiken om de volgende pagina op te halen, leveraging van de index zonder overslaan) is veel efficiënter voor grote datasets, een waardevolle prestatietechniek.
Weten dat sorteren op geïndexeerde velden efficiënt is terwijl grote ongeïndexeerde sorteringen traag kunnen zijn of mislukken (in-memory sorteerlimieten) is ook belangrijk — indexeer velden waarop u sorteert.
Omdat sorteren en paginering vereist zijn voor praktisch elke gegevenspresentatie, en omdat de consistentievereiste (sorteer voor stabiele paginering) en prestatieoverwegingen (skip versus op bereik gebaseerde paginering, geïndexeerde sorteringen) rechtstreeks de correctheid en snelheid beïnvloeden, is inzicht in MongoDB sorteren en paginering — sort, offset-paginering met skip/limit, de stabiele-sortvereiste, het efficiënte op bereik gebaseerde alternatief en indexering van sorteervelden — essentieel, veelvuldig toegepaste kennis voor het bouwen van applicaties die MongoDB-gegevens effectief en performant presenteren.