Lazy loading and N+1 prevention in Laravel - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output count of queries executed?

Given the following Laravel Eloquent code, how many database queries will be executed?

use App\Models\Post;

$posts = Post::all();
foreach ($posts as $post) {
    echo $post->comments->count();
}

Laravel

use App\Models\Post;

$posts = Post::all();
foreach ($posts as $post) {
    echo $post->comments->count();
}

A N+1 queries, where N is the number of posts

B 1 query

C N queries, where N is the number of posts

D 2 queries

💡 Hint

Think about how Laravel loads related models when accessed without eager loading.

The code first fetches all posts in one query. Then, for each post, accessing comments triggers a separate query. This results in 1 query for posts plus N queries for comments, totaling N+1 queries.

📝 Syntax

intermediate

Which code snippet correctly prevents N+1 problem using eager loading?

Select the Laravel Eloquent code that correctly uses eager loading to prevent the N+1 query problem when retrieving posts with their comments.

A $posts = Post::with('comments')->get();

B $posts = Post::all()->load('comments');

C $posts = Post::get()->with('comments');

D $posts = Post::withComments()->get();

💡 Hint

Eager loading is done before retrieving the data, not after.

Option A uses with('comments') before get(), which eager loads comments in one query. Option A calls load() on a collection, which works but is less efficient than eager loading before retrieval. Option A is invalid syntax because with() cannot be called after get(). Option A uses a non-existent method.

🔧 Debug

advanced

Why does this eager loading code still cause N+1 queries?

Consider this Laravel code:

$posts = Post::with('comments')->get();
foreach ($posts as $post) {
    echo $post->comments()->where('approved', true)->count();
}

Why does this still cause N+1 queries?

Laravel

$posts = Post::with('comments')->get();
foreach ($posts as $post) {
    echo $post->comments()->where('approved', true)->count();
}

A Because with('comments') does not eager load comments

B Because comments() is called as a query each time, ignoring eager loaded data

C Because count() cannot be used on eager loaded relationships

D Because the where clause is invalid syntax

💡 Hint

Check how the comments relationship is accessed inside the loop.

Using comments() calls the relationship method returning a query builder, so each count() triggers a new query. The eager loaded comments are accessed via the property comments without parentheses.

🧠 Conceptual

advanced

How to eager load nested relationships to prevent N+1?

You want to load posts with their comments and each comment's author to avoid N+1 queries. Which eager loading syntax is correct?

A $posts = Post::with('comments')->with('author')->get();

B $posts = Post::with(['comments', 'author'])->get();

C $posts = Post::with('comments.author')->get();

D $posts = Post::with('comments')->load('author');

💡 Hint

Nested relationships are specified with dot notation inside with().

Option C correctly eager loads comments and their author in one query. Option C tries to load author directly on posts, which is incorrect. Option C loads author on posts separately, not nested. Option C uses load() after get(), which is less efficient.

❓ state_output

expert

What is the output count of queries executed with conditional eager loading?

Given this Laravel code:

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

foreach ($posts as $post) {
    echo $post->comments->count();
}

How many queries are executed?

Laravel

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

foreach ($posts as $post) {
    echo $post->comments->count();
}

A 1 query

B N+1 queries, where N is the number of posts

C 3 queries

D 2 queries

💡 Hint

Constrained eager loading performs 1 query for posts and 1 query for filtered comments.

The with() method with a closure applies a condition to eager load only approved comments. This results in 1 query for posts + 1 query for approved comments, totaling 2 queries. Accessing $post->comments uses the already loaded data, so only 2 queries total.

Practice

1. What is the main purpose of using with() in Laravel Eloquent queries?

easy

A. To delete related models automatically

B. To load related models eagerly and prevent the N+1 query problem

C. To delay loading related models until they are accessed

D. To paginate the main query results

Solution

1. Step 1: Understand lazy vs eager loading

   Lazy loading delays loading related data until accessed, causing multiple queries (N+1 problem).

2. Step 2: Role of with()

   The with() method loads related models eagerly in one query, preventing multiple queries.

3. Final Answer:

   To load related models eagerly and prevent the N+1 query problem -> Option B

4. Quick Check:

   Eager loading = with() usage [OK]

Hint: Use with() to load relations early and avoid many queries [OK]

Common Mistakes:

• Confusing lazy loading with eager loading
• Thinking with() delays loading
• Assuming with() deletes data
• Mixing with() with pagination

2. Which of the following is the correct syntax to eager load the 'comments' relation on a Post model?

easy

A. $posts = Post::with('comments')->get();

B. $posts = Post::load('comments')->get();

C. $posts = Post::eager('comments')->get();

D. $posts = Post::fetch('comments')->get();

Solution

1. Step 1: Identify Laravel eager loading method

   Laravel uses with() to eager load relations, not load() or others in this context.

2. Step 2: Check method chaining and syntax

   with('comments') is called before get() to eager load comments with posts.

3. Final Answer:

   $posts = Post::with('comments')->get(); -> Option A

4. Quick Check:

   Eager load syntax = with() before get() [OK]

Hint: Remember: with() before get() for eager loading [OK]

Common Mistakes:

• Using load() statically instead of on model instance
• Using non-existent methods like eager() or fetch()
• Calling with() after get()

3. Given the code below, what will be the total number of database queries executed?

 $users = User::all();
foreach ($users as $user) {
  echo $user->posts->count();
}

medium

A. N+1 queries, where N is the number of users

B. 1 query

C. N queries, where N is the number of posts

D. 2 queries regardless of users count

Solution

1. Step 1: Analyze the initial query

   User::all() runs 1 query to get all users.

2. Step 2: Check relation access inside loop

   Accessing $user->posts triggers a query per user (lazy loading), causing N additional queries.

3. Final Answer:

   N+1 queries, where N is the number of users -> Option A

4. Quick Check:

   Lazy loading inside loop = N+1 queries [OK]

Hint: Accessing relations in loop without with() causes N+1 queries [OK]

Common Mistakes:

• Assuming only 1 query runs
• Confusing number of queries with posts count
• Thinking 2 queries run regardless of data size

4. Identify the error in the following code that tries to prevent N+1 queries:

 $orders = Order::with('items');
foreach ($orders as $order) {
  echo $order->items->count();
}

medium

A. Incorrect relation name 'items', should be 'item'

B. Loop variable should be $orders not $order

C. Using with() causes lazy loading, should use load()

D. Missing get() after with() to execute the query

Solution

1. Step 1: Check query execution

   Order::with('items') builds a query but does not execute it without get() or similar.

2. Step 2: Effect on foreach loop

   Without get(), $orders is a query builder, not a collection, so foreach will error.

3. Final Answer:

   Missing get() after with() to execute the query -> Option D

4. Quick Check:

   Always call get() to run query after with() [OK]

Hint: Add get() after with() to fetch data [OK]

Common Mistakes:

• Forgetting to execute query with get()
• Assuming with() runs query immediately
• Confusing relation names without checking model
• Misunderstanding foreach variable naming

5. You want to display a list of authors with their books and each book's reviews without causing N+1 queries. Which is the best way to write the query?

hard

A. $authors = Author::with('reviews')->get();

B. $authors = Author::with('books')->get(); foreach ($authors as $author) { $author->books->load('reviews'); }

C. $authors = Author::with('books.reviews')->get();

D. $authors = Author::all(); foreach ($authors as $author) { foreach ($author->books as $book) { echo $book->reviews->count(); } }

Solution

1. Step 1: Understand nested eager loading

   To avoid N+1, load related models and their relations in one query using dot notation.

2. Step 2: Analyze options for efficiency

   $authors = Author::with('books.reviews')->get(); uses with('books.reviews') to eager load books and their reviews together, preventing multiple queries.

3. Final Answer:

   $authors = Author::with('books.reviews')->get(); -> Option C

4. Quick Check:

   Nested eager loading = dot notation in with() [OK]

Hint: Use dot notation in with() for nested relations [OK]

Common Mistakes:

• Loading relations inside loops causing N+1
• Not eager loading nested relations together
• Using wrong relation names
• Assuming with('reviews') loads nested reviews