როგორ მუშაობს დახარისხება და გვერდებად დაყოფა 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` იღებს ველის:მიმართულების დოკუმენტს (`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 გვერდებად დაყოფას** (გვერდი 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 ნელი არის ღრმა გვერდებზე — გამოიყენეთ დიაპაზონზე დაფუძნებული გვერდებად დაყოფა

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

## დახარისხება და ინდექსები

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

## რატომ აქვს მნიშვნელობა

დახარისხება და გვერდებად დაყოფა ფუნდამენტური ხელსაწყოები არიან **მონაცემების სასარგებლოდ ჩვენებისთვის** MongoDB-ში — შედეგების დაჯერებულობა და მართვადი გვერდების დაბრუნება თითქმის უნივერსალური საჭიროებებია (ნებისმიერი სია, ჩამონათვალი ან ცხრილი აპლიკაციაში), ამიტომ მათი გაგება აუცილებელია დღე-დღეების ცოდნისთვის.

`sort`-ის ცოდნა (ველებით დაჯერებულობა `1`/`-1`-ით, დაკავშირებული ჩანაწერებით) და `limit`/`skip` (for **offset გვერდებად დაყოფა** — მონაცემების გვერდების დაბრუნება) ფარავს საერთო საჭიროებებს მოთხოვნის შედეგების ჩვენებისთვის.

ორი პრაქტიკული პუნქტი განსაკუთრებით მნიშვნელოვანია: **ყოველთვის დაჯერეთ გვერდებად დაყოფის დროს** (მის გარეშე, დოკუმენტის წესრიგი გარანტირებული არ არის, რაც იწვევს არათანმიმდევრულ გვერდებს, რომლებიც ერთმანეთს ემთხვევა ან გამოტოვებენ დოკუმენტებს — რეალური შეცდომა, იგივე პრობლემა SQL-ში), და გაგება, რომ **`skip` ნელი არის ღრმა გვერდებზე** (ის უნდა შეამოწმოს და გამოტოვოს ყველა წინა დოკუმენტი) — ამიტომ **დიაპაზონზე დაფუძნებული (კურსორი) გვერდებად დაყოფა** (ბოლო ხილული `_id` გამოყენება შემდეგი გვერდის მისაღებად, ინდექსის გამოყენება გამოტოვების გარეშე) გораც მეტად ეფექტური არის დიდი მონაცემთა ბაზებისთვის, ღირებული წარმადობის ტექნიკა.

ცოდნა, რომ **ინდექსირებულ ველებზე დახარისხება ეფექტური არის**, ხოლო დიდი ინდექსირებული დახარისხება შეიძლება იყოს ნელი ან არაუმტკივარი (მეხსიერების მახასიათებლები) ასევე მნიშვნელოვანია — ინდექსირეთ ველები, რომლებიც დახარისხებთ.

მას შემდეგ, რაც დახარისხება და გვერდებად დაყოფა საჭირო არეს პრაქტიკულად ნებისმიერი მონაცემთა ჩვენებისთვის, და რადგან თანმიმდევრობის მოთხოვნელობა (დაჯერებული გვერდებად დაყოფის დახარისხება) და წარმადობის საზომი (skip vs დიაპაზონზე დაფუძნებული გვერდებად დაყოფა, ინდექსირებული დახარისხებები) პირდაპირ გავლენას ახდენს სისწორითა და სიჩქარეზე, MongoDB დახარისხების და გვერდებად დაყოფის გაგება — `sort`, offset გვერდებად დაყოფა skip/limit-ით, სტაბილური დახარისხების მოთხოვნელობა, ეფექტური დიაპაზონზე დაფუძნებული ალტერნატივა, და დახარისხების ველების ინდექსირება — აუცილებელი, ხშირად გამოყენებული ცოდნა MongoDB მონაცემების ეფექტური და მიზანსწული პრეზენტაციის ჩვენებაზე.