Bagaimana Anda memperbaiki kueri N+1 dan mengoptimalkan Eloquent?

Question

Accepted Answer

Masalah **kueri N+1** — di mana mengakses relasi dalam loop memicu kueri terpisah per record — adalah masalah performa Eloquent yang paling umum. **Eager loading** dengan `with()` adalah perbaikan utama, bersama dengan optimasi lain (memilih kolom, chunking, indexing).

## Masalah N+1 dan cara memperbaikinya

```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-loads relasi di awal (satu kueri tambahan per relasi bukan satu per record), mengubah 101 kueri menjadi 2 — peningkatan dramatis. Ini adalah optimasi Eloquent yang esensial.

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

## Menangkap N+1 secara otomatis

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

Alat seperti **Debugbar/Telescope** menampilkan jumlah kueri per halaman (lihat N+1 secara visual), dan `preventLazyLoading()` mengubah lazy load yang tidak disengaja menjadi error selama development.

## Optimasi Eloquent lainnya

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

## Mengapa ini penting

Memperbaiki kueri N+1 dan mengoptimalkan Eloquent adalah pengetahuan performa kritis untuk aplikasi Laravel — **masalah kueri N+1 adalah masalah performa tunggal yang paling umum dan berdampak** di Laravel, dan memahami cara mencegahnya adalah esensial.

Masalahnya insidious karena akses relasi yang nyaman di Eloquent (`$post->author`) secara senyap memicu kueri database setiap kali, jadi kode yang berfungsi baik dengan sedikit data menurun secara katastrofal saat data bertumbuh (100 record menjadi 101 kueri), sering hanya ditemukan di production saat load tinggi. **Eager loading dengan `with()`** adalah perbaikan esensial — memuat relasi di awal dalam beberapa kueri bukan satu per record — dan mengetahui variasiasinya (multiple, nested, constrained eager loads, `withCount`) mencakup kebutuhan umum.

Sama berharganya adalah mengetahui cara **menangkap masalah N+1** (Debugbar/Telescope untuk melihat jumlah kueri, `preventLazyLoading()` untuk mengubah lazy load yang tidak disengaja menjadi error dalam development), jadi Anda menemukannya sebelum production.

Di luar N+1, optimasi lain — memilih hanya kolom yang diperlukan, **chunking/cursors** untuk memproses dataset besar tanpa menghabiskan memori, agregasi database atas pemrosesan sisi PHP, dan penting **indexing** kolom yang difilter/di-join (sering kali keuntungan database level terbesar) — melengkapi toolkit.

Memahami ini — terutama mengenali dan memperbaiki N+1 dengan eager loading — adalah pengetahuan level senior yang membedakan developer yang menulis aplikasi Laravel performan dari mereka yang aplikasinya melambat saat data bertumbuh, menjadikannya topik yang sering relevan dan bernilai tinggi untuk membangun aplikasi yang scalable.