Bạn sửa truy vấn N+1 và tối ưu hóa Eloquent như thế nào?

Question

Accepted Answer

**Vấn đề N+1 query** — khi truy cập relationship trong một vòng lặp kích hoạt một truy vấn riêng cho mỗi bản ghi — là vấn đề hiệu năng Eloquent phổ biến nhất. **Eager loading** với `with()` là cách sửa chính, cùng với các tối ưu khác (chọn cột, chunking, indexing).

## Vấn đề N+1 và cách sửa

```php
// ❌ N+1: 1 truy vấn cho các post + 1 truy vấn MỖI post để load author của nó
$posts = Post::all();                         // 1 truy vấn
foreach ($posts as $post) {
    echo $post->author->name;                  // +1 truy vấn MỖI cái → 100 post = 101 truy vấn!
}

// ✅ eager load với with() → tổng 2 truy vấn (post + tất cả author)
$posts = Post::with('author')->get();
foreach ($posts as $post) {
    echo $post->author->name;                  // không truy vấn thêm — author đã được prefetch
}
```

**`with()`** eager-load các relationship trước (một truy vấn thêm cho mỗi relationship thay vì một cho mỗi bản ghi), biến 101 truy vấn thành 2 — một cải thiện đáng kể. Đây là tối ưu Eloquent thiết yếu.

## Các biến thể eager loading

```php
Post::with(['author', 'comments'])->get();        // nhiều relationship
Post::with('comments.user')->get();                // lồng nhau
Post::with(['comments' => fn($q) => $q->latest()])->get();   // có ràng buộc
User::withCount('posts')->get();                   // đếm không load (post_count)
```

## Bắt N+1 tự động

```php
// trong development, khiến lazy loading NÉM lỗi để bạn bắt vấn đề N+1 sớm
Model::preventLazyLoading();    // trong một service provider (dev)
// hoặc dùng Laravel Debugbar / Telescope để xem số truy vấn mỗi request
```

Các công cụ như **Debugbar/Telescope** hiển thị số truy vấn mỗi trang (phát hiện N+1 trực quan), và `preventLazyLoading()` biến các lazy load vô tình thành lỗi trong development.

## Các tối ưu Eloquent khác

```php
User::select('id', 'name')->get();             // chỉ lấy các cột cần thiết
User::chunk(1000, fn($users) => ...);           // xử lý tập rất lớn theo batch (bộ nhớ)
User::cursor();                                  // lặp lazy — bộ nhớ hằng số
// + thêm INDEX database trên các cột được lọc/join (lợi ích lớn nhất cấp DB)
// + dùng query builder / aggregation database thay vì vòng lặp PHP trên collection
```

## Tại sao điều này quan trọng

Sửa truy vấn N+1 và tối ưu hóa Eloquent là kiến thức hiệu năng then chốt cho các ứng dụng Laravel — **vấn đề N+1 query là vấn đề hiệu năng phổ biến và có tác động nhất** trong Laravel, và hiểu cách ngăn nó là thiết yếu.

Vấn đề này âm thầm vì truy cập relationship tiện lợi của Eloquent (`$post->author`) lặng lẽ kích hoạt một truy vấn database mỗi lần, nên code hoạt động tốt với ít dữ liệu suy thoái thảm họa khi dữ liệu tăng (100 bản ghi thành 101 truy vấn), thường chỉ phát hiện trong production dưới tải. **Eager loading với `with()`** là cách sửa thiết yếu — load các relationship trước trong vài truy vấn thay vì một cho mỗi bản ghi — và biết các biến thể của nó (eager load nhiều, lồng nhau, có ràng buộc, `withCount`) bao phủ các nhu cầu phổ biến.

Quan trọng không kém là biết cách **bắt vấn đề N+1** (Debugbar/Telescope để xem số truy vấn, `preventLazyLoading()` để biến các lazy load vô tình thành lỗi trong development), nên bạn tìm thấy chúng trước production.

Ngoài N+1, các tối ưu khác — chỉ chọn các cột cần thiết, **chunking/cursor** để xử lý các tập dữ liệu lớn mà không cạn bộ nhớ, aggregation database thay vì xử lý collection phía PHP, và quan trọng là **indexing** các cột được lọc/join (thường là lợi ích lớn nhất cấp database) — hoàn thiện bộ công cụ.

Hiểu những điều này — đặc biệt là nhận ra và sửa N+1 với eager loading — là kiến thức cấp senior quan trọng phân biệt các lập trình viên viết các ứng dụng Laravel hiệu năng cao với những người mà app chậm lại như rùa bò khi dữ liệu tăng, khiến nó là một chủ đề thường xuyên liên quan, giá trị cao để xây dựng các ứng dụng có khả năng mở rộng.