Upangaji na ukurasaji vinafanyaje kazi katika MongoDB?

Question

Accepted Answer

MongoDB hupanga matokeo ya mauliza kwa **`sort`** na hufanya ukurasaji kwa **`limit`** na **`skip`** — vikiunganishwa kwenye cursor ya `find`. Pamoja vinashughulikia upangaji na kurudisha kurasa za data, muhimu kwa kuonyesha matokeo.

## sort — kupanga matokeo

```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` huchukua nyaraka ya field:mwelekeo (`1` kupanda, `-1` kushuka). Sehemu nyingi hutoa uvunjaji wa sare.

## limit na skip — ukurasaji

```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)` hurudisha zaidi ya nyaraka n; `skip(m)` huruka m za kwanza. Pamoja zinatekeleza **ukurasaji wa offset** (ukurasa N kupitia skip + limit).

## Daima panga unapofanya ukurasaji

```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);
```

Bila `sort`, mpangilio wa nyaraka hauhakikishiwi, kwa hivyo kurasa zilizowekwa kwenye ukurasaji zinaweza kuwa hazifanani. Daima panga kwa sehemu thabiti (kama `_id`) unapofanya ukurasaji.

## skip ni polepole kwenye kurasa za kina — tumia ukurasaji unaotegemea masafa

```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)
```

## Upangaji na indexes

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

## Kwa nini ni muhimu

Upangaji na ukurasaji ni vya msingi kwa **kuonyesha data kwa manufaa** katika MongoDB — kupanga matokeo na kurudisha kurasa zinazoweza kudhibitiwa ni mahitaji ya karibu yote (orodha yoyote, feed, au jedwali katika programu), kwa hivyo kuvielewa ni maarifa muhimu ya kila siku.

Kujua `sort` (kupanga kwa sehemu kwa `1`/`-1`, na uvunjaji wa sare) na `limit`/`skip` (kwa **ukurasaji wa offset** — kurudisha kurasa za data) hujumuisha mahitaji ya kawaida ya kuwasilisha matokeo ya mauliza.

Mambo mawili ya kivitendo ni muhimu hasa: **daima panga unapofanya ukurasaji** (bila hilo, mpangilio wa nyaraka hauhakikishiwi, ukisababisha kurasa zisizofanana zinazoingiliana au kuruka nyaraka — hitilafu halisi, suala lile lile kama katika SQL), na kuelewa kwamba **`skip` ni polepole kwenye kurasa za kina** (lazima ichanganue na kuruka nyaraka zote zinazotangulia) — kwa hivyo **ukurasaji unaotegemea masafa (cursor)** (kutumia `_id` ya mwisho iliyoonekana kupata ukurasa unaofuata, ukitumia index bila kuruka) ni bora zaidi kwa seti kubwa za data, mbinu yenye thamani ya utendaji.

Kujua kwamba **upangaji kwenye sehemu zilizo na index ni wenye ufanisi** ilhali upangaji mkubwa usio na index unaweza kuwa polepole au kushindwa (mipaka ya upangaji wa kumbukumbu) pia ni muhimu — weka index kwa sehemu unazopanga.

Kwa kuwa upangaji na ukurasaji vinahitajika kwa karibu uonyeshaji wowote wa data, na kwa kuwa hitaji la uthabiti (panga kwa ukurasaji thabiti) na mazingatio ya utendaji (skip dhidi ya ukurasaji unaotegemea masafa, upangaji wenye index) huathiri moja kwa moja usahihi na kasi, kuelewa upangaji na ukurasaji wa MongoDB — `sort`, ukurasaji wa offset kwa skip/limit, hitaji la upangaji thabiti, mbadala wenye ufanisi unaotegemea masafa, na kuweka index kwa sehemu za upangaji — ni maarifa muhimu, yanayotumika mara kwa mara kwa kujenga programu zinazowasilisha data ya MongoDB kwa ufanisi na utendaji.