Through model for extra fields on M2M in Django - Step-by-Step Execution

Concept Flow - Through model for extra fields on M2M

Define two main models

↓

Define through model with extra fields

↓

Set ManyToManyField with through=through_model

↓

Create instances of main models

↓

Create through model instances linking main models + extra data

↓

Access related objects and extra fields via through model

This flow shows how to define two models linked by a ManyToManyField using a through model that holds extra information about the relationship.

Execution Sample

Django

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

class Author(models.Model):
    name = models.CharField(max_length=100)
    books = models.ManyToManyField(Book, through='Authorship')

class Authorship(models.Model):
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    book = models.ForeignKey(Book, on_delete=models.CASCADE)
    role = models.CharField(max_length=50)

Defines Author and Book models linked by Authorship through model that stores the role of the author for each book.

Execution Table

Step	Action	Evaluation	Result
1	Create Book instance	Book(title='Django Basics')	Book object saved with id=1
2	Create Author instance	Author(name='Alice')	Author object saved with id=1
3	Create Authorship instance	Authorship(author=Alice, book=Django Basics, role='Writer')	Authorship object saved linking author 1 and book 1 with role 'Writer'
4	Access Author's books	author.books.all()	Returns queryset with Book 'Django Basics'
5	Access role via Authorship	Authorship.objects.get(author=Alice, book=Django Basics).role	Returns 'Writer'
6	Exit	No more actions	End of execution

💡 All objects created and linked; extra field role accessed successfully.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
Book instance	None	Book(id=1, title='Django Basics')	Book(id=1, title='Django Basics')	Book(id=1, title='Django Basics')	Book(id=1, title='Django Basics')
Author instance	None	None	Author(id=1, name='Alice')	Author(id=1, name='Alice')	Author(id=1, name='Alice')
Authorship instance	None	None	None	Authorship(id=1, author=1, book=1, role='Writer')	Authorship(id=1, author=1, book=1, role='Writer')

Key Moments - 3 Insights

Why do we need a through model instead of a simple ManyToManyField?

Because the through model lets us add extra fields (like 'role') to the relationship, which a simple ManyToManyField cannot store. See execution_table step 3 where Authorship stores 'role'.

How do we access the extra fields on the relationship?

We query the through model directly, as shown in execution_table step 5, to get the 'role' field for a specific author-book pair.

Can we add objects to the ManyToManyField directly when using a through model?

No, we must create instances of the through model explicitly to include extra fields. This is why in step 3 we create Authorship instead of using author.books.add().

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'role' after step 3?

A 'Writer'

B 'Editor'

C None

D 'Author'

💡 Hint

Check the 'Result' column in step 3 where Authorship is created with role 'Writer'.

At which step do we link the Author and Book with extra data?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for the step where Authorship instance is created linking author and book.

If we tried to add a book to author.books without using the through model, what would happen?

A It would work and save the role as empty

B It would raise an error because through model requires explicit creation

C It would create a new book instead

D It would ignore the extra fields and link normally

💡 Hint

Refer to key_moments where it explains the need to create through model instances explicitly.

Concept Snapshot

Use a through model to add extra fields to ManyToMany relationships.
Define the through model with ForeignKeys to both models plus extra fields.
Set ManyToManyField with through=YourThroughModel.
Create through model instances to link objects with extra data.
Access extra fields by querying the through model directly.

Full Transcript

This example shows how to use a through model in Django to add extra fields to a many-to-many relationship. We define two main models, Author and Book, and a through model Authorship that links them and stores an extra field 'role'. We create instances of Book and Author, then create an Authorship instance linking them with the role 'Writer'. Accessing author.books returns the related books, and querying Authorship lets us get the role. This approach is necessary because a simple ManyToManyField cannot store extra data on the relationship. The execution table traces each step, showing object creation and linking. Key moments clarify why the through model is needed and how to access extra fields. The visual quiz tests understanding of these steps.