Prefetch_related for reverse relations in Django - Step-by-Step Execution

Concept Flow - Prefetch_related for reverse relations

Query main model

↓

Identify reverse relation

↓

Create separate query for related objects

↓

Fetch related objects in bulk

↓

Link related objects to main model instances

↓

Return combined result with prefetched data

Django fetches main model data first, then separately fetches related objects via reverse relation, and links them to avoid extra queries later.

Execution Sample

Django

authors = Author.objects.prefetch_related('book_set').all()
for author in authors:
    print(author.name, [book.title for book in author.book_set.all()])

Fetch authors and their related books efficiently using prefetch_related on reverse relation 'book_set'.

Execution Table

Step	Action	Query Executed	Result	Notes
1	Fetch all authors	SELECT * FROM author;	List of authors	Main query to get authors
2	Identify reverse relation 'book_set'	N/A	Prepare to fetch books	Recognize reverse FK from Book to Author
3	Fetch books for all authors in one query	SELECT * FROM book WHERE author_id IN (author_ids);	List of books	Bulk fetch books related to authors
4	Link books to each author instance	N/A	author.book_set populated	Attach books to authors in memory
5	Iterate authors and print books	N/A	Print author names and their book titles	No extra queries during iteration
6	End	N/A	All data fetched efficiently	Prefetch_related avoids N+1 query problem

💡 All authors and their related books fetched with only two queries, avoiding multiple database hits.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	Final
authors	empty	List of Author objects	Same list, books not linked yet	Authors with book_set linked	Authors with book_set linked
books	empty	empty	List of Book objects related to authors	Books linked to authors	Books linked to authors

Key Moments - 3 Insights

Why does prefetch_related run two queries instead of one?

Prefetch_related runs one query for the main model and a separate query for the related objects to efficiently fetch reverse relations in bulk, as shown in execution_table steps 1 and 3.

How does Django link the related objects to the main model after fetching?

After fetching related objects in step 3, Django attaches them to each main model instance in memory (step 4), so accessing reverse relations does not trigger new queries.

What problem does prefetch_related solve when accessing reverse relations?

It prevents the N+1 query problem where accessing each related set would cause a separate query, by fetching all related objects in one query and linking them upfront (see steps 3 and 4).

Visual Quiz - 3 Questions

Look at the execution_table, at which step are the related books fetched from the database?

A Step 1

B Step 3

C Step 4

D Step 5

💡 Hint

Check the 'Query Executed' column for the step fetching books.

According to variable_tracker, when do authors get their book_set linked?

A After Step 4

B After Step 3

C After Step 1

D At Start

💡 Hint

Look at the 'authors' row and see when book_set is populated.

If prefetch_related was not used, what would happen during iteration in Step 5?

A No queries would run

B One query for all books would run

C A query per author to fetch books would run

D An error would occur

💡 Hint

Recall the N+1 query problem explained in key_moments.

Concept Snapshot

prefetch_related('reverse_relation') fetches related objects in a separate query.
It avoids multiple queries when accessing reverse foreign key sets.
Django runs two queries: one for main model, one for related objects.
Related objects are linked in memory for fast access.
Use it to improve performance when accessing reverse relations.

Full Transcript

This visual execution trace shows how Django's prefetch_related works for reverse relations. First, Django queries the main model (authors). Then it identifies the reverse relation (book_set) and fetches all related books in one query. After fetching, Django links these books to their respective authors in memory. This process avoids running a separate query for each author when accessing their books, solving the N+1 query problem. The variable tracker shows authors and books before and after linking. Key moments clarify why two queries run and how linking happens. The quiz tests understanding of when queries run and how data links. Overall, prefetch_related improves efficiency by batching related data fetching for reverse relations.

Practice

1. What is the main purpose of using prefetch_related with reverse relations in Django?

easy

A. To update related objects in bulk

B. To fetch related objects in a single query and reduce database hits

C. To delete related objects automatically

D. To create new related objects during query

Solution

1. Step 1: Understand what prefetch_related does

   prefetch_related fetches related objects in a separate query but combines results in Python to reduce database hits.

2. Step 2: Apply this to reverse relations

   Using prefetch_related on reverse relations loads all related objects efficiently, avoiding queries inside loops.

3. Final Answer:

   To fetch related objects in a single query and reduce database hits -> Option B

4. Quick Check:

   prefetch_related reduces queries [OK]

Hint: Remember: prefetch_related loads reverse relations in one go [OK]

Common Mistakes:

• Thinking prefetch_related deletes or updates data
• Confusing prefetch_related with select_related
• Assuming it creates new objects automatically

2. Which of the following is the correct syntax to prefetch a reverse relation named comments on a Post model?

easy

A. Post.objects.prefetch_related(comments)

B. Post.objects.select_related('comments')

C. Post.objects.prefetch('comments')

D. Post.objects.prefetch_related('comments')

Solution

1. Step 1: Recall the correct method name

   The correct method to prefetch related objects is prefetch_related, not prefetch or select_related for reverse relations.

2. Step 2: Check the argument format

   The related name must be a string inside quotes, so 'comments' is correct, not a variable without quotes.

3. Final Answer:

   Post.objects.prefetch_related('comments') -> Option D

4. Quick Check:

   Correct method and string argument [OK]

Hint: Use prefetch_related('relation_name') with quotes [OK]

Common Mistakes:

• Using select_related for reverse relations
• Omitting quotes around relation name
• Using a non-existent method like prefetch()

3. Given these models:

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    author = models.ForeignKey(Author, related_name='books', on_delete=models.CASCADE)
    title = models.CharField(max_length=100)

What will this code print?

authors = Author.objects.prefetch_related('books')
for author in authors:
    print(author.name, [book.title for book in author.books.all()])

medium

A. Prints author names but book lists are empty

B. Raises an error because 'books' is not a valid relation

C. Prints each author name with a list of their book titles without extra queries

D. Prints author names but causes a query for each author inside the loop

Solution

1. Step 1: Understand the model relation

   Each Author has many Book objects accessible via the reverse relation books.

2. Step 2: Analyze the prefetch_related effect

   Using prefetch_related('books') loads all books for all authors in one extra query, so no queries happen inside the loop.

3. Final Answer:

   Prints each author name with a list of their book titles without extra queries -> Option C

4. Quick Check:

   prefetch_related loads reverse relations efficiently [OK]

Hint: prefetch_related loads reverse sets before looping [OK]

Common Mistakes:

• Thinking prefetch_related causes errors if relation exists
• Assuming empty lists because of missing select_related
• Believing queries run inside the loop despite prefetch

4. What is wrong with this code snippet?

posts = Post.objects.prefetch_related('comment_set')
for post in posts:
    print(post.title, [c.text for c in post.comment_set.all()])

Assuming Comment model has a ForeignKey to Post without a related_name set.

medium

A. Using 'comment_set' is correct; no error here

B. Should use 'comments' instead of 'comment_set' in prefetch_related

C. Must use select_related instead of prefetch_related for reverse relations

D. The code will raise an AttributeError because 'comment_set' is invalid

Solution

1. Step 1: Understand default reverse relation naming

   If no related_name is set on a ForeignKey, Django uses modelname_set as the reverse relation name, here comment_set.

2. Step 2: Check usage in prefetch_related and loop

   Using prefetch_related('comment_set') and accessing post.comment_set.all() is correct and will work without error.

3. Final Answer:

   Using 'comment_set' is correct; no error here -> Option A

4. Quick Check:

   Default reverse name = modelname_set [OK]

Hint: Default reverse name is modelname_set if no related_name [OK]

Common Mistakes:

• Assuming related_name is always 'comments'
• Using select_related for reverse relations
• Expecting an error when using default reverse name

5. You want to efficiently load all Author objects with their Book objects, but only books published after 2020. How do you use prefetch_related for this filtered reverse relation?

authors = Author.objects.prefetch_related( ... )

hard

A. Use Prefetch with a filtered queryset: Prefetch('books', queryset=Book.objects.filter(pub_year__gt=2020))

B. Use prefetch_related('books').filter(pub_year__gt=2020)

C. Use select_related('books').filter(pub_year__gt=2020)

D. Use prefetch_related('books__filter(pub_year__gt=2020)')

Solution

1. Step 1: Understand filtering reverse relations with prefetch_related

   To filter related objects in prefetch_related, use the Prefetch object with a filtered queryset.

2. Step 2: Apply Prefetch with filtered queryset

   Use Prefetch('books', queryset=Book.objects.filter(pub_year__gt=2020)) inside prefetch_related() to load only books after 2020.

3. Final Answer:

   Use Prefetch with a filtered queryset: Prefetch('books', queryset=Book.objects.filter(pub_year__gt=2020)) -> Option A

4. Quick Check:

   Filtered prefetch needs Prefetch object [OK]

Hint: Use Prefetch with filtered queryset inside prefetch_related [OK]

Common Mistakes:

• Trying to filter directly inside prefetch_related string
• Using select_related for many-to-one reverse relations
• Filtering the main queryset instead of related queryset