The N+1 query problem — where accessing relationships in a loop triggers a separate query per record — is the most common Eloquent performance issue. Eager loading with with() is the primary fix, alongside other optimizations (selecting columns, chunking, indexing).
= ::();
( ) {
->author->name;
}
= ::()->();
( ) {
->author->name;
}
with() eager-loads relationships up front (one extra query per relationship instead of one per record), turning 101 queries into 2 — a dramatic improvement. This is the essential Eloquent optimization.
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
Tools like Debugbar/Telescope show query counts per page (spot N+1 visually), and preventLazyLoading() turns accidental lazy loads into errors during development.
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
N+1 შეკითხვების ამოღება და Eloquent-ის ოპტიმიზაცია არის კრიტიკული performance ცოდნა Laravel აპლიკაციებისთვის — N+1 query პრობლემა არის ერთადერთი ყველაზე გავრცელებული და გავლენიანი performance საკითხი Laravel-ში, და მისი თავიდან აცილება აუცილებელია.
პრობლემა მახალისი არის იმიტომ, რომ Eloquent-ის მოსახერხებელი relationship접근 ($post->author) ჩუმად აწყობს database შეკითხვას ყოველ ჯერზე, ასე რომ კოდი რომელიც კარგად მუშაობს მცირე მონაცემებთან, კატასტროფალურად დეგრადირებულ ხდება მონაცემების ზრდასთან (100 ჩანაწერი ხდება 101 შეკითხვა), ხშირად აღმოჩენილი მხოლოდ production-ში დატვირთვის ქვეშ. Eager loading with()-ით არის ეს არსებითი გასწორება — relationships-ის ჩატვირთვა წინასწარ რამდენიმე შეკითხვაში ერთის ნაცვლად ჩანაწერზე — და მისი ვარიაციების ცოდნა (რამდენიმე, nested, constrained eager loads, withCount) მოიცავს გავრცელებულ საჭიროებებს.
თანაბრად ღირებული არის იმ უნარი რომ დაჭიროთ N+1 პრობლემები (Debugbar/Telescope საჩვენებლად query counts გვერდზე, preventLazyLoading() რათა გადააქციოთ შემთხვევითი lazy loads შეცდომებად development-ში), ასე რომ მათ აკვეთეთ production-ის წინ.
N+1-ის გარდა, სხვა ოპტიმიზაციები — მხოლოდ საჭირო სვეტების არჩევა, chunking/cursors დიდი ნაკრებების დამუშავებისთვის memory-ის ამოწურვის გარეშე, database aggregation PHP-ს მხარის collection processing-ზე, და კრიტიკულად indexing filtered/joined სვეტებზე (ხშირად ყველაზე დიდი database-ის დონის გაზომვა) — დაასრულებთ toolkit-ს.
ამ ყველას გაგება — განსაკუთრებით N+1 ამოცნობა და გასწორება eager loading-ით — არის მნიშვნელოვანი senior-level ცოდნა რომელიც განასხვავებს developers-ს რომელიც წერენ performant Laravel აპლიკაციებს მათი აპლიკაციებიდან რომელიც ნელდება მონაცემების ზრდასთან, რაც ხდის მას ხშირად რელევანტურ, მაღალი ღირებულების თემას აპლიკაციების აშენებისთვის რომლებიც სკალირდება.