Hogyan javítasz meg N+1 lekérdezéseket és optimalizálsz Eloquent-et?

Question

Accepted Answer

Az **N+1 lekérdezési probléma** — amikor egy hurok során az kapcsolatok eléréséhez külön lekérdezés szükséges minden rekordnál — az Eloquent leggyakoribb teljesítménybeli problémája. Az **eager loading** a `with()` függvénnyel az elsődleges megoldás, egyéb optimalizálásokkal kombinálva (oszlopok kiválasztása, chunking, indexelés).

## Az N+1 probléma és annak megoldása

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

A **`with()`** előre betölti a kapcsolatokat (egy extra lekérdezés kapcsolatonként az egy helyett rekordonként), 101 lekérdezésből 2-re csökkentve — drámai javulás. Ez az alapvető Eloquent optimalizálás.

## Eager loading változatai

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

## N+1 automatikus felismerése

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

Az olyan eszközök, mint a **Debugbar/Telescope**, oldalonként megmutatják a lekérdezések számát (N+1 vizuálisan felismerhető), és a `preventLazyLoading()` a véletlen lusta betöltéseket fejlesztés közben hibákká alakítja.

## Egyéb Eloquent optimalizálások

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

## Miért fontos

Az N+1 lekérdezések kijavítása és az Eloquent optimalizálása kritikus teljesítménybeli ismeret Laravel alkalmazásoknál — az **N+1 lekérdezési probléma az egyetlen leggyakoribb és legbefolyásolóbb teljesítménybeli probléma** Laravel-ben, és annak megakadályozásának megértése elengedhetetlen.

A probléma tünetmentes, mert az Eloquent kényelmes kapcsolat-hozzáférése (`$post->author`) csendesen aktivál egy adatbázis-lekérdezést minden alkalommal, így az apró adatok mellett működő kód drasztikusan romlottal nagy mennyiségű adatok esetén (100 rekord 101 lekérdezésből), gyakran csak éles környezetben, nagy terhelés alatt felfedezve. Az **eager loading a `with()` függvénnyel** az alapvető megoldás — a kapcsolatok előre betöltése néhány lekérdezésben az egy helyett rekordonként — és annak ismeret (többszörös, beágyazott, megkötött eager loadok, `withCount`) a gyakori igényeket pokriva.

Egyformán értékes az **N+1 problémák felismerésének** ismerete (Debugbar/Telescope a lekérdezések számának megtekintéséhez, `preventLazyLoading()` a véletlen lusta betöltéseket hibákká alakítja fejlesztés során), így megtalálhatod őket az éles környezet előtt.

Az N+1-en túl más optimalizálások — csak szükséges oszlopok kiválasztása, **chunking/cursors** nagy adathalmazok feldolgozásához memória kimerítése nélkül, adatbázis-oldali aggregáció a PHP-oldali gyűjtemény feldolgozása helyett, és döntően **indexelés** szűrt/összekapcsolt oszlopokon (gyakran a legnagyobb adatbázis-szintű nyereség) — kerekítik ki az eszközkészletet.

Ezek megértése — különösen az N+1 felismerése és kijavítása eager loadinggal — fontos senior szintű ismeret, amely megkülönböztet teljesítményes Laravel alkalmazásokat írni tudó fejlesztőket azoktól, akiknek az alkalmazásai lelassulnak az adatok növekedésével, ezért ez egy gyakran releváns, magas értékű téma, amely skálázható alkalmazások építéséhez szükséges.