Problemă N+1 query — unde accesarea relațiilor într-o buclă declanșează o interogare separată per înregistrare — este cea mai comună problemă de performanță în Eloquent. Eager loading cu with() este soluția primară, alături de alte optimizări (selectarea coloanelor, chunking, indexing).
= ::();
( ) {
->author->name;
}
= ::()->();
( ) {
->author->name;
}
with() încarcă relațiile din start (o interogare suplimentară per relație în loc de una per înregistrare), transformând 101 interogări în 2 — o îmbunătățire dramatică. Aceasta este optimizarea esențială în Eloquent.
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)
// 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
Instrumente precum Debugbar/Telescope arată contul query-urilor per pagină (observă N+1 vizual), iar preventLazyLoading() transformă lazy load-urile accidentale în erori în timpul dezvoltării.
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
Rezolvarea problemelor N+1 query și optimizarea Eloquent sunt cunoștințe critice de performanță pentru aplicațiile Laravel — problema N+1 query este cea mai comună și impactantă problemă de performanță în Laravel, iar înțelegerea modului de a o preveni este esențială.
Problema este vicleanã deoarece accesul convenabil al Eloquent la relații ($post->author) declanșează tăcut o interogare de bază de date de fiecare dată, așa că codul care funcționează bine cu puține date se degradează catastrofal pe măsură ce datele cresc (100 de înregistrări devenind 101 interogări), adesea descoperit doar în producție sub sarcină. Eager loading cu with() este soluția esențială — încărcarea relațiilor din start în câteva interogări în loc de una per înregistrare — și cunoașterea variațiilor sale (multiple, imbricate, eager load-uri constrânse, withCount) acoperă nevoile comune.
La fel de valoroasă este cunoașterea modului de detectare a problemelor N+1 (Debugbar/Telescope pentru a vedea contul query-urilor, preventLazyLoading() pentru a transforma lazy load-urile accidentale în erori în dezvoltare), astfel încât le găsești înainte de producție.
Dincolo de N+1, alte optimizări — selectarea doar a coloanelor necesare, chunking/cursors pentru prelucrarea seturilor mari de date fără epuizarea memoriei, agregare pe bază de date peste procesarea pe partea PHP a colecțiilor, și critic indexing pe coloane filtrate/unite (adesea cel mai mare câștig la nivel de bază de date) — completează setul de instrumente.
Înțelegerea acestora — în special recunoașterea și rezolvarea N+1 cu eager loading — este cunoaștere importantă la nivel senior care diferențiază dezvoltatorii care scriu aplicații Laravel performante de cei ale căror aplicații încetinesc pe măsură ce datele cresc, ceea ce o face un subiect frecvent relevant și cu valoare mare pentru construirea aplicațiilor care se scalează.