Self-referencing relationships in Django - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a self-referencing ForeignKey in a Django model.

Django

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

Drag options to blanks, or click blank then click option'

A'Category'

B'self'

C'models'

D'parent'

Attempts:

3 left

💡 Hint

Common Mistakes

Using the model class name directly without quotes.

Using an unrelated string instead of 'self'.

In Django, to create a self-referencing ForeignKey, you use the string 'self' to refer to the same model class.

2fill in blank

medium

Complete the code to allow a Category to have many children categories.

Django

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

Drag options to blanks, or click blank then click option'

A'children'

B'parents'

C'siblings'

D'categories'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'parents' which is the opposite direction.

Using unrelated names like 'siblings'.

The related_name defines the reverse relation name. 'children' is a common choice for self-referencing parent-child relations.

3fill in blank

hard

Fix the error in the model field to correctly allow null parent categories.

Django

parent = models.ForeignKey('self', on_delete=models.CASCADE, [1]=True, blank=True, related_name='children')

Drag options to blanks, or click blank then click option'

Aallow_null

Bempty

Cnull

Dnullable

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'nullable' instead of 'null'.

Confusing 'blank' with 'null'.

The correct argument to allow a ForeignKey to be empty in the database is null=True.

4fill in blank

hard

Fill both blanks to create a self-referencing ManyToManyField with a symmetrical relationship.

Django

class Person(models.Model):
    name = models.CharField(max_length=100)
    friends = models.[1]('self', [2]=True, blank=True)

Drag options to blanks, or click blank then click option'

AManyToManyField

BForeignKey

Csymmetrical

Drelated_name

Attempts:

3 left

💡 Hint

Common Mistakes

Using ForeignKey instead of ManyToManyField.

Forgetting to set symmetrical=True for self-referencing many-to-many.

A self-referencing ManyToManyField uses symmetrical=True to indicate the relationship is mutual, like friendship.

5fill in blank

hard

Fill all three blanks to define a self-referencing ManyToManyField with an asymmetrical relationship and a custom reverse name.

Django

class Employee(models.Model):
    name = models.CharField(max_length=100)
    mentors = models.[1]('self', symmetrical=[2], [3]='mentees', blank=True)

Drag options to blanks, or click blank then click option'

AManyToManyField

BFalse

Crelated_name

DTrue

Attempts:

3 left

💡 Hint

Common Mistakes

Setting symmetrical=True for an asymmetrical relation.

Not providing a related_name for reverse access.

Using ForeignKey instead of ManyToManyField.

For a mentorship relation, the ManyToManyField is asymmetrical (symmetrical=False) and uses related_name='mentees' for reverse access.

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