Jak fungují řazení a stránkování v MongoDB?

Question

Accepted Answer

MongoDB řadí výsledky dotazů pomocí **`sort`** a stránkuje pomocí **`limit`** a **`skip`** — řetězené na kurzoru `find`. Dohromady zpracovávají řazení a vracení stránek dat, což je nezbytné pro zobrazování výsledků.

## sort — řazení výsledků

```js
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` přijímá dokument se vztahem pole:směr (`1` vzestupně, `-1` sestupně). Více polí umožňuje rozhodování v případě rovnosti.

## limit a skip — stránkování

```js
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)` vrací maximálně n dokumentů; `skip(m)` přeskočí prvních m. Dohromady implementují **stránkování s offsetem** (stránka N pomocí skip + limit).

## Vždy řaďte při stránkování

```js
// ❌ 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);
```

Bez `sort` není pořadí dokumentů zaručeno, takže stránkované stránky mohou být nekonzistentní. Při stránkování vždy řaďte podle stabilního pole (například `_id`).

## skip je pomalý na hlubokých stránkách — použijte stránkování založené na rozsahu

```js
// ⚠️ 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)
```

## Řazení a indexy

```text
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.
```

## Proč to záleží

Řazení a stránkování jsou základní pro **užitečné zobrazování dat** v MongoDB — řazení výsledků a vracení zvládnutelných stránek jsou téměř univerzální potřeby (jakýkoli seznam, feed nebo tabulka v aplikaci), takže jejich pochopení je nezbytné každodenní znalostí.

Znalost `sort` (řazení podle polí s `1`/`-1`, s rozhodováním v případě rovnosti) a `limit`/`skip` (pro **stránkování s offsetem** — vracení stránek dat) pokrývá běžné potřeby pro prezentaci výsledků dotazů.

Dva praktické body jsou zvláště důležité: **vždy řaďte při stránkování** (bez toho není pořadí dokumentů zaručeno, což způsobuje nekonzistentní stránky, které se překrývají nebo přeskakují dokumenty — skutečná chyba, stejný problém jako v SQL), a pochopení, že **`skip` je pomalý na hlubokých stránkách** (musí skenovat a přeskočit všechny předchozí dokumenty) — takže **stránkování založené na rozsahu (kurzor)** (používající poslední viděné `_id` k načtení další stránky, využívající index bez přeskakování) je mnohem efektivnější pro velké datové sady, cenná technika výkonu.

Vědomí, že **řazení podle indexovaných polí je efektivní**, zatímco velké neindexované řazení mohou být pomalé nebo selhat (limity in-memory řazení), je také důležité — indexujte pole, podle kterých řadíte.

Protože řazení a stránkování jsou vyžadovány pro prakticky jakékoliv zobrazování dat a protože požadavek na konzistenci (řazení pro stabilní stránkování) a hlediska výkonu (skip versus stránkování založené na rozsahu, indexované řazení) přímo ovlivňují správnost a rychlost, pochopení MongoDB řazení a stránkování — `sort`, stránkování s offsetem pomocí skip/limit, požadavek na stabilní řazení, efektivní alternativu založenou na rozsahu a indexování polí pro řazení — je nezbytné, často používané znalosti pro vytváření aplikací, které efektivně a výkonně prezentují MongoDB data.