Eager loading (N+1 prevention) in Ruby on Rails - Step-by-Step Execution

Concept Flow - Eager loading (N+1 prevention)

Query Parent Records

↓

Check for Associated Records

↓

Without Eager Loading

↓

For each parent, query associated

↓

Many queries (N+1 problem)

↓

Slow performance

Shows how fetching associated records separately causes many queries (N+1 problem), while eager loading fetches all at once for speed.

Execution Sample

Ruby on Rails

posts = Post.all
posts.each do |post|
  puts post.comments.count
end

This code fetches all posts, then for each post fetches its comments count, causing many queries (N+1 problem).

Execution Table

Step	Action	Query Executed	Number of Queries So Far	Result
1	Fetch all posts	SELECT * FROM posts;	1	Posts loaded
2	For post 1, fetch comments count	SELECT COUNT(*) FROM comments WHERE post_id = 1;	2	Comments count for post 1
3	For post 2, fetch comments count	SELECT COUNT(*) FROM comments WHERE post_id = 2;	3	Comments count for post 2
4	For post 3, fetch comments count	SELECT COUNT(*) FROM comments WHERE post_id = 3;	4	Comments count for post 3
5	End loop	No query	4	All posts processed

💡 Loop ends after all posts processed; total queries = 1 (posts) + N (comments per post)

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
posts	nil	[post1, post2, post3]	[post1, post2, post3]	[post1, post2, post3]	[post1, post2, post3]
post	nil	post1	post2	post3	nil
comments_count	nil	count for post1	count for post2	count for post3	nil

Key Moments - 2 Insights

Why does the code run one query per post to get comments count?

Because inside the loop, calling post.comments.count triggers a separate query each time, as shown in execution_table rows 2-4.

How does eager loading fix the N+1 problem?

Eager loading fetches all comments for all posts in one query before the loop, avoiding multiple queries during iteration.

Visual Quiz - 3 Questions

Look at the execution table, how many queries run after fetching 3 posts and their comments counts without eager loading?

A 1

B 3

C 4

D 6

💡 Hint

Check the 'Number of Queries So Far' column in the execution_table after step 4.

If we add eager loading with Post.includes(:comments), how many queries will run for 3 posts and their comments?

A 1

B 2

C 3

D 4

💡 Hint

Eager loading runs one query for posts and one for comments, see key_moments explanation.

In variable_tracker, what is the value of 'post' after step 3?

A post3

B post2

C post1

D nil

💡 Hint

Look at the 'post' row and the 'After 3' column in variable_tracker.

Concept Snapshot

Eager loading prevents N+1 queries by fetching associated records in advance.
Without it, each parent record triggers a query for its children.
Use Post.includes(:comments) to load posts and comments in two queries.
This improves performance by reducing database hits.
Always eager load when accessing associations in loops.

Full Transcript

This visual execution shows how fetching posts and their comments without eager loading causes multiple queries, one per post, known as the N+1 problem. The code first runs one query to get all posts, then inside a loop, each post triggers a separate query to count its comments. This leads to slow performance. Eager loading solves this by running one query for posts and one for all comments, reducing queries drastically. The variable tracker shows how variables change during execution. The key moments clarify why queries multiply and how eager loading fixes it. The quizzes test understanding of query counts and variable states.