Through model for extra fields on M2M in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of accessing extra fields in a through model?

Consider a Django many-to-many relationship with a through model that adds an extra field date_joined. What will be the output of the following code snippet?

Django

class Membership(models.Model):
    person = models.ForeignKey('Person', on_delete=models.CASCADE)
    group = models.ForeignKey('Group', on_delete=models.CASCADE)
    date_joined = models.DateField()

class Person(models.Model):
    name = models.CharField(max_length=100)
    groups = models.ManyToManyField('Group', through='Membership')

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

# Assume we have a person instance and group instance linked via Membership
membership = Membership.objects.get(person=person_instance, group=group_instance)
print(membership.date_joined)

A Raises DoesNotExist error because Membership is not accessible directly

B Prints the date_joined value stored in the Membership instance

C Raises AttributeError because date_joined is not on Person or Group

D Prints the current date because date_joined defaults to today

💡 Hint

Remember that the through model stores extra fields and can be queried directly.

The through model Membership holds the extra field date_joined. Accessing it via the Membership instance returns the stored date.

❓ state_output

intermediate

How many Membership records exist after adding a person to a group with extra fields?

Given the following models with a through model Membership that has an extra field role, what is the number of Membership records after executing the code below?

Django

person = Person.objects.create(name='Alice')
group = Group.objects.create(name='Developers')
Membership.objects.create(person=person, group=group, role='admin')
print(Membership.objects.count())

A 1

B 0

C 2

D Raises IntegrityError due to missing fields

💡 Hint

Creating a Membership instance adds one record.

Each call to Membership.objects.create() adds one record. Here, one record is created.

🔧 Debug

advanced

Why does this code raise an error when adding to a ManyToManyField with a through model?

Given the models below, why does the code person.groups.add(group_instance) raise an error?

Django

class Membership(models.Model):
    person = models.ForeignKey('Person', on_delete=models.CASCADE)
    group = models.ForeignKey('Group', on_delete=models.CASCADE)
    date_joined = models.DateField()

class Person(models.Model):
    name = models.CharField(max_length=100)
    groups = models.ManyToManyField('Group', through='Membership')

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

person = Person.objects.create(name='Bob')
group_instance = Group.objects.create(name='Admins')
person.groups.add(group_instance)

A Because person.groups is not a valid attribute

B Because the group_instance is not saved to the database

C Because the through model requires extra fields, add() cannot be used without them

D Because the ManyToManyField is missing related_name

💡 Hint

Think about how Django handles many-to-many relations with extra fields.

When a through model has extra fields, you cannot use add() directly because Django doesn't know how to fill those extra fields. You must create the through model instance manually.

📝 Syntax

advanced

Which option correctly defines a through model with an extra field for a ManyToManyField?

Choose the correct Django model code that defines a many-to-many relationship with a through model containing an extra field status.

A

class Membership(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    status = models.CharField(max_length=20)

class User(models.Model):
    groups = models.ManyToManyField(Group)

B

class Membership(models.Model):
    user = models.ManyToManyField(User)
    group = models.ManyToManyField(Group)
    status = models.CharField(max_length=20)

class User(models.Model):
    groups = models.ManyToManyField(Group, through='Membership')

C

class Membership(models.Model):
    user = models.ForeignKey(User)
    group = models.ForeignKey(Group)
    status = models.CharField(max_length=20)

class User(models.Model):
    groups = models.ManyToManyField(Group, through='Membership')

D

class Membership(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    status = models.CharField(max_length=20)

class User(models.Model):
    groups = models.ManyToManyField(Group, through='Membership')

💡 Hint

Remember that ForeignKey fields in the through model require on_delete argument.

Option D correctly uses ForeignKey with on_delete=models.CASCADE and defines the ManyToManyField with through='Membership'. Option D incorrectly uses ManyToManyField inside the through model. Option D misses on_delete. Option D misses the through argument.

🧠 Conceptual

expert

What is the main advantage of using a through model with extra fields on a ManyToManyField?

Why would a developer choose to use a through model with extra fields instead of a simple ManyToManyField without a through model?

A To store additional information about the relationship between the two models, such as timestamps or roles

B To improve database query performance by avoiding joins

C To automatically create reverse relationships without extra code

D To allow ManyToManyField to accept more than two models

💡 Hint

Think about what extra fields in the through model represent.

The main advantage is to store extra data about the relationship itself, like when it was created or the role of the related object, which is not possible with a simple ManyToManyField.