Eager loading in Laravel Eloquent prevents the N 1 query problem by reducing database calls. 1. Use with() to load relationships upfront, e.g., User::with('role')->get() reduces queries from 101 to 2 for 100 users. 2. Load multiple or nested relationships using Book::with(['author', 'publisher'])->get() or Book::with('author.contacts')->get(). 3. Filter eager-loaded data with closures, like Post::with(['comments' => function ($query) { $query->where('active', true); }])->get(). 4. Select specific columns but include foreign keys, e.g., User::with(['profile' => function ($query) { $query->select('user_id', 'bio'); }])->get(). Avoid common mistakes: don’t overuse whereHas(), overload unused relationships, or use wildcards like with('*'). Use load() outside loops when needed, such as $user->load('roles').

When working with Laravel Eloquent, one of the most common performance issues you’ll run into is the N 1 query problem. That’s where your app ends up making way too many database calls—especially when looping through relationships. The good news? You can avoid this by using eager loading properly.

What is eager loading and why it matters

Eager loading is a technique that allows you to load related models in advance, all in one go, instead of querying them one at a time. This cuts down on the number of queries significantly, especially when dealing with nested or multiple relationships.

For example, imagine you're fetching a list of users and also want to show their roles. Without eager loading, each user would trigger an additional query for their role. With 100 users, that becomes 101 queries (one for users, and 100 for roles). That's not efficient.

By using with(), like so:

User::with('role')->get();

You reduce that to just two queries: one for users, one for all related roles.

How to use basic eager loading effectively

The simplest and most common use case is loading a single relationship:

$books = Book::with('author')->get();

This makes sure all books are fetched along with their related authors in the fewest queries possible.

If you need more than one relationship:

$books = Book::with(['author', 'publisher'])->get();

Or if you need to go deeper:

$books = Book::with('author.contacts')->get();

Here are a few quick tips:

• Only eager load what you need – don’t overdo it.
• Use dot notation for nested relationships ('author.address.city').
• Avoid using load() inside loops unless absolutely necessary.

Filtering or customizing eager loaded data

Sometimes you might only want to load part of a relationship or apply some constraints. For example, you might only want active comments from a post. You can do this by passing a closure:

Post::with(['comments' => function ($query) {
    $query->where('active', true);
}])->get();

You can even select specific columns:

User::with(['profile' => function ($query) {
    $query->select('user_id', 'bio');
}])->get();

A couple of important notes here:

• Always include the foreign key (user_id in this case), otherwise the relationship won’t bind correctly.
• Selecting fewer fields can help performance but make sure you’re not missing critical data.

Watch out for these common mistakes

Even experienced developers sometimes misuse eager loading. Here are a few pitfalls to avoid:

• Using whereHas() without actually needing it: If you’re filtering based on a relationship but still need to load it fully, whereHas() alone won’t do that. Combine it with with() when needed.

• Overloading relationships unnecessarily: Don’t eager load relationships you don’t use in your view or API response.

• Not using lazy eager loading when appropriate: Sometimes you already have a model instance and realize later you need its relationships. In those cases, load() is fine:

  $user = User::find(1);
  $user->load('roles');

• *Using wildcards like `with('')`**: It might seem convenient, but it loads everything—including relationships you might not need.

---

That’s basically how you optimize queries using Eloquent eager loading. It’s not complicated, but it’s easy to overlook or misuse. Focus on loading what you need, filter when necessary, and avoid unnecessary queries—it makes a big difference in real-world applications.

The above is the detailed content of Optimizing database queries with Laravel Eloquent eager loading. For more information, please follow other related articles on the PHP Chinese website!