Lazy loading vs eager loading in Flask - Visual Side-by-Side Comparison

Concept Flow - Lazy loading vs eager loading

Start: Query Object Created

↓

Eager Loading?

Yes→Load Related Data Immediately

↓

Return Full Data

↓

Lazy Loading

↓

Access Related Data?

Yes→Load Related Data Now

↓

Return Partial Data

↓

Return Partial Data

The flow shows how eager loading fetches all related data upfront, while lazy loading waits until related data is accessed.

Execution Sample

Flask

user = User.query.options(joinedload(User.posts)).first()
print(user.name)
print(user.posts[0].title)

This code uses eager loading to fetch a user and their posts together, then prints the user's name and the first post's title.

Execution Table

Step	Action	Data Loaded	Output
1	Create query with joinedload(User.posts)	User and posts data prepared for loading	No output yet
2	Execute query with eager loading	User and all posts loaded from DB	No output yet
3	Access user.name	No new data loaded	Print user name
4	Access user.posts[0].title	Posts already loaded, no DB hit	Print first post title
5	End of code	All needed data loaded	Program ends

💡 All data loaded eagerly at query execution, no lazy loading triggered

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
user	None	User object with posts loaded	User object with posts loaded	User object with posts loaded	User object with posts loaded
user.name	N/A	N/A	User's name string	User's name string	User's name string
user.posts	N/A	List of posts loaded	List of posts loaded	List of posts loaded	List of posts loaded
user.posts[0].title	N/A	N/A	N/A	Title of first post	Title of first post

Key Moments - 2 Insights

Why does accessing user.posts[0].title not trigger a new database query?

Because eager loading fetched all posts when the query ran (see execution_table step 2), so posts are already in memory.

What happens if we don't use joinedload and access user.posts?

Lazy loading triggers a new database query at access time to fetch posts (not shown here, but would happen at step 4 if no eager loading).

Visual Quiz - 3 Questions

Look at the execution table, at which step is the related posts data loaded?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Check the 'Data Loaded' column in execution_table row for step 2

According to variable_tracker, what is the value of user.posts after step 3?

A List of posts loaded

B Empty list

C None

D Not yet loaded

💡 Hint

Look at user.posts value in variable_tracker after step 3

If we remove joinedload from the query, when will posts be loaded?

A At query execution (step 2)

B When accessing user.posts (step 4)

C Never loaded

D At program end (step 5)

💡 Hint

Refer to key_moments explanation about lazy loading triggering DB query on access

Concept Snapshot

Lazy loading delays fetching related data until accessed.
Eager loading fetches related data immediately with the main query.
In Flask-SQLAlchemy, use joinedload() for eager loading.
Lazy loading can cause extra queries later, eager loading reduces queries upfront.
Choose based on performance needs and data usage patterns.

Full Transcript

This visual execution shows how Flask-SQLAlchemy handles lazy and eager loading. When eager loading is used with joinedload(), related data like posts are fetched immediately with the main user query. This means accessing user.posts does not cause extra database queries. The execution table traces each step: query creation, execution with eager loading, accessing user name and posts, and program end. The variable tracker shows how variables like user and user.posts hold data after each step. Key moments clarify why eager loading avoids extra queries and when lazy loading triggers them. The quiz tests understanding of when data loads and variable states. Overall, eager loading fetches related data upfront, while lazy loading waits until access time, affecting performance and query count.