Related name for reverse access in Django - Step-by-Step Execution

Concept Flow - Related name for reverse access

Define ForeignKey with related_name

↓

Create model instances

↓

Access related objects via related_name

↓

Use reverse lookup in queries or templates

↓

Get related objects list or queryset

This flow shows how defining related_name on a ForeignKey allows reverse access from the related model to the original model's instances.

Execution Sample

Django

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

# Access reverse: author.books.all()

Defines a ForeignKey with related_name 'books' to access all books of an author from the author instance.

Execution Table

Step	Action	Code/Expression	Result/Value
1	Define ForeignKey with related_name	author = models.ForeignKey('Author', related_name='books', on_delete=models.CASCADE)	Sets reverse accessor name to 'books'
2	Create Author instance	author = Author.objects.create(name='Alice')	Author object with id=1
3	Create Book instance linked to author	book = Book.objects.create(author=author, title='Django Basics')	Book object linked to author id=1
4	Access books from author using related_name	author.books.all()	QuerySet containing the book 'Django Basics'
5	Add another Book for same author	Book.objects.create(author=author, title='Advanced Django')	Second book linked to author id=1
6	Access books again	author.books.all()	QuerySet with two books: 'Django Basics', 'Advanced Django'
7	Access books from unrelated author	other_author.books.all()	Empty QuerySet if no books linked
8	Exit	No more steps	Reverse access works via related_name 'books'

💡 Execution stops after confirming reverse access via related_name returns correct related objects.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
author	None	Author(id=1, name='Alice')	Author(id=1, name='Alice')	Author(id=1, name='Alice')	Author(id=1, name='Alice')
book	None	None	Book(id=1, title='Django Basics', author=1)	Book(id=1, title='Django Basics', author=1)	Book(id=1, title='Django Basics', author=1)
author.books.all()	N/A	Empty QuerySet	QuerySet with 1 book	QuerySet with 2 books	QuerySet with 2 books

Key Moments - 3 Insights

Why do we use related_name instead of the default reverse accessor?

The default reverse accessor is modelname_set (e.g., book_set). Using related_name lets us choose a clearer, friendlier name like 'books' for author.books.all(), as shown in steps 1 and 4.

What happens if we don't set related_name and try to access reverse relation?

Django uses the default name modelname_set (e.g., author.book_set.all()). This can be less readable and may conflict if multiple ForeignKeys exist. See step 4 for how related_name changes this.

Can related_name be the same on multiple ForeignKeys to the same model?

No, related_name must be unique per model to avoid reverse accessor conflicts. Otherwise, Django raises an error during model validation.

Visual Quiz - 3 Questions

Look at the execution table, what does author.books.all() return after step 3?

A A QuerySet with one book titled 'Django Basics'

B An empty QuerySet

C A QuerySet with two books

D An error because related_name is missing

💡 Hint

Check the 'Result/Value' column at step 4 in the execution_table.

At which step does author.books.all() first return two books?

A Step 3

B Step 5

C Step 6

D Step 7

💡 Hint

Look at the 'Result/Value' for author.books.all() in steps 5 and 6.

If we remove related_name from the ForeignKey, how would the reverse access change?

A Reverse access would not be possible

B We would use author.book_set.all() instead of author.books.all()

C author.books.all() would still work

D Django would raise an error at runtime

💡 Hint

Recall the explanation in key_moments about default reverse accessor names.

Concept Snapshot

In Django models, related_name sets the name for reverse access from the related model.
Use related_name='books' on ForeignKey to Author to access all books via author.books.all().
Without related_name, Django uses default modelname_set (e.g., book_set).
This improves code readability and avoids conflicts.
Reverse access returns a QuerySet of related objects.

Full Transcript

This visual execution traces how Django's related_name on a ForeignKey defines the reverse accessor name. First, the ForeignKey is defined with related_name='books'. Then, an Author instance is created, followed by creating Book instances linked to that author. Accessing author.books.all() returns a QuerySet of all books linked to that author. Adding more books updates this QuerySet. The variable tracker shows author and book instances and how author.books.all() changes from empty to containing one and then two books. Key moments clarify why related_name is used, what happens if omitted, and uniqueness requirements. The quiz tests understanding of when and how reverse access works and the effect of removing related_name. The snapshot summarizes the concept for quick recall.

Practice

1. What does the related_name attribute do in a Django model's ForeignKey field?

easy

A. It sets the name used to access related objects from the other model.

B. It changes the database table name for the model.

C. It defines the primary key of the model.

D. It specifies the default ordering of query results.

Solution

1. Step 1: Understand the purpose of related_name

   The related_name attribute defines how you access related objects from the reverse side of a ForeignKey relationship.

2. Step 2: Identify what related_name affects

   It does not affect table names, primary keys, or ordering but sets the attribute name for reverse access.

3. Final Answer:

   It sets the name used to access related objects from the other model. -> Option A

4. Quick Check:

   related_name = reverse access name [OK]

Hint: related_name names reverse access from related model [OK]

Common Mistakes:

• Confusing related_name with table name
• Thinking it sets primary key
• Assuming it controls query ordering

2. Which of the following is the correct way to set a related_name in a Django ForeignKey field?

easy

A. author = models.ForeignKey(Author, reverse_name='books', on_delete=models.CASCADE)

B. author = models.ForeignKey(Author, related='books', on_delete=models.CASCADE)

C. author = models.ForeignKey(Author, related_name='books', on_delete=models.CASCADE)

D. author = models.ForeignKey(Author, relation_name='books', on_delete=models.CASCADE)

Solution

1. Step 1: Recall correct attribute name

   The correct attribute to set reverse access name is related_name.

2. Step 2: Check syntax correctness

   author = models.ForeignKey(Author, related_name='books', on_delete=models.CASCADE) uses related_name='books' correctly; others use incorrect attribute names.

3. Final Answer:

   author = models.ForeignKey(Author, related_name='books', on_delete=models.CASCADE) -> Option C

4. Quick Check:

   Use related_name= for reverse access [OK]

Hint: Use exact attribute name 'related_name' in ForeignKey [OK]

Common Mistakes:

• Using 'related' instead of 'related_name'
• Using 'reverse_name' or 'relation_name' which don't exist
• Missing on_delete argument

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 author.books.all() return?

medium

A. All Author objects related to that Book instance.

B. All Book objects related to that Author instance.

C. A syntax error because 'books' is not defined.

D. An empty queryset always.

Solution

1. Step 1: Understand related_name usage

   The related_name='books' allows accessing all Book objects from an Author instance using author.books.

2. Step 2: Interpret the method call

   author.books.all() returns a queryset of all Book objects linked to that Author.

3. Final Answer:

   All Book objects related to that Author instance. -> Option B

4. Quick Check:

   author.books.all() = related books [OK]

Hint: related_name lets you get all related objects easily [OK]

Common Mistakes:

• Thinking it returns Author objects
• Assuming syntax error due to related_name
• Expecting empty queryset without data

4. Identify the error in this model definition:

class Comment(models.Model):
    post = models.ForeignKey(Post, related_name='post', on_delete=models.CASCADE)
    text = models.TextField()

What problem will this cause?

medium

A. It will cause a syntax error because related_name cannot be 'post'.

B. It will cause a runtime error because TextField is not allowed here.

C. It will work fine without any issues.

D. It will cause a reverse accessor clash if Post already has a field named 'post'.

Solution

1. Step 1: Understand related_name uniqueness

   The related_name must be unique per model to avoid clashes.

2. Step 2: Analyze the name 'post'

   If Post model already has a field or reverse accessor named 'post', this causes a clash error.

3. Final Answer:

   It will cause a reverse accessor clash if Post already has a field named 'post'. -> Option D

4. Quick Check:

   related_name must be unique to avoid clashes [OK]

Hint: Avoid related_name same as model or field names [OK]

Common Mistakes:

• Assuming related_name can be any string without conflict
• Thinking related_name causes syntax error
• Believing TextField is invalid here

5. You have these models:

class Category(models.Model):
    name = models.CharField(max_length=50)

class Product(models.Model):
    category = models.ForeignKey(Category, on_delete=models.CASCADE)

You want to access all products of a category using category.items.all(). How should you modify the ForeignKey?

hard

A. Add related_name='items' to the ForeignKey in Product.

B. Change ForeignKey to ManyToManyField with related_name='items'.

C. Rename the ForeignKey field to 'items'.

D. Add related_query_name='items' to the ForeignKey.

Solution

1. Step 1: Understand reverse access naming

   To use category.items.all(), the ForeignKey must have related_name='items'.

2. Step 2: Check other options

   Changing to ManyToManyField or renaming the field won't create the desired reverse attribute. related_query_name affects query filters, not attribute names.

3. Final Answer:

   Add related_name='items' to the ForeignKey in Product. -> Option A

4. Quick Check:

   related_name sets reverse attribute name [OK]

Hint: Set related_name='items' to get category.items [OK]

Common Mistakes:

• Confusing related_name with related_query_name
• Changing field name instead of related_name
• Switching to ManyToManyField unnecessarily