Lazy loading and N+1 prevention in Laravel - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is lazy loading in Laravel Eloquent?

Lazy loading means loading related data only when you access it, not before. It helps save memory but can cause many database queries if used carelessly.

beginner

What problem does the N+1 query problem cause?

The N+1 problem happens when your app runs 1 query to get main data, then runs N more queries to get related data for each item. This slows down your app.

intermediate

How does Laravel's with() method help prevent N+1 queries?

The with() method loads related data in one query ahead of time (called eager loading), so Laravel does not run extra queries for each item.

intermediate

What is the difference between lazy loading and eager loading?

Lazy loading loads related data only when needed. Eager loading loads related data upfront in one query to avoid many queries later.

intermediate

How can you check for N+1 problems in Laravel?

You can use Laravel Debugbar or Telescope to see all queries your app runs. If you see many similar queries for related data, you have an N+1 problem.

What does Laravel's with() method do?

A Loads related data in one query before accessing it

B Loads related data only when accessed

C Deletes related data automatically

D Caches all queries permanently

with() is used for eager loading, which loads related data upfront in one query.

What is the main issue caused by the N+1 query problem?

A Incorrect data being saved

B Data not loading at all

C Too many database queries slowing down the app

D Database connection errors

N+1 problem causes many queries, which slows down the app.

Which of these is an example of lazy loading?

A Caching query results

B Using <code>with()</code> to load relations upfront

C Running a single query to get all data

D Accessing a related model property triggers a query

Lazy loading runs queries only when you access related data.

Which tool can help detect N+1 queries in Laravel?

A Composer

B Laravel Debugbar

C PHPUnit

D Artisan migrate

Laravel Debugbar shows all queries and helps spot N+1 problems.

How do you fix an N+1 problem in Laravel?

A Use eager loading with <code>with()</code>

B Remove all relations

C Use lazy loading everywhere

D Disable database queries

Eager loading with with() loads related data in fewer queries.

Explain what the N+1 query problem is and how Laravel helps prevent it.

Think about how many queries run when loading related data.

Describe the difference between lazy loading and eager loading in Laravel Eloquent.

Consider when the related data is fetched from the database.

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