Jak opravíte N+1 dotazy a optimalizujete Eloquent?

Question

Accepted Answer

Problém **N+1 dotazů** — kdy přístup k relacím v cyklu spustí samostatný dotaz na záznam — je nejčastějším problémem výkonu Eloquentu. **Eager loading** s `with()` je primárním řešením, spolu s dalšími optimalizacemi (výběr sloupců, chunking, indexování).

## Problém N+1 a jeho řešení

```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-loaduje relace předem (jeden další dotaz na relaci místo jednoho na záznam), čímž změní 101 dotazů na 2 — dramatické zlepšení. Toto je základní optimalizace Eloquentu.

## Variace eager loadingu

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

## Automatické zachycení 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
```

Nástroje jako **Debugbar/Telescope** zobrazují počet dotazů na stránku (vizuálně odhalují N+1), a `preventLazyLoading()` změní náhodné lazy loading na chyby během vývoje.

## Další optimalizace Eloquentu

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

## Proč na tom záleží

Oprava N+1 dotazů a optimalizace Eloquentu je kritická znalost výkonu pro Laravel aplikace — **problém N+1 dotazů je jediný nejčastější a nejvlivnější problém výkonu v Laravelu** a pochopení způsobu jeho prevence je zásadní.

Problém je zákeřný, protože pohodlný přístup Eloquentu k relacím (`$post->author`) tiše spustí dotaz do databáze pokaždé, takže kód, který funguje dobře s malým množstvím dat, se katastrofálně zhoršuje jak data rostou (100 záznamů se stává 101 dotazů), často obnamuž až v produkci pod zatížením. **Eager loading s `with()`** je základní řešení — nahrání relací předem v několika dotazech místo jednoho na záznam — a znalost jeho variací (více, vnořených, omezených eager loads, `withCount`) pokryje běžné potřeby.

Stejně cenné je znát, jak **zachytit N+1 problémy** (Debugbar/Telescope vidět počty dotazů, `preventLazyLoading()` změní náhodné lazy loading na chyby ve vývoji), abyste je našli před produkcí.

Vzád N+1, další optimalizace — výběr pouze potřebných sloupců, **chunking/cursors** pro zpracování velkých datových sad bez vyčerpání paměti, agregace databází přes PHP-side kolekčnímu zpracování, a zásadně **indexování** filtrovaných/připojovaných sloupců (často největší výhra na úrovni databází) — doplní sadu nástrojů.

Pochopení těchto — zvláště rozpoznání a oprava N+1 s eager loadingem — je důležitou znalostí senior úrovně, která rozlišuje vývojáře, kteří píší výkonné Laravel aplikace, od těch, jejichž aplikace zpomalují jak data rostou, což z toho činí často relevantní, vysokohodnotné téma pro vytváření aplikací, které se škálují.