MongoDB ਵਿੱਚ ਛਾਂਟੀ ਅਤੇ ਪੰਨਾ-ਦਰ-ਪੰਨਾ ਕਾਰਜ ਕਿਵੇਂ ਕਾਮ ਕਰਦਾ ਹੈ?

Question

Accepted Answer

MongoDB ਬੇਨਤੀ ਨਤੀਜਿਆਂ ਨੂੰ **`sort`** ਨਾਲ ਛਾਂਟਦਾ ਹੈ ਅਤੇ **`limit`** ਅਤੇ **`skip`** ਨਾਲ ਪੰਨਾ-ਦਰ-ਪੰਨਾ ਬਣਾਉਂਦਾ ਹੈ — ਇਹ `find` ਕਰਸਰ ਉੱਤੇ ਚੇਨ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇਕੱਠੇ ਇਹ ਕ੍ਰਮ ਪ੍ਰਬੰਧਨ ਅਤੇ ਡੇਟਾ ਦੇ ਪੰਨਿਆਂ ਦੀ ਵਾਪਸੀ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ, ਜੋ ਨਤੀਜਿਆਂ ਦੀ ਪ੍ਰਦਰਸ਼ਨੀ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

## sort — ਨਤੀਜਿਆਂ ਨੂੰ ਕ੍ਰਮ ਵਿੱਚ ਕਰੋ

```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` ਇੱਕ ਦਸਤਾਵੇਜ਼ ਨੂੰ field:direction (`1` ਵਾਧਾ, `-1` ਘਟਾਓ) ਲੈਂਦਾ ਹੈ। ਕਈ ਖੇਤਰ ਟਾਈ-ਬ੍ਰੇਕਿੰਗ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।

## limit ਅਤੇ skip — ਪੰਨਾ-ਦਰ-ਪੰਨਾ

```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)` ਵੱਧ ਤੋਂ ਵੱਧ n ਦਸਤਾਵੇਜ਼ ਵਾਪਸ ਕਰਦਾ ਹੈ; `skip(m)` ਪਹਲੇ m ਨੂੰ ਛੱਡ ਦਿੰਦਾ ਹੈ। ਇਕੱਠੇ ਇਹ **offset pagination** ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਨ (ਪੰਨਾ N skip + limit ਦੇ ਰਾਹੀਂ)।

## ਹਮੇਸ਼ਾ ਪੰਨਾ-ਦਰ-ਪੰਨਾ ਕਰਦੇ ਸਮੇਂ ਛਾਂਟੋ

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

`sort` ਤੋਂ ਬਿਨਾਂ, ਦਸਤਾਵੇਜ਼ ਦਾ ਕ੍ਰਮ ਨਿਸ਼ਚਿਤ ਨਹੀਂ, ਇਸ ਲਈ ਪੰਨਾਬੱਧ ਪੰਨੇ ਅਸਮਰੱਪ ਹੋ ਸਕਦੇ ਹਨ। ਪੰਨਾ-ਦਰ-ਪੰਨਾ ਕਰਦੇ ਸਮੇਂ ਹਮੇਸ਼ਾ ਇੱਕ ਸਥਿਰ ਖੇਤਰ (ਜਿਵੇਂ `_id`) ਨਾਲ ਛਾਂਟੋ।

## ਡੂੰਘੇ ਪੰਨਿਆਂ ਉੱਤੇ skip ਹੌਲੀ ਹੈ — range-based pagination ਦੀ ਵਰਤੋਂ ਕਰੋ

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

## Sorting ਅਤੇ 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.
```

## ਇਸ ਦਾ ਕੀ ਮਤਲਬ ਹੈ

Sorting ਅਤੇ pagination MongoDB ਵਿੱਚ **ਦੇਟਾ ਨੂੰ ਉਪਯੋਗੀ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ** ਲਈ ਬੁਨਿਆਦੀ ਹਨ — ਨਤੀਜਿਆਂ ਦਾ ਕ੍ਰਮ ਬਣਾਉਣਾ ਅਤੇ ਪ੍ਰਬੰਧਨਯੋਗ ਪੰਨੇ ਵਾਪਸ ਕਰਨਾ ਲਗਭਗ ਸਰਵ-ਮਾਨਯ ਜ਼ਰੂਰੀ ਹਾਂ (ਕਿਸੇ ਵੀ ਸੂਚੀ, ਫੀਡ, ਜਾਂ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਸਾਰਣੀ), ਇਸ ਲਈ ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਰੋਜ਼ਮਰ੍ਹਾ ਗਿਆਨ ਹੈ।

`sort` ਨੂੰ ਜਾਣਨਾ (fields ਨਾਲ `1`/`-1` ਨਾਲ ਕ੍ਰਮ ਬਣਾਉਣਾ, tie-breaking ਦੇ ਨਾਲ) ਅਤੇ `limit`/`skip` (ਦੇਟਾ ਦੇ ਪੰਨਿਆਂ ਲਈ **offset pagination** — ਬੇਨਤੀ ਨਤੀਜਿਆਂ ਨੂੰ ਪ੍ਰਸਤੁਤ ਕਰਨ ਲਈ ਆਮ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ।

ਦੋ ਵਿਹਾਰਕ ਨੁਕਤੇ ਖਾਸ ਤੌਰ ਤੇ ਮਹੱਤਵਪੂਰਨ ਹਨ: **ਹਮੇਸ਼ਾ ਪੰਨਾ-ਦਰ-ਪੰਨਾ ਕਰਦੇ ਸਮੇਂ ਛਾਂਟੋ** (ਬਿਨਾ, ਦਸਤਾਵੇਜ਼ ਦਾ ਕ੍ਰਮ ਨਿਸ਼ਚਿਤ ਨਹੀਂ, ਜਿਸ ਨਾਲ ਅਸਮਰੱਪ ਪੰਨੇ ਜੋ ਓਵਰਲੈਪ ਜਾਂ ਦਸਤਾਵੇਜ਼ ਛੱਡਦੇ ਹਨ — ਇੱਕ ਵਾਸਤਵਿਕ ਬਗ, SQL ਵਿੱਚ ਉਹੀ ਮੁੱਦਾ), ਅਤੇ ਸਮਝਣਾ ਕਿ **`skip` ਡੂੰਘੇ ਪੰਨਿਆਂ ਤੇ ਹੌਲਾ ਹੈ** (ਇਸ ਨੂੰ ਸਕੈਨ ਅਤੇ ਸਾਰੇ ਪਿਛਲੇ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਛੱਡਣਾ ਚਾਹੀਦਾ ਹੈ) — ਇਸ ਲਈ **range-based (cursor) pagination** (ਆਖਰੀ ਦੇਖਿਆ `_id` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਗਲਾ ਪੰਨਾ ਲਿਆ ਜਾਂਦਾ ਹੈ, ਬਿਨਾ ਛੱਡੇ ਸੂਚਕਾਂ ਦਾ ਫਾਇਦਾ) ਵੱਡੇ ਡੇਟਾ ਸੈਟਾਂ ਲਈ ਬਹੁਤ ਵੱਧ ਸਮਰਥ ਹੈ, ਇੱਕ ਮੁੱਲਵਾਨ ਕਾਰਜ ਕਾਰਕਰਦਗੀ ਤਕਨੀਕ।

ਜਾਣਨਾ ਕਿ **ਸੂਚਕ ਖੇਤਰਾਂ ਉੱਤੇ ਛਾਂਟਾ ਕੁਸ਼ਲ ਹੈ** ਜਦੋਂ ਕਿ ਵੱਡਾ ਬਿਨਾ-ਸੂਚਕ sorts ਹੌਲਾ ਜਾਂ ਅਸਫਲ ਹੋ ਸਕਦੇ ਹਨ (ਮੈਮੋਰੀ-ਵਿੱਚ sort ਸੀਮਾਵਾਂ) ਪਨਿਹਾ ਮਹੱਤਵਪੂਰਨ ਹੈ — ਸੂਚਕ ਖੇਤਰ ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਛਾਂਟਦੇ ਹੋ।

ਕਿਉਂਕਿ sorting ਅਤੇ pagination ਲਗਭਗ ਕਿਸੇ ਵੀ ਡੇਟਾ ਡਿਸਪਲੇ ਲਈ ਲਾਜ਼ਮੀ ਹਨ, ਅਤੇ ਕਿਉਂਕਿ ਇਕਸਾਰਤਾ ਦੀ ਮੁਲਾਜ਼ਮਤ (pagination ਲਈ stable sort) ਅਤੇ ਕਾਰਕਰਦਗੀ ਵਿਚਾਰ (skip vs range-based pagination, indexed sorts) ਸਿੱਧੇ ਸਹੀਤਾ ਅਤੇ ਗਤੀ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ, MongoDB sorting ਅਤੇ pagination ਨੂੰ ਸਮਝਣਾ — `sort`, offset pagination skip/limit ਨਾਲ, stable-sort ਲਾਜ਼ਮਤ, ਕੁਸ਼ਲ range-based ਵਿਕਲਪ, ਅਤੇ sort ਖੇਤਰਾਂ ਨੂੰ ਸੂਚਕ ਕਰਨਾ — ਜ਼ਰੂਰੀ, ਅਕਸਰ-ਲਾਗੂ ਗਿਆਨ ਹੈ MongoDB ਡੇਟਾ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਅਤੇ ਸਮਰੱਥ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਸਤੁਤ ਕਰਨ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਲਈ।