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.

Practice

1. What is the main difference between lazy loading and eager loading in Flask ORM?

easy

A. Lazy loading is faster than eager loading in all cases.

B. Lazy loading loads all data at once; eager loading loads data in parts.

C. Lazy loading delays loading related data until accessed; eager loading loads it immediately.

D. Eager loading delays loading related data until accessed; lazy loading loads it immediately.

Solution

1. Step 1: Understand lazy loading behavior

   Lazy loading means related data is not loaded until you specifically ask for it, saving resources initially.

2. Step 2: Understand eager loading behavior

   Eager loading means related data is loaded immediately with the main query, reducing the number of queries later.

3. Final Answer:

   Lazy loading delays loading related data until accessed; eager loading loads it immediately. -> Option C

4. Quick Check:

   Lazy vs eager loading = delay vs immediate load [OK]

Hint: Lazy waits, eager loads now. Remember delay vs immediate [OK]

Common Mistakes:

• Confusing which one loads data immediately
• Thinking lazy loading loads all data at once
• Assuming eager loading is always slower

2. Which of the following is the correct syntax to use eager loading with SQLAlchemy in Flask?

easy

A. query.load_later(Model.related)

B. query.lazyload(Model.related)

C. query.eager(Model.related)

D. query.options(joinedload(Model.related))

Solution

1. Step 1: Identify eager loading syntax in SQLAlchemy

   SQLAlchemy uses joinedload() inside options() to eagerly load related data.

2. Step 2: Check other options for correctness

   lazyload is for lazy loading, eager and load_later are not valid methods.

3. Final Answer:

   query.options(joinedload(Model.related)) -> Option D

4. Quick Check:

   Eager loading = options(joinedload()) [OK]

Hint: Eager loading uses options(joinedload()) in SQLAlchemy [OK]

Common Mistakes:

• Using lazyload instead of joinedload for eager loading
• Trying non-existent methods like eager()
• Confusing method names for loading strategies

3. Given the code below, what will be the output when accessing user.posts if lazy='select' is used?

user = session.query(User).first()
print(user.posts)

medium

A. A list of posts is loaded only when user.posts is accessed.

B. All posts are loaded immediately with the user query.

C. An error occurs because posts are not loaded.

D. Posts are never loaded even when accessed.

Solution

1. Step 1: Understand lazy='select' behavior

   Lazy loading with 'select' means related posts are loaded only when accessed, not with the initial query.

2. Step 2: Analyze code behavior

   When user.posts is printed, a separate query fetches posts at that moment.

3. Final Answer:

   A list of posts is loaded only when user.posts is accessed. -> Option A

4. Quick Check:

   lazy='select' = load on access [OK]

Hint: Lazy='select' loads related data only when accessed [OK]

Common Mistakes:

• Assuming posts load with user query
• Expecting error due to missing posts
• Thinking posts never load

4. Identify the error in this Flask SQLAlchemy code snippet using eager loading:

user = session.query(User).options(lazyload(User.posts)).first()
print(user.posts)

medium

A. Calling print before loading posts.

B. Using lazyload instead of joinedload for eager loading.

C. Incorrect model name used in query.

D. Missing filter() before first().

Solution

1. Step 1: Check loading option used

   The code uses lazyload, which triggers lazy loading, not eager loading.

2. Step 2: Identify correct eager loading method

   For eager loading, joinedload should be used inside options().

3. Final Answer:

   Using lazyload instead of joinedload for eager loading. -> Option B

4. Quick Check:

   Eager loading requires joinedload, not lazyload [OK]

Hint: Eager loading needs joinedload, not lazyload [OK]

Common Mistakes:

• Confusing lazyload and joinedload
• Thinking lazyload triggers eager loading
• Ignoring loading strategy in options()

5. You have a Flask app with a User model and a related Post model. You want to display all users with their posts efficiently. Which approach best balances performance and resource use?

hard

A. Use eager loading with joinedload to load users and posts in one query.

B. Use lazy loading and access posts inside a loop, causing many queries.

C. Load posts separately after loading all users, doubling queries.

D. Avoid loading posts to save resources, showing empty post lists.

Solution

1. Step 1: Consider performance needs

   Loading users and posts in one query reduces database hits and improves speed.

2. Step 2: Compare loading strategies

   Lazy loading inside a loop causes many queries (N+1 problem), and loading posts separately doubles queries.

3. Step 3: Evaluate resource use

   Eager loading with joinedload balances resource use and query count efficiently.

4. Final Answer:

   Use eager loading with joinedload to load users and posts in one query. -> Option A

5. Quick Check:

   Eager loading with joinedload = efficient queries [OK]

Hint: Eager loading with joinedload avoids many queries [OK]

Common Mistakes:

• Using lazy loading causing many queries
• Loading posts separately doubling queries
• Skipping posts causing empty data