คุณแก้ปัญหา N+1 queries และปรับแต่ง Eloquent อย่างไร?

Question

Accepted Answer

**ปัญหา N+1 query** ซึ่งการเข้าถึง relationship ใน loop กระตุ้นให้เกิด query แยกต่อหนึ่งเรคคอร์ด เป็นปัญหาด้านประสิทธิภาพของ Eloquent ที่พบบ่อยที่สุด **Eager loading** ด้วย `with()` เป็นวิธีแก้หลัก ควบคู่ไปกับการปรับแต่งอื่น ๆ (การเลือกคอลัมน์ การ chunking การทำ indexing)

## ปัญหา N+1 และวิธีแก้

```php
// ❌ N+1: 1 query for posts + 1 query PER post to load its author
$posts = Post::all();                         // 1 query
foreach ($posts as $post) {
    echo $post->author->name;                  // +1 query EACH → 100 posts = 101 queries!
}

// ✅ eager load with with() → 2 queries total (posts + all authors)
$posts = Post::with('author')->get();
foreach ($posts as $post) {
    echo $post->author->name;                  // no extra queries — authors prefetched
}
```

**`with()`** ทำการ eager-load relationship ล่วงหน้า (เพิ่ม query หนึ่งครั้งต่อ relationship แทนที่จะเป็นหนึ่งครั้งต่อเรคคอร์ด) เปลี่ยน 101 queries ให้เหลือ 2 ซึ่งเป็นการปรับปรุงที่ชัดเจนมาก นี่คือการปรับแต่ง Eloquent ที่จำเป็นที่สุด

## รูปแบบต่าง ๆ ของ eager loading

```php
Post::with(['author', 'comments'])->get();        // multiple relationships
Post::with('comments.user')->get();                // nested
Post::with(['comments' => fn($q) => $q->latest()])->get();   // constrained
User::withCount('posts')->get();                   // count without loading (post_count)
```

## การจับ N+1 โดยอัตโนมัติ

```php
// in development, make lazy loading THROW so you catch N+1 problems early
Model::preventLazyLoading();    // in a service provider (dev)
// or use Laravel Debugbar / Telescope to see query counts per request
```

เครื่องมืออย่าง **Debugbar/Telescope** แสดงจำนวน query ต่อหน้า (มองเห็น N+1 ได้ชัดเจน) และ `preventLazyLoading()` เปลี่ยนการ lazy load โดยไม่ตั้งใจให้กลายเป็น error ระหว่างการพัฒนา

## การปรับแต่ง Eloquent อื่น ๆ

```php
User::select('id', 'name')->get();             // fetch only needed columns
User::chunk(1000, fn($users) => ...);           // process huge sets in batches (memory)
User::cursor();                                  // lazy iteration — constant memory
// + add database INDEXES on filtered/joined columns (the biggest DB-level win)
// + use the query builder / database aggregation instead of PHP loops over collections
```

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

การแก้ปัญหา N+1 queries และการปรับแต่ง Eloquent เป็นความรู้ด้านประสิทธิภาพที่สำคัญยิ่งสำหรับแอปพลิเคชัน Laravel เพราะ **ปัญหา N+1 query เป็นปัญหาด้านประสิทธิภาพที่พบบ่อยและส่งผลกระทบมากที่สุด** ใน Laravel และการเข้าใจวิธีป้องกันมันเป็นสิ่งจำเป็น

ปัญหานี้แอบแฝงเพราะการเข้าถึง relationship ที่สะดวกของ Eloquent (`$post->author`) กระตุ้น query ฐานข้อมูลทุกครั้งอย่างเงียบ ๆ ดังนั้นโค้ดที่ทำงานได้ดีเมื่อมีข้อมูลน้อยจะเสื่อมลงอย่างหายนะเมื่อข้อมูลเติบโต (100 เรคคอร์ดกลายเป็น 101 queries) และมักถูกค้นพบใน production ภายใต้ภาระงานเท่านั้น **Eager loading ด้วย `with()`** เป็นวิธีแก้ที่จำเป็น โหลด relationship ล่วงหน้าในไม่กี่ query แทนที่จะเป็นหนึ่งต่อเรคคอร์ด และการรู้รูปแบบต่าง ๆ ของมัน (multiple, nested, constrained eager loads, `withCount`) ครอบคลุมความต้องการทั่วไป

ที่มีค่าพอ ๆ กันคือการรู้วิธี **จับปัญหา N+1** (Debugbar/Telescope เพื่อดูจำนวน query, `preventLazyLoading()` เพื่อเปลี่ยนการ lazy load โดยไม่ตั้งใจให้เป็น error ระหว่างการพัฒนา) เพื่อให้คุณพบมันก่อนขึ้น production

นอกเหนือจาก N+1 แล้ว การปรับแต่งอื่น ๆ เช่นการเลือกเฉพาะคอลัมน์ที่ต้องการ **chunking/cursors** สำหรับการประมวลผลชุดข้อมูลขนาดใหญ่โดยไม่ทำให้หน่วยความจำหมด การ aggregate ที่ฐานข้อมูลแทนการประมวลผล collection ฝั่ง PHP และที่สำคัญคือการ **indexing** คอลัมน์ที่ใช้ filter/join (มักเป็นชัยชนะที่ใหญ่ที่สุดในระดับฐานข้อมูล) ช่วยทำให้ชุดเครื่องมือสมบูรณ์

การเข้าใจสิ่งเหล่านี้ โดยเฉพาะการจดจำและแก้ N+1 ด้วย eager loading เป็นความรู้ระดับ senior ที่สำคัญ ซึ่งแยกแยะนักพัฒนาที่เขียนแอปพลิเคชัน Laravel ที่มีประสิทธิภาพออกจากผู้ที่แอปช้าลงจนคืบคลานเมื่อข้อมูลเติบโต ทำให้มันเป็นหัวข้อที่เกี่ยวข้องบ่อยและมีคุณค่าสูงสำหรับการสร้างแอปพลิเคชันที่ขยายขนาดได้