OneToOneField for one-to-one in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when you access a related object via OneToOneField?

Consider these Django models:

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

If you have a User instance u, what does u.profile return?

A The <code>Profile</code> instance linked to <code>u</code>, or raises <code>Profile.DoesNotExist</code> if none exists

B Always returns None

C The <code>User</code> instance itself

D A list of all <code>Profile</code> instances linked to <code>u</code>

💡 Hint

Think about how OneToOneField creates a direct link between two models.

OneToOneField creates a single related object accessible as an attribute. Accessing u.profile returns the linked Profile instance or raises DoesNotExist if none exists.

📝 Syntax

intermediate

Which is the correct way to define a OneToOneField in Django?

Choose the correct syntax to define a one-to-one relationship from Profile to User:

A user = models.ManyToManyField(User)

B user = models.ForeignKey(User, unique=True, on_delete=models.CASCADE)

C user = models.OneToOneField(User, on_delete=models.CASCADE)

D user = models.OneToManyField(User)

💡 Hint

OneToOneField is a specific field type in Django models.

Only models.OneToOneField correctly defines a one-to-one relationship. ForeignKey with unique=True is not recommended for this purpose. ManyToManyField and OneToManyField do not exist or do not represent one-to-one.

🔧 Debug

advanced

Why does accessing a OneToOneField related object raise an error?

Given these models:

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

u = User.objects.create(username='alice')
print(u.profile)

This code raises Profile.DoesNotExist. Why?

A Because <code>on_delete=models.CASCADE</code> deletes the <code>User</code> instance

B Because <code>OneToOneField</code> requires <code>null=True</code> to work

C Because <code>User</code> model does not have a <code>profile</code> attribute by default

D Because no <code>Profile</code> instance linked to <code>u</code> exists yet

💡 Hint

Think about what happens if the related object is missing.

Accessing u.profile tries to find a Profile linked to u. If none exists, Django raises Profile.DoesNotExist. The other options are incorrect because null=True is not required, the reverse attribute is created automatically, and on_delete does not delete the user here.

❓ state_output

advanced

What is the output of this Django shell code involving OneToOneField?

Given these models and code:

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

u = User.objects.create(username='bob')
p = Profile.objects.create(user=u, bio='Hello')
print(u.profile.bio)

What will be printed?

A bob

B Hello

C Profile object at some memory address

D Raises Profile.DoesNotExist

💡 Hint

Remember that u.profile accesses the related Profile instance.

The code creates a User and a linked Profile with bio 'Hello'. Accessing u.profile.bio prints 'Hello'.

🧠 Conceptual

expert

Why use OneToOneField instead of ForeignKey with unique=True?

In Django, both OneToOneField and ForeignKey with unique=True can enforce one-to-one relationships. Why is OneToOneField preferred?

A OneToOneField creates a reverse attribute on the related model automatically, improving code clarity and access

B ForeignKey with unique=True does not enforce uniqueness at the database level

C OneToOneField allows multiple related objects, unlike ForeignKey

D ForeignKey with unique=True is deprecated and no longer supported in Django

💡 Hint

Think about how Django creates reverse relations and the developer experience.

OneToOneField automatically creates a reverse attribute on the related model, making it easier to access the linked object. ForeignKey with unique=True can enforce uniqueness but does not create a clear reverse one-to-one relation. Option A is incorrect because unique=True does enforce uniqueness. Option A is false because OneToOneField allows only one related object. Option A is false because ForeignKey with unique=True is still supported.

Practice

1. What is the main purpose of Django's OneToOneField?

easy

A. To store multiple values in a single database field

B. To create a many-to-many relationship between two models

C. To allow multiple records in one model to link to a single record in another

D. To link two models so each record in one matches exactly one record in the other

Solution

1. Step 1: Understand the relationship types in Django

   Django provides different fields for relationships: ForeignKey for many-to-one, ManyToManyField for many-to-many, and OneToOneField for one-to-one.

2. Step 2: Identify the purpose of OneToOneField

   OneToOneField links exactly one record in one model to exactly one record in another, ensuring a unique pairing.

3. Final Answer:

   To link two models so each record in one matches exactly one record in the other -> Option D

4. Quick Check:

   OneToOneField = unique pair link [OK]

Hint: OneToOneField means one record matches one record only [OK]

Common Mistakes:

• Confusing OneToOneField with ForeignKey
• Thinking it allows multiple links per record
• Using it to store multiple values in one field

2. Which of the following is the correct way to define a OneToOneField in a Django model?

easy

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

B. user = models.OneToOneField(User)

C. user = models.OneToOneField(User, on_delete=models.CASCADE)

D. user = models.ManyToManyField(User)

Solution

1. Step 1: Check required parameters for OneToOneField

   OneToOneField requires the related model and the on_delete argument to specify behavior on deletion.

2. Step 2: Validate the options

   user = models.OneToOneField(User, on_delete=models.CASCADE) correctly includes both the related model and on_delete=models.CASCADE. user = models.OneToOneField(User) misses on_delete, which is mandatory.

3. Final Answer:

   user = models.OneToOneField(User, on_delete=models.CASCADE) -> Option C

4. Quick Check:

   OneToOneField needs on_delete [OK]

Hint: Always include on_delete with OneToOneField [OK]

Common Mistakes:

• Omitting on_delete argument
• Using ForeignKey or ManyToManyField instead
• Incorrect field syntax

3. Given these models:

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

user = User.objects.create(username='anna')
profile = Profile.objects.create(user=user, bio='Hello!')
print(profile.user.username)

What will be printed?

medium

A. Hello!

B. anna

C. profile

D. Error: user attribute missing

Solution

1. Step 1: Understand the OneToOneField link

   The Profile model links to User via OneToOneField named 'user'. The profile instance has a user with username 'anna'.

2. Step 2: Evaluate the print statement

   Accessing profile.user.username fetches the username of the linked User, which is 'anna'.

3. Final Answer:

   anna -> Option B

4. Quick Check:

   profile.user.username = anna [OK]

Hint: Access linked user via profile.user.username [OK]

Common Mistakes:

• Printing profile.bio instead of username
• Confusing attribute names
• Assuming user attribute is missing

4. What is wrong with this model definition?

class Employee(models.Model):
    user = models.OneToOneField(User)
    department = models.CharField(max_length=100)

medium

A. Missing on_delete argument in OneToOneField

B. OneToOneField cannot link to User model

C. department field must be IntegerField

D. OneToOneField should be ForeignKey

Solution

1. Step 1: Check OneToOneField requirements

   OneToOneField requires the on_delete argument to specify what happens if the linked User is deleted.

2. Step 2: Analyze the model code

   The model misses on_delete, which will cause an error when running migrations or server start.

3. Final Answer:

   Missing on_delete argument in OneToOneField -> Option A

4. Quick Check:

   OneToOneField needs on_delete [OK]

Hint: Always add on_delete to OneToOneField [OK]

Common Mistakes:

• Forgetting on_delete causes errors
• Thinking OneToOneField can't link to User
• Confusing field types for department

5. You want to extend Django's User model to add a phone number without modifying the original User table. Which is the best way to do this using OneToOneField?

hard

A. Create a new Profile model with a OneToOneField to User and add phone number there

B. Add a phone number field directly to the User model

C. Use a ForeignKey from User to Profile with phone number

D. Create a ManyToManyField between User and phone numbers

Solution

1. Step 1: Understand extending User without changing it

   To add extra info without altering User, create a separate model linked one-to-one to User.

2. Step 2: Choose the correct relationship

   OneToOneField in a Profile model allows storing phone number linked uniquely to each User.

3. Final Answer:

   Create a new Profile model with a OneToOneField to User and add phone number there -> Option A

4. Quick Check:

   Extend User via OneToOneField in separate model [OK]

Hint: Use OneToOneField in new model to extend User [OK]

Common Mistakes:

• Modifying User model directly
• Using ForeignKey or ManyToManyField incorrectly
• Not linking phone number uniquely to User