Kaip ištaisyti N+1 užklausas ir optimizuoti Eloquent?

Question

Accepted Answer

**N+1 užklausų problema** — kai santykių prieiga cikle paleidžia atskirą užklausą kiekvienam įrašui — yra dažniausias Eloquent našumo klausimas. **Greitas ryšių įkėlimas** su `with()` yra pagrindinis sprendimas, kartu su kitomis optimizacijomis (stulpelių pasirinkimas, chunking, indeksavimas).

## N+1 problema ir jos sprendimas

```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()`** iš anksto įkelia ryšius (viena papildoma užklausa vienam ryšiui vietoj vienos per įrašą), pavertę 101 užklausą į 2 — dramatiškas pagerinimas. Tai yra esminė Eloquent optimizacija.

## Greto ryšių įkėlimo variacijos

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

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

Tokiai padarai kaip **Debugbar/Telescope** rodo užklausų skaičių per puslapį (vizualiai numatykite N+1), o `preventLazyLoading()` netyčinį lėtą įkėlimą paverčia klaidomis vykdant kūrimą.

## Kitos Eloquent optimizacijos

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

## Kodėl tai svarbu

N+1 užklausų ištaisymas ir Eloquent optimizacija yra kritinis našumo žinojimas Laravel programoms — **N+1 užklausų problema yra vienintelė dažniausia ir didžiausia našumo problema Laravel**, o jos prevencijos supratimas yra būtinas.

Problema yra pačius, nes Eloquent patogusis santykių prieiga (`$post->author`) tyliai paleidžia duomenų bazės užklausą kiekvieną kartą, todėl kodas, kuris gerai veikia su nedaug duomenų, pasikeitimu žlugdo didėjant duomenims (100 įrašų tampant 101 užklausa), dažnai aptinkama tik produkcijoje esant apkrovai. **Gretas ryšių įkėlimas su `with()`** yra esminė taisomoji priemonė — ryšių įkėlimas iš anksto keliomis užklausomis vietoj vienos per įrašą — ir jo variacijų žinojimas (keletas, lizdas, apribojamos gretos, `withCount`) padengti bendrus poreikius.

Eigal svarbu žinoti, kaip **aptikti N+1 problemas** (Debugbar/Telescope, kad pamatytumėte užklausų skaičius, `preventLazyLoading()`, kad tylias laziojo įkėlimo klaidą pavertumėte klaidomis kūrimo metu), kad jas rasite prieš produkciją.

Pagal N+1, kitos optimizacijos — pasirinkti tik reikalingus stulpelius, **chunking/cursors** dideliems duomenų rinkinių apdorojimui be atminties išeikvojimo, duomenų bazės agregavimas per PHP pusės rinkinio apdorojimą ir svarbiausia **indeksavimas** filtruotų/susijungtų stulpelių (dažnai didžiausias duomenų bazės lygio laimėjimas) — papildo įrankių rinkinį.

Supratimas šių — ypač N+1 atpažinimas ir taisymas su gretu — yra svarbus aukšto lygio žinojimas, kuris atskiria kūrėjus, kurie rašo našumo Laravelio programas, nuo tų, kurių programos sulėtėja didėjant duomenims, todėl tai yra dažnai aktualus, aukštos vertės dalykas kuriant programas, kurios keičiasi.