Chaining querysets in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output count of this chained queryset?

Given two querysets qs1 and qs2 from the same Django model, what will be the count of combined_qs = qs1 | qs2 if qs1 has 3 items and qs2 has 4 items with 2 overlapping records?

Django

qs1 = Model.objects.filter(field__startswith='A')  # 3 items
qs2 = Model.objects.filter(field__endswith='Z')      # 4 items
combined_qs = qs1 | qs2
print(combined_qs.count())

A 5

B 7

C 6

D 4

💡 Hint

Remember that chaining with | combines unique records from both querysets.

The | operator combines two querysets and removes duplicates. Since 2 records overlap, total unique records are 3 + 4 - 2 = 5.

📝 Syntax

intermediate

Which option correctly chains querysets to filter users?

You want to get all users who are either staff or have a verified email. Which queryset chaining syntax is correct?

Django

staff_qs = User.objects.filter(is_staff=True)
verified_qs = User.objects.filter(email_verified=True)
combined_qs = ???

A combined_qs = staff_qs | verified_qs

B combined_qs = staff_qs + verified_qs

C combined_qs = staff_qs & verified_qs

D combined_qs = staff_qs.filter(verified_qs)

💡 Hint

Use the operator that combines two querysets including all unique records from both.

The | operator combines two querysets with an OR condition, including unique records from both. The & operator is for intersection (AND).

🔧 Debug

advanced

Why does this chained queryset raise an error?

Consider these querysets from different models. Why does chaining them with | cause an error?

Django

qs1 = Author.objects.filter(active=True)
qs2 = Book.objects.filter(published=True)
combined_qs = qs1 | qs2

A You must convert querysets to lists before chaining

B You cannot chain querysets with filter conditions

C The | operator only works with lists, not querysets

D Querysets must be from the same model to be chained with |

💡 Hint

Check the model type of each queryset before chaining.

The | operator requires both querysets to be from the same model. Here, Author and Book are different models, so chaining raises a TypeError.

❓ state_output

advanced

What is the output of this chained queryset with exclusion?

Given qs1 with 5 items and qs2 with 3 items (all in qs1), what is the count of result_qs = qs1.exclude(pk__in=qs2)?

Django

qs1 = Model.objects.filter(active=True)  # 5 items
qs2 = Model.objects.filter(active=True, status='inactive')  # 3 items, all in qs1
result_qs = qs1.exclude(pk__in=qs2)
print(result_qs.count())

A 0

B 5

C 2

D 3

💡 Hint

Excluding items in qs2 removes those 3 from qs1.

The exclude removes the 3 items from qs1 that are in qs2, leaving 2 items.

🧠 Conceptual

expert

Why is chaining querysets with | preferred over concatenating lists?

Which reason best explains why chaining querysets with | is better than converting querysets to lists and concatenating them?

A List concatenation preserves database query optimizations, chaining does not

B Chaining with | keeps the query lazy and efficient, while list concatenation loads all data immediately

C Chaining querysets with | only works on small datasets, lists work on large datasets

D List concatenation automatically removes duplicates, but chaining does not

💡 Hint

Think about when the database query runs in each case.

Using | chains querysets lazily, so the database query runs only when needed, improving performance. Converting to lists fetches all data immediately, which can be slow and memory-heavy.

Practice

1. What does chaining querysets in Django allow you to do?

easy

A. Change the original queryset directly with each filter

B. Run multiple queries at the same time

C. Build complex database queries step by step without changing the original queryset

D. Automatically save changes to the database

Solution

1. Step 1: Understand queryset chaining

   Chaining querysets means applying filters or other queryset methods one after another, each returning a new queryset.

2. Step 2: Effect on original queryset

   Each filter returns a new queryset and does not modify the original queryset, allowing step-by-step building.

3. Final Answer:

   Build complex database queries step by step without changing the original queryset -> Option C

4. Quick Check:

   Chaining querysets = build stepwise [OK]

Hint: Remember: filters return new querysets, original stays unchanged [OK]

Common Mistakes:

• Thinking filters modify the original queryset
• Believing chaining runs multiple queries simultaneously
• Confusing queryset chaining with saving data

2. Which of the following is the correct way to chain querysets in Django?

easy

A. MyModel.objects.filter(active=True).exclude(age__lt=18)

B. MyModel.objects.filter(active=True).filter(age__lt=18).get()

C. MyModel.objects.filter(active=True).filter(age__lt=18).save()

D. MyModel.objects.filter(active=True).filter(age__lt=18).update()

Solution

1. Step 1: Check chaining syntax

   Chaining querysets means applying filters or other queryset methods one after another, returning new querysets.

2. Step 2: Identify invalid methods

   Methods like save() and update() are not queryset chaining methods; get() returns a single instance, not suitable for chaining.

3. Final Answer:

   MyModel.objects.filter(active=True).exclude(age__lt=18) -> Option A

4. Quick Check:

   Correct chaining uses filter/exclude methods [OK]

Hint: Chain filters and excludes; avoid save() or update() in chaining [OK]

Common Mistakes:

• Using save() or update() in queryset chains
• Using get() after filters
• Confusing queryset methods with model instance methods

3. Given the code:

qs = MyModel.objects.filter(active=True)
qs2 = qs.filter(age__gte=18)
qs3 = qs2.exclude(name__startswith='A')

What does qs3 contain?

medium

A. Active MyModel objects aged 18 or older whose names do not start with 'A'

B. All MyModel objects regardless of filters

C. Only MyModel objects with names starting with 'A'

D. Active MyModel objects younger than 18

Solution

1. Step 1: Analyze first filter

   qs filters objects where active=True.

2. Step 2: Analyze second filter

   qs2 further filters qs to include only those with age >= 18.

3. Step 3: Analyze exclude

   qs3 excludes objects from qs2 whose name starts with 'A'.

4. Final Answer:

   Active MyModel objects aged 18 or older whose names do not start with 'A' -> Option A

5. Quick Check:

   Filters + exclude = refined queryset [OK]

Hint: Read filters stepwise to understand final queryset content [OK]

Common Mistakes:

• Ignoring the exclude step
• Mixing up filter and exclude logic
• Assuming qs3 includes names starting with 'A'

4. What is wrong with this queryset chaining?

qs = MyModel.objects.all()[:10]
qs = qs.filter(active=True)

medium

A. You cannot slice querysets in Django

B. There is no problem; this is valid chaining

C. The filter method should come before all()

D. Slicing before filtering breaks chaining; filter cannot be applied after slicing

Solution

1. Step 1: Understand slicing effect

   Slicing a queryset (like [:10]) evaluates it and returns a list, not a queryset.

2. Step 2: Applying filter after slicing

   Since qs is now a list, calling filter() on it causes an error or unexpected behavior.

3. Final Answer:

   Slicing before filtering breaks chaining; filter cannot be applied after slicing -> Option D

4. Quick Check:

   Slice first = no chaining [OK]

Hint: Always filter before slicing to keep queryset chaining intact [OK]

Common Mistakes:

• Slicing before filtering
• Assuming slicing returns a queryset
• Trying to chain after slicing

5. You want to get all active users aged 18 or older, but exclude those whose names start with 'A' or 'B'. Which queryset chaining is correct?

hard

A. MyModel.objects.filter(active=True).filter(age__gte=18).exclude(name__startswith=['A', 'B'])

B. MyModel.objects.filter(active=True).filter(age__gte=18).exclude(name__startswith='A').exclude(name__startswith='B')

C. MyModel.objects.filter(active=True).exclude(name__startswith='A', name__startswith='B').filter(age__gte=18)

D. MyModel.objects.filter(active=True, age__gte=18).exclude(name__startswith='A' or 'B')

Solution

1. Step 1: Filter active and age

   Use two filters or one combined filter to get active users aged 18 or older.

2. Step 2: Exclude names starting with 'A' and 'B'

   Exclude separately for 'A' and 'B' because exclude(name__startswith='A' or 'B') is invalid syntax and exclude(name__startswith=['A', 'B']) is not supported.

3. Final Answer:

   MyModel.objects.filter(active=True).filter(age__gte=18).exclude(name__startswith='A').exclude(name__startswith='B') -> Option B

4. Quick Check:

   Chain filters then multiple excludes correctly [OK]

Hint: Chain filters first, then exclude each condition separately [OK]

Common Mistakes:

• Using invalid exclude syntax with 'or' inside
• Trying to exclude with a list in startswith
• Mixing filter and exclude order incorrectly