OneToOneField for one-to-one in Django - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a OneToOneField in Django?

A OneToOneField creates a one-to-one relationship between two models, meaning each record in one model is linked to exactly one record in another model.

beginner

How do you define a one-to-one relationship in Django models?

Use models.OneToOneField inside a model to link it to another model with a one-to-one relationship.

beginner

What is a real-life example of a one-to-one relationship?

A person and their passport: each person has exactly one passport, and each passport belongs to exactly one person.

intermediate

What happens if you try to create two records linked to the same record using a OneToOneField?

Django will raise an IntegrityError because OneToOneField enforces uniqueness, so only one record can link to the other.

intermediate

How do you access the related object in a one-to-one relationship?

You can access the related object using the attribute name defined by the OneToOneField on the model instance.

What does OneToOneField enforce between two Django models?

A No relationship between models

B Multiple records in one model can link to one record in the other

C One record links to many records in the other model

D Each record in one model links to exactly one record in the other model

OneToOneField ensures a strict one-to-one link between two models.

Which Django field type would you use to create a one-to-one relationship?

A models.ManyToManyField

B models.ForeignKey

C models.OneToOneField

D models.CharField

models.OneToOneField is the correct field for one-to-one relationships.

If a OneToOneField is set on model A pointing to model B, how do you access model B from an instance of model A?

A Using the attribute name of the <code>OneToOneField</code>

B Using a query on model B

C Using a list of related objects

D You cannot access model B from model A

The related object is accessed directly via the attribute defined by the OneToOneField.

What error occurs if you try to link two records to the same record using a OneToOneField?

A ValueError

B IntegrityError

C TypeError

D No error

Django raises an IntegrityError because the uniqueness constraint is violated.

Which of these is a good example of a one-to-one relationship?

A A student and their ID card

B A book and its author

C A teacher and their students

D A blog post and its comments

Each student has exactly one ID card, and each ID card belongs to one student.

Explain how to create and use a OneToOneField in Django models.

Think about how two models can be connected so each record matches exactly one record in the other.

Describe a real-life situation where a one-to-one relationship fits well and how it maps to Django models.

Think about unique pairs in everyday life.

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