Eager loading in Eloquent reduces queries by preloading relationships upfront. Lazy loading causes the N 1 query problem, where looping through 100 users and accessing their profiles results in 101 queries. To fix this, use with() to eager load relationships like User::with('profile')->get(), which executes just two queries. You can load multiple relationships with User::with(['profile', 'posts'])->get(), or nested ones like User::with('posts.comments')->get(). Add constraints using closures such as filtering only published posts or sorting them by date. Avoid over-eager loading unnecessary data, as it wastes memory and performance. Only load what’s needed for the current request.

Eager loading in Eloquent is one of the most effective ways to reduce the number of queries executed when retrieving related models, especially when working with large datasets. The main idea is to load all needed relationships upfront instead of querying them on demand later.

Why Lazy Loading Can Be Costly

By default, Eloquent uses lazy loading for relationships. That means if you loop through a collection and access a relationship inside the loop, Eloquent will run a new query each time.

For example:

$users = User::all();

foreach ($users as $user) {
    echo $user->profile->bio;
}

If there are 100 users, this will result in 101 queries — one to get all users, and 100 more to fetch each user’s profile. This is commonly referred to as the "N 1 query problem."

That's where eager loading comes in handy.

How to Use with() for Eager Loading

The simplest and most common way to eager load relationships is by using the with() method when querying your model.

Example:

$users = User::with('profile')->get();

In this case, Eloquent will execute two queries: one for all users and another to get all related profiles. It then matches them efficiently in PHP, which is much faster than doing it per model.

You can also eager load multiple relationships at once:

$users = User::with(['profile', 'posts'])->get();

And even nested relationships:

$users = User::with('posts.comments')->get();

This tells Eloquent to also load comments for each post made by the user.

Tip: If you're not sure whether a relationship exists, use with() anyway. It still performs better than not using it when the data is present.

Conditional Eager Loading with Constraints

Sometimes you may want to eager load a relationship but only include certain results — like only active posts or recent comments.

You can add constraints to your eager loading by passing a closure:

$users = User::with(['posts' => function ($query) {
    $query->where('published', true);
}])->get();

This loads only published posts for each user.

Or sort the results:

$users = User::with(['posts' => function ($query) {
    $query->orderBy('created_at', 'desc');
}])->get();

You can even combine conditions and sorting:

• Filter posts that are published
• Sort them by date
• Limit to 5 most recent ones

However, note that limiting in eager loading isn’t directly supported in base Eloquent (you'd need a package or custom logic), so keep that in mind for advanced filtering.

Avoid Over-Eager Loading

While eager loading improves performance, don't fall into the trap of loading everything just in case.

Only eager load what you actually need for the current request or view. Loading unnecessary data increases memory usage and could slow things down too.

For example, if you're displaying a list of users without any profile or post data, there’s no reason to call:

User::with(['profile', 'posts', 'roles', 'comments'])->get();

It might seem safe, but it's wasteful.

Stick to what your page needs right now.

That's basically how eager loading works in Eloquent. It's not complicated, but it makes a huge difference when used correctly.

The above is the detailed content of How do I use eager loading to improve query performance in Eloquent?. For more information, please follow other related articles on the PHP Chinese website!