Model relationships preview in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of accessing related objects in Django?

Given these Django models:

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

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

What will author.books.count() return after creating one author and two books linked to that author?

Django

author = Author.objects.create(name='Alice')
Book.objects.create(title='Book 1', author=author)
Book.objects.create(title='Book 2', author=author)
result = author.books.count()

A 1

B 2

C 0

D Raises AttributeError

💡 Hint

Think about how the related_name works for reverse lookups.

The related_name='books' on the ForeignKey allows accessing all Book objects linked to an Author via author.books. Since two books are created for the author, author.books.count() returns 2.

📝 Syntax

intermediate

Which option correctly defines a ManyToMany relationship in Django?

You want to model a relationship where multiple students can enroll in multiple courses. Which model definition is correct?

A

class Student(models.Model):
    courses = models.OneToOneField('Course', on_delete=models.CASCADE)

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

B

class Student(models.Model):
    courses = models.ForeignKey('Course', on_delete=models.CASCADE)

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

C

class Student(models.Model):
    courses = models.CharField(max_length=100)

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

D

class Student(models.Model):
    courses = models.ManyToManyField('Course')

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

💡 Hint

Many students can have many courses, so think about the field type that supports many-to-many.

ManyToManyField is the correct field to represent many-to-many relationships in Django. ForeignKey is one-to-many, OneToOneField is one-to-one, and CharField is just text.

🔧 Debug

advanced

Why does accessing a related object raise DoesNotExist error?

Given these models:

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()

And this code:

profile = Profile.objects.get(user=request.user)
print(profile.bio)

Sometimes this raises Profile.DoesNotExist. Why?

A The user does not have a linked Profile object in the database.

B The OneToOneField is incorrectly defined and causes a syntax error.

C The bio field is empty, causing the error.

D The User model does not exist in Django by default.

💡 Hint

Think about what happens if the related object is missing.

The DoesNotExist error means the query found no Profile linked to the user. This happens if the user has no Profile record yet.

❓ state_output

advanced

What is the output of this code using select_related?

Given these models:

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

class Book(models.Model):
    title = models.CharField(max_length=100)
    publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)

And this code:

book = Book.objects.select_related('publisher').get(id=1)
print(book.publisher.name)

What does select_related do here?

A It raises a ValueError because select_related cannot be used with ForeignKey.

B It delays fetching the Publisher until publisher.name is accessed, causing a second query.

C It fetches the Book and its Publisher in one database query, so accessing publisher.name does not cause another query.

D It fetches only the Book and ignores the Publisher.

💡 Hint

select_related is used to optimize queries by joining related tables.

select_related performs a SQL join to get related objects in one query. This avoids extra queries when accessing related fields.

🧠 Conceptual

expert

How does Django handle cascading deletes in model relationships?

Consider these models:

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

class Item(models.Model):
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    name = models.CharField(max_length=100)

If a Category is deleted, what happens to its related Items?

A All Items linked to the deleted Category are also deleted automatically.

B The Items remain but their category field is set to NULL.

C Deleting Category raises an IntegrityError because Items depend on it.

D The Items are archived but not deleted.

💡 Hint

Check the meaning of on_delete=models.CASCADE.

on_delete=models.CASCADE means deleting the referenced object (Category) will delete all related objects (Items) automatically.

Practice

1. Which Django model field type represents a many-to-one relationship?

easy

A. ForeignKey

B. OneToOneField

C. ManyToManyField

D. CharField

Solution

1. Step 1: Understand relationship types in Django models

   Django uses ForeignKey for many-to-one, OneToOneField for one-to-one, and ManyToManyField for many-to-many relationships.

2. Step 2: Match the field to many-to-one relationship

   The ForeignKey field connects many instances of one model to a single instance of another model, representing many-to-one.

3. Final Answer:

   ForeignKey -> Option A

4. Quick Check:

   Many-to-one = ForeignKey [OK]

Hint: ForeignKey always means many-to-one relation [OK]

Common Mistakes:

• Confusing OneToOneField with ForeignKey
• Thinking ManyToManyField is many-to-one
• Using CharField for relationships

2. Which of the following is the correct syntax to define a one-to-one relationship in a Django model?

easy

A. user = models.ForeignKey(User, on_delete=models.CASCADE)

B. email = models.CharField(max_length=100)

C. groups = models.ManyToManyField(Group)

D. profile = models.OneToOneField(User, on_delete=models.CASCADE)

Solution

1. Step 1: Identify the field for one-to-one relationship

   The OneToOneField is used to create a one-to-one link between two models.

2. Step 2: Check the syntax correctness

   The syntax profile = models.OneToOneField(User, on_delete=models.CASCADE) correctly defines a one-to-one relationship with proper arguments.

3. Final Answer:

   profile = models.OneToOneField(User, on_delete=models.CASCADE) -> Option D

4. Quick Check:

   OneToOneField syntax = profile = models.OneToOneField(User, on_delete=models.CASCADE) [OK]

Hint: OneToOneField uses on_delete argument like ForeignKey [OK]

Common Mistakes:

• Using ForeignKey instead of OneToOneField
• Omitting on_delete argument
• Confusing ManyToManyField syntax

3. Given these models:

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

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

What will book.author.name return if book is a Book instance?

medium

A. The name of the author related to the book

B. The title of the book

C. An error because author is a ForeignKey

D. The id of the author

Solution

1. Step 1: Understand ForeignKey access in Django

   A ForeignKey field allows access to the related model instance. So book.author gives the Author instance linked to the book.

2. Step 2: Access the related model's attribute

   Using book.author.name accesses the name attribute of the related Author instance, returning the author's name.

3. Final Answer:

   The name of the author related to the book -> Option A

4. Quick Check:

   ForeignKey attribute access returns related model data [OK]

Hint: ForeignKey lets you access related object attributes directly [OK]

Common Mistakes:

• Expecting book.author to be just an ID
• Thinking book.author.name causes error
• Confusing book.title with author name

4. Identify the error in this Django model relationship:

class Profile(models.Model):
    user = models.OneToOneField(User)
    bio = models.TextField()

medium

A. OneToOneField should be ForeignKey

B. Missing on_delete argument in OneToOneField

C. TextField cannot be used for bio

D. User model must be imported

Solution

1. Step 1: Check OneToOneField required arguments

   Django requires the on_delete argument for relationship fields like OneToOneField to specify behavior on deletion.

2. Step 2: Identify missing argument

   The model misses on_delete=models.CASCADE or similar, which causes an error.

3. Final Answer:

   Missing on_delete argument in OneToOneField -> Option B

4. Quick Check:

   Relationship fields need on_delete argument [OK]

Hint: Always add on_delete to OneToOneField and ForeignKey [OK]

Common Mistakes:

• Omitting on_delete argument
• Confusing OneToOneField with ForeignKey
• Assuming TextField is invalid for bio

5. You want to model a social app where users can follow many other users and be followed by many users. Which Django model field setup correctly represents this many-to-many self-relationship?

hard

A. followers = models.OneToOneField('self', on_delete=models.CASCADE)

B. followers = models.ForeignKey('self', on_delete=models.CASCADE)

C. followers = models.ManyToManyField('self', symmetrical=False, related_name='following')

D. followers = models.ManyToManyField(User)

Solution

1. Step 1: Understand many-to-many self-relationship

   Users can follow many users and be followed by many, so a many-to-many relationship to self is needed.

2. Step 2: Check correct ManyToManyField syntax for self

   Using ManyToManyField('self', symmetrical=False, related_name='following') correctly models directed follow relationships.

3. Final Answer:

   followers = models.ManyToManyField('self', symmetrical=False, related_name='following') -> Option C

4. Quick Check:

   ManyToManyField to 'self' with symmetrical=False models follow [OK]

Hint: Use ManyToManyField('self', symmetrical=False) for directed self-relations [OK]

Common Mistakes:

• Using ForeignKey or OneToOneField for many-to-many
• Omitting symmetrical=False for directed relation
• Using ManyToManyField(User) instead of 'self'