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.