Piye carane ndandani N+1 queries lan ngoptimalke Eloquent?

Question

Accepted Answer

**Masalah N+1 query** — nalika ngakses relationships ing loop ngaktifake query pisah kanggo saben record — minangka masalah performance Eloquent sing paling umum. **Eager loading** nganggo `with()` minangka perbaikan utama, bebarengan karo optimisasi liya-liyane (milih kolom, chunking, indexing).

## Masalah N+1 lan ndandaniné

```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 relationships sadurunge (siji query tambahan kanggo saben relationship tinimbang siji kanggo saben record), ngowahi 101 queries dadi 2 — perbaikan sing dramatis. Iki minangka optimisasi Eloquent sing penting.

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

## Nanggkep N+1 kanthi 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
```

Tools kaya **Debugbar/Telescope** nampilake jumlah query saben halaman (nanggkep N+1 kanthi visual), lan `preventLazyLoading()` ngowahi lazy loads aksidental dadi errors sajroning pengembangan.

## Optimisasi Eloquent liya-liyane

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

## Kenapa iku penting

Ndandani N+1 queries lan ngoptimalke Eloquent minangka pengetahuan performance kritis kanggo aplikasi Laravel — **masalah N+1 query minangka siji-satuné masalah performance sing paling umum lan berdampak** ing Laravel, lan ngerti carane nyegah iku kudu.

Masalahe insidious amarga Eloquent pun relationship access (`$post->author`) mêmêndêm ngaktifake database query saben wektu, dadi kode sing bisa kanthi data sithik medhun drastis nalika data tuwuh (100 records dadi 101 queries), asring kapanggihake ning production ing beban. **Eager loading nganggo `with()`** minangka ndandani penting — muataken relationships sadurunge ing loro queries tinimbang siji kanggo saben record — lan ngerti variasi-variasine (kathah, bersarang, constrained eager loads, `withCount`) mutupi kabutuhan umum.

Saweweg penting iku ngerti carane **nanggkep masalah N+1** (Debugbar/Telescope kanggo ningali query counts, `preventLazyLoading()` kanggo ngowahi lazy loads aksidental dadi errors sajroning pengembangan), dadi sampeyan ketemu dhisik sadurunge production.
": jalanipun N+1, optimisasi liya-liyane — pilih mung kolom sing dibutuhake, **chunking/cursors** kanggo ngolah dataset besar tanpa ngabisin memori, aggregation database tinimbang PHP-side collection processing, lan penting banget **indexing** kolom filtered/joined (asring paling gedhe kuntul tingkat database) — lengkapi toolkit.

Ngerti iki — utamane ngenali lan ndandani N+1 nganggo eager loading — minangka pengetahuan tingkat senior penting sing mbedaake developers sing nulis aplikasi Laravel performant saking sing aplikasi-aplikasi mêmêndêm ngadeg nalika data tuwuh, ndadekake iku topik relevant asring, high-value kanggo ngbangun aplikasi sing scale.