Self-referencing relationships in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Django model's __str__ method?

Consider this Django model with a self-referencing ForeignKey. What will be printed when calling print(category) if category.name = 'Books' and category.parent = None?

Django

from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=100)
    parent = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)

    def __str__(self):
        return f"{self.name} - Parent: {self.parent.name if self.parent else 'None'}"

A Books - Parent: None

B Books - Parent: Books

C Books - Parent: ''

D Books - Parent: Null

💡 Hint

Check how the __str__ method handles the parent attribute when it is None.

The __str__ method returns the category name and the parent's name if it exists. Since parent is None, it prints 'None'.

❓ state_output

intermediate

What is the value of child.parent.name after saving these objects?

Given this Django model and code, what is the value of child.parent.name after execution?

Django

from django.db import models

class Node(models.Model):
    name = models.CharField(max_length=50)
    parent = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)

root = Node.objects.create(name='Root')
child = Node.objects.create(name='Child', parent=root)

result = child.parent.name

A Root

B Child

C None

D Raises AttributeError

💡 Hint

Look at how the parent is assigned when creating the child node.

The child node's parent is set to the root node, so accessing child.parent.name returns 'Root'.

📝 Syntax

advanced

Which option correctly defines a self-referencing ManyToManyField in Django?

You want to create a Django model where each person can have many friends, and friends are also Person instances. Which code snippet correctly defines this self-referencing relationship?

Django

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=100)
    friends = ???

A models.ManyToManyField('self', symmetrical=False, blank=True)

B models.ManyToManyField('Person', symmetrical=False)

C models.ManyToManyField('self', symmetrical=True, blank=True)

D models.ForeignKey('self', on_delete=models.CASCADE)

💡 Hint

Friends usually have a symmetrical relationship.

For friends, the relationship is symmetrical, so symmetrical=True is correct. Using 'self' as the model name is required for self-referencing.

🔧 Debug

advanced

Why does this self-referencing model raise a ValueError?

This Django model raises a ValueError when running migrations. What is the cause?

Django

from django.db import models

class Employee(models.Model):
    name = models.CharField(max_length=100)
    manager = models.ForeignKey('Employee', null=True, blank=True, on_delete=models.SET_NULL)

A The model must inherit from models.SelfReferencingModel

B ForeignKey cannot be null or blank in self-referencing models

C on_delete=models.SET_NULL is invalid for self-referencing fields

D The ForeignKey must use a string 'self' instead of the class name Employee

💡 Hint

Check how Django handles self-referencing ForeignKey declarations.

When referencing the same model inside its definition, Django requires the model name as a string 'self' to avoid errors.

🧠 Conceptual

expert

What is the main difference between symmetrical=True and symmetrical=False in self-referencing ManyToManyFields?

In Django, when defining a self-referencing ManyToManyField, what does setting symmetrical=True versus symmetrical=False change about the relationship?

A symmetrical=True disables the relationship; symmetrical=False enables it

B symmetrical=True means if A is related to B, then B is automatically related to A; symmetrical=False means the relationship is one-way

C symmetrical=True requires a through model; symmetrical=False does not

D symmetrical=True only works with ForeignKey; symmetrical=False only works with ManyToManyField

💡 Hint

Think about friendship versus following relationships.

symmetrical=True means the relationship is mutual (like friends). symmetrical=False means the relationship can be one-directional (like followers).

Practice

1. What does a self-referencing relationship in a Django model mean?

easy

A. A model has a field that links to another instance of the same model.

B. A model links to a different model using ForeignKey.

C. A model cannot have relationships with itself.

D. A model uses a ManyToManyField to link to another model.

Solution

1. Step 1: Understand self-referencing relationships

   Self-referencing means a model links to itself, not to a different model.

2. Step 2: Identify the correct description

   The correct description is that a model has a field linking to another instance of the same model.

3. Final Answer:

   A model has a field that links to another instance of the same model. -> Option A

4. Quick Check:

   Self-referencing = model links to itself [OK]

Hint: Self-reference means linking model to itself, not others [OK]

Common Mistakes:

• Thinking self-reference links to a different model
• Confusing ForeignKey with ManyToManyField
• Believing models cannot link to themselves

2. Which of the following is the correct way to define a self-referencing ForeignKey in Django?

easy

A. parent = models.ForeignKey(ModelName, on_delete=models.CASCADE)

B. parent = models.ForeignKey(self, on_delete=models.CASCADE)

C. parent = models.ForeignKey('self', on_delete=models.CASCADE, null=True, blank=True)

D. parent = models.ForeignKey('ModelName', on_delete=models.CASCADE)

Solution

1. Step 1: Recognize self-referencing syntax

   Use the string 'self' in ForeignKey to refer to the same model.

2. Step 2: Check options for correct syntax

   Only parent = models.ForeignKey('self', on_delete=models.CASCADE, null=True, blank=True) uses 'self' as a string and includes proper parameters.

3. Final Answer:

   parent = models.ForeignKey('self', on_delete=models.CASCADE, null=True, blank=True) -> Option C

4. Quick Check:

   Use 'self' string in ForeignKey for self-reference [OK]

Hint: Use 'self' as a string in ForeignKey for self-reference [OK]

Common Mistakes:

• Using self without quotes
• Using model class name instead of 'self'
• Omitting null=True for optional links

3. Given this model:

class Category(models.Model):
    name = models.CharField(max_length=100)
    parent = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)

c1 = Category(name='Root')
c1.save()
c2 = Category(name='Child', parent=c1)
c2.save()
print(c2.parent.name)

What will be printed?

medium

A. Child

B. Root

C. None

D. Error

Solution

1. Step 1: Understand the parent-child link

   c2's parent is set to c1, whose name is 'Root'.

2. Step 2: Print c2.parent.name

   Accessing c2.parent.name prints 'Root'.

3. Final Answer:

   Root -> Option B

4. Quick Check:

   c2.parent.name = 'Root' [OK]

Hint: Parent points to another instance; print its name [OK]

Common Mistakes:

• Expecting 'Child' instead of 'Root'
• Assuming parent is None
• Thinking it causes an error

4. What is wrong with this self-referencing model code?

class Employee(models.Model):
    name = models.CharField(max_length=100)
    manager = models.ForeignKey(Employee, null=True, blank=True, on_delete=models.SET_NULL)

medium

A. ForeignKey should use 'self' as a string, not the class name directly.

B. on_delete=models.SET_NULL is invalid for ForeignKey.

C. null=True and blank=True cannot be used together.

D. CharField must have unique=True for self-reference.

Solution

1. Step 1: Check ForeignKey target

   For self-reference, use 'self' as a string, not the class name directly.

2. Step 2: Validate other parameters

   on_delete=models.SET_NULL and null=True, blank=True are valid here.

3. Final Answer:

   ForeignKey should use 'self' as a string, not the class name directly. -> Option A

4. Quick Check:

   Use 'self' string in ForeignKey for self-reference [OK]

Hint: Use 'self' string in ForeignKey, not class name directly [OK]

Common Mistakes:

• Using class name instead of 'self' string
• Thinking on_delete=models.SET_NULL is invalid
• Confusing null and blank usage

5. You want to create a Django model for a comment system where each comment can reply to another comment. Which is the best way to model this self-referencing relationship?

hard

A. Use a ForeignKey to another model called Reply.

B. Use a ManyToManyField to 'self' to link replies.

C. Use a OneToOneField to 'self' to link each comment to one reply.

D. Use a ForeignKey to 'self' with null=True and blank=True to allow top-level comments.

Solution

1. Step 1: Understand comment-reply structure

   Each comment can optionally reply to one other comment or none (top-level).

2. Step 2: Choose correct field type

   ForeignKey to 'self' with null=True and blank=True allows optional parent comment.

3. Step 3: Evaluate other options

   ManyToManyField allows multiple parents, OneToOneField limits to one reply, and another model is unnecessary.

4. Final Answer:

   Use a ForeignKey to 'self' with null=True and blank=True to allow top-level comments. -> Option D

5. Quick Check:

   Comment replies = ForeignKey('self', optional) [OK]

Hint: Use ForeignKey('self') with null=True for optional parent [OK]

Common Mistakes:

• Using ManyToManyField which allows multiple parents
• Using OneToOneField which restricts replies
• Creating unnecessary separate Reply model