Related name for reverse access in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the reverse access name for a ForeignKey with related_name='children'?

Given the following Django models, what is the correct way to access all children of a Parent instance using the related_name?

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

class Child(models.Model):
    parent = models.ForeignKey(Parent, related_name='children', on_delete=models.CASCADE)
    name = models.CharField(max_length=100)

A parent.children.all()

B child.parent.all()

C parent.child_set.all()

D parent.children_set.all()

💡 Hint

Think about the related_name attribute and how it changes the default reverse accessor.

The related_name='children' sets the reverse accessor from Parent to Child as 'children'. So, to get all children of a parent, you use parent.children.all(). The default would be parent.child_set.all() if related_name was not set.

📝 Syntax

intermediate

Which related_name causes a syntax error in this ForeignKey?

Identify which related_name value will cause a syntax error when used in this Django model:

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

A 'books_written'

B 'books123'

C 'books-written'

D 'booksWritten'

💡 Hint

related_name must be a valid Python identifier.

The related_name must be a valid Python attribute name. Hyphens '-' are not allowed in Python identifiers, so 'books-written' causes a syntax error. The others are valid identifiers.

❓ state_output

advanced

What is the output of accessing reverse relation with related_name?

Consider these Django models and code:

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

class Product(models.Model):
    category = models.ForeignKey(Category, related_name='products', on_delete=models.CASCADE)
    name = models.CharField(max_length=100)

cat = Category.objects.create(name='Toys')
Product.objects.create(name='Car', category=cat)
Product.objects.create(name='Doll', category=cat)

print(list(cat.products.values_list('name', flat=True)))

What will be printed?

A []

B ['Car', 'Doll']

C ['Car']

D ['Toys']

💡 Hint

The related_name 'products' allows reverse access from Category to Product.

The related_name 'products' lets us access all Product instances linked to the Category instance 'cat'. So cat.products.all() returns both products. The values_list with 'name' and flat=True returns a list of product names.

🔧 Debug

advanced

Why does this reverse access raise AttributeError?

Given these models:

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

class Book(models.Model):
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    title = models.CharField(max_length=200)

And this code:

author = Author.objects.first()
print(author.books.all())

Why does this raise AttributeError: 'Author' object has no attribute 'books'?

A Because the ForeignKey has no related_name, so default is 'book_set', not 'books'.

B Because the author variable is None and has no attributes.

C Because the Book model is missing a related_name attribute.

D Because the Author model must define a reverse relation explicitly.

💡 Hint

Check the default reverse accessor name when related_name is not set.

When related_name is not set, Django uses the default reverse accessor as modelname_set, here 'book_set'. So author.books does not exist, but author.book_set does.

🧠 Conceptual

expert

How does related_name affect reverse access in multi-level relations?

Given these models:

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

class City(models.Model):
    country = models.ForeignKey(Country, related_name='cities', on_delete=models.CASCADE)
    name = models.CharField(max_length=50)

class Person(models.Model):
    city = models.ForeignKey(City, related_name='residents', on_delete=models.CASCADE)
    name = models.CharField(max_length=100)

Which expression correctly gets all Person instances living in a Country instance named 'country'?

A country.cities.residents_set.all()

B country.residents.all()

C country.cities.residents.all()

D Person.objects.filter(city__country=country)

💡 Hint

Think about how to traverse ForeignKey relations in Django queries.

To get all Person instances living in a Country, you filter Person by city__country=country. The related_name allows reverse access from Country to City as 'cities', and from City to Person as 'residents', but you cannot chain reverse relations directly as attributes without querying.

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