Chaining querysets in Django - Mini Project: Build & Apply

Chaining Querysets in Django

📖 Scenario: You are building a simple Django app to manage a bookstore. You want to find books that are either published after 2010 or have more than 500 pages. You will use chaining querysets to combine these two filters.

🎯 Goal: Create two querysets filtering books by different criteria, then chain them together to get a combined list of books matching either condition.

📋 What You'll Learn

Create a Django model Book with fields title (string), published_year (integer), and pages (integer).

Create a queryset recent_books filtering books published after 2010.

Create a queryset long_books filtering books with more than 500 pages.

Chain recent_books and long_books using union() to get combined_books.

💡 Why This Matters

🌍 Real World

Chaining querysets helps combine multiple filters in Django apps, like showing products that meet different criteria in an online store.

💼 Career

Understanding queryset chaining is important for Django developers to write efficient database queries and build flexible data views.

1

Define the Book model

Create a Django model called Book with fields: title as models.CharField(max_length=100), published_year as models.IntegerField(), and pages as models.IntegerField().

Django

# Define the Book model with title, published_year, and pages fields
from django.db import models

# Your code here

Hint

Use models.CharField for text and models.IntegerField for numbers.

2

Create querysets for recent and long books

Create a queryset called recent_books that filters Book objects with published_year greater than 2010. Also create a queryset called long_books that filters Book objects with pages greater than 500.

Django

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    published_year = models.IntegerField()
    pages = models.IntegerField()

# Create recent_books queryset filtering published_year > 2010
# Create long_books queryset filtering pages > 500
# Your code here

Hint

Use filter() with __gt to get values greater than a number.

3

Chain the querysets using union()

Create a queryset called combined_books by chaining recent_books and long_books using the union() method.

Django

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    published_year = models.IntegerField()
    pages = models.IntegerField()

recent_books = Book.objects.filter(published_year__gt=2010)
long_books = Book.objects.filter(pages__gt=500)

# Chain recent_books and long_books using union() into combined_books
# Your code here

Hint

Use union() to combine two querysets without duplicates.

4

Use combined_books in a view

In a Django view function called book_list, return a context dictionary with key books set to combined_books. Use render() to render a template called books.html with this context.

Django

from django.db import models
from django.shortcuts import render

class Book(models.Model):
    title = models.CharField(max_length=100)
    published_year = models.IntegerField()
    pages = models.IntegerField()

recent_books = Book.objects.filter(published_year__gt=2010)
long_books = Book.objects.filter(pages__gt=500)
combined_books = recent_books.union(long_books)

# Define a view function book_list that renders 'books.html' with context {'books': combined_books}
# Your code here

Hint

Use render(request, template_name, context) to send data to the template.

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