Lazy loading vs eager loading in Flask - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding lazy loading behavior in Flask-SQLAlchemy

In Flask-SQLAlchemy, what happens when you access a related object configured with lazy='select' for the first time?

A The related object is loaded only when you access the attribute for the first time.

B The related object is loaded immediately when the parent object is queried.

C The related object is never loaded automatically and must be queried manually.

D The related object is loaded in a separate thread asynchronously.

💡 Hint

Think about when the database query for the related object happens.

Lazy loading with lazy='select' means the related data is fetched only when you access it, not when the parent is loaded.

❓ component_behavior

intermediate

Eager loading effect on query count

Given a Flask-SQLAlchemy model with a relationship set to eager loading using joined, what is the effect on the number of database queries when fetching parent objects?

A Each parent object triggers a separate query for its related objects.

B No related objects are fetched unless accessed later.

C All parent objects and their related objects are fetched in a single query using a JOIN.

D Related objects are fetched in multiple queries but batched together.

💡 Hint

Eager loading tries to reduce the number of queries by fetching related data upfront.

Eager loading with joined uses a SQL JOIN to get parent and related objects in one query, reducing database hits.

❓ state_output

advanced

Output of query count with lazy loading

Consider this Flask-SQLAlchemy code snippet where lazy='select' is used. What will be the total number of SQL queries executed when iterating over 3 parent objects and accessing their related child objects?

Flask

parents = Parent.query.all()
for p in parents:
    print(p.child.name)

A 4 queries total: one for parents and one for each child's lazy load.

B 3 queries total: one for parents and two for children.

C 1 query total: one for parents and children together.

D No queries executed because data is cached.

💡 Hint

Remember lazy loading triggers a query each time a related attribute is accessed if not already loaded.

Lazy loading runs one query to get all parents, then one query per parent to get each child when accessed.

🔧 Debug

advanced

Fixing N+1 query problem with eager loading

You notice your Flask app runs many queries when accessing related objects, causing slow response. Which change fixes this N+1 query problem?

Flask

parents = Parent.query.all()
for p in parents:
    print(p.child.name)

A Change relationship to lazy='dynamic' to delay loading.

B Use joined eager loading: Parent.query.options(joinedload(Parent.child)).all()

C Remove the relationship and query children separately.

D Add .limit(1) to the query to reduce data.

💡 Hint

Eager loading can reduce queries by fetching related data upfront.

Using joinedload tells SQLAlchemy to fetch related objects in the same query, avoiding multiple queries.

📝 Syntax

expert

Correct syntax for eager loading with subquery in Flask-SQLAlchemy

Which option correctly applies subquery eager loading to a relationship named items in a Flask-SQLAlchemy query?

Flask

results = Order.query.options(_____).all()

A joinedload('items')

B eagerload(Order.items)

C lazy='subquery'

D subqueryload(Order.items)

💡 Hint

Look for the correct function to pass inside options() for subquery loading.

subqueryload() is the correct function to specify subquery eager loading in SQLAlchemy queries.

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