Kako popraviti N+1 upite i optimizirati Eloquent?

Question

Accepted Answer

**N+1 problem s upitima** — gdje pristup relacijama u petlji sprema zaseban upit po zapisu — je najčešće pitanje performansi u Eloquentu. **Eager loading** s `with()` je primarni popravak, zajedno s ostalim optimizacijama (izbor stupaca, chunking, indeksiranje).

## Problem N+1 i njegovo rješenje

```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-loadira relacije unaprijed (jedan dodatni upit po relaciji umjesto jednog po zapisu), pretvarajući 101 upit u 2 — dramatično poboljšanje. Ovo je bitna optimizacija u Eloquentu.

## Varijacije eager loadinga

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

## Automatsko hvatanje 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
```

Alati kao **Debugbar/Telescope** prikazuju broj upita po stranici (vizualno uočite N+1), a `preventLazyLoading()` pretvara slučajne lazy loadove u greške tijekom razvoja.

## Ostale optimizacije Eloquenta

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

## Zašto je važno

Popravka N+1 upita i optimizacija Eloquenta kritično je znanje o performansama za Laravel aplikacije — **N+1 problem s upitima je jednom čest i najutjecajniji problem performansi** u Laravelu, a razumijevanje kako ga spriječiti je bitno.

Problem je podmukliji jer je pristup relacijama Eloquenta prikladan (`$post->author`) tiho pokreće bazu podataka upit svaki put, tako da kod koji dobro radi s malim podacima pada katastrofalno kako podaci rastu (100 zapisa postaje 101 upit), često otkriveno tek u produkciji pod opterećenjem. **Eager loading s `with()`** je bitna popravka — učitavanje relacija unaprijed u par upita umjesto jednog po zapisu — i poznavanjeovih varijacija (više, ugniježđene, uvjetovane eager loadove, `withCount`) pokriva česte potrebe.

Jednako vrijedna je sposobnost **hvatanja N+1 problema** (Debugbar/Telescope za pregled brojeva upita, `preventLazyLoading()` za pretvaranje slučajnih lazy loadova u greške tijekom razvoja), tako da ih pronađete prije produkcije.

Osim N+1, ostale optimizacije — izbor samo potrebnih stupaca, **chunking/cursors** za obradu velikih skupova podataka bez iscrpljenja memorije, agregacija u bazi podataka umjesto obrade na PHP strani, i kritično **indeksiranje** filtriranih/spojenih stupaca (često najveći dobitak na razini baze podataka) — zaokružuju toolkit.

Razumijevanje ovih — osobito prepoznavanje i popravka N+1 s eager loadingom — je važno znanje na razini seniora koje razlikuje programere koji pišu performantne Laravel aplikacije od onih čije aplikacije usporavaju kako podaci rastu, što ga čini često relevantnom temom visoke vrijednosti za izgradnju aplikacija koje se skaliraju.