การ sort และ pagination ทำงานอย่างไรใน MongoDB?

Question

Accepted Answer

MongoDB เรียงลำดับผลลัพธ์ query ด้วย **`sort`** และทำ pagination ด้วย **`limit`** และ **`skip`** ซึ่ง chain บน cursor ของ `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` รับ document แบบ field:direction (`1` จากน้อยไปมาก, `-1` จากมากไปน้อย) หลาย field ใช้สำหรับการตัดสินเมื่อค่าเท่ากัน

## limit และ skip — pagination

```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)` คืน document ไม่เกิน n รายการ `skip(m)` ข้าม m รายการแรก ทั้งสองอย่างรวมกันใช้ทำ **offset pagination** (หน้า N ผ่าน skip + limit)

## sort เสมอเมื่อทำ pagination

```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` ลำดับของ document ไม่ได้รับการรับประกัน ดังนั้นหน้าที่ถูก paginate อาจไม่สอดคล้องกัน จง sort ตาม field ที่เสถียร (เช่น `_id`) เสมอเมื่อทำ pagination

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

## การ sort และ index

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

## ทำไมจึงสำคัญ

การ sort และ pagination เป็นพื้นฐานสำหรับการ **แสดงข้อมูลอย่างมีประโยชน์** ใน MongoDB การเรียงลำดับผลลัพธ์และการคืนหน้าข้อมูลที่จัดการได้เป็นความต้องการที่แทบจะเป็นสากล (รายการ ฟีด หรือตารางใด ๆ ในแอปพลิเคชัน) ดังนั้นการเข้าใจสิ่งเหล่านี้จึงเป็นความรู้พื้นฐานที่ใช้ในชีวิตประจำวันอย่างจำเป็น

การรู้ `sort` (การเรียงลำดับตาม field ด้วย `1`/`-1` พร้อมการตัดสินเมื่อค่าเท่ากัน) และ `limit`/`skip` (สำหรับ **offset pagination** การคืนหน้าข้อมูล) ครอบคลุมความต้องการที่พบบ่อยในการแสดงผลลัพธ์ query

จุดในทางปฏิบัติสองจุดมีความสำคัญเป็นพิเศษ คือ **sort เสมอเมื่อทำ pagination** (หากไม่มี ลำดับของ document ไม่ได้รับการรับประกัน ทำให้หน้าไม่สอดคล้องกันที่ทับซ้อนหรือข้าม document ซึ่งเป็น bug จริง เป็นปัญหาเดียวกับใน SQL) และการเข้าใจว่า **`skip` ช้าในหน้าที่ลึก** (มันต้อง scan และข้าม document ก่อนหน้าทั้งหมด) ดังนั้น **range-based (cursor) pagination** (ใช้ `_id` ที่เห็นล่าสุดเพื่อดึงหน้าถัดไป โดยใช้ index โดยไม่ต้อง skip) จึงมีประสิทธิภาพมากกว่ามากสำหรับชุดข้อมูลขนาดใหญ่ ซึ่งเป็นเทคนิคด้านประสิทธิภาพที่มีคุณค่า

การรู้ว่า **การ sort บน field ที่มี index มีประสิทธิภาพ** ในขณะที่การ sort ชุดข้อมูลขนาดใหญ่ที่ไม่มี index อาจช้าหรือล้มเหลว (ข้อจำกัดของ in-memory sort) ก็สำคัญเช่นกัน จง index field ที่คุณ sort

เนื่องจากการ sort และ pagination จำเป็นสำหรับการแสดงข้อมูลแทบทุกประเภท และเนื่องจากข้อกำหนดความสอดคล้อง (sort เพื่อ pagination ที่เสถียร) และข้อควรพิจารณาด้านประสิทธิภาพ (skip เทียบกับ range-based pagination, indexed sort) ส่งผลโดยตรงต่อความถูกต้องและความเร็ว การเข้าใจการ sort และ pagination ของ MongoDB ทั้ง `sort`, offset pagination ด้วย skip/limit, ข้อกำหนด stable-sort, ทางเลือก range-based ที่มีประสิทธิภาพ และการ index field ที่ sort จึงเป็นความรู้ที่จำเป็นและใช้บ่อยสำหรับการสร้างแอปพลิเคชันที่แสดงข้อมูล MongoDB อย่างมีประสิทธิภาพและรวดเร็ว