OneToOneField for one-to-one in Django - Mini Project: Build & Apply

OneToOneField for one-to-one

📖 Scenario: You are building a simple Django app to store user profiles. Each user has exactly one profile with extra information.

🎯 Goal: Create two Django models: User and Profile. Link them with a one-to-one relationship using OneToOneField.

📋 What You'll Learn

Create a User model with a username field

Create a Profile model with a bio field

Add a OneToOneField in Profile linking to User

Set on_delete=models.CASCADE for the OneToOneField

Use exact field and model names as specified

💡 Why This Matters

🌍 Real World

One-to-one relationships are common when you want to extend user information without changing the original user model.

💼 Career

Understanding OneToOneField is essential for Django developers building user profiles, settings, or linked data models.

1

Create the User model

Create a Django model called User with a single field username that is a CharField with max_length=30.

Django

# Create the User model with username field
from django.db import models

# Your code here

Hint

Use class User(models.Model): and define username = models.CharField(max_length=30).

2

Create the Profile model with bio field

Add a Django model called Profile with a bio field that is a TextField.

Django

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=30)

# Create the Profile model with bio field

# Your code here

Hint

Define class Profile(models.Model): and add bio = models.TextField().

3

Add OneToOneField linking Profile to User

In the Profile model, add a OneToOneField called user that links to the User model with on_delete=models.CASCADE.

Django

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=30)

class Profile(models.Model):
    bio = models.TextField()
    # Add OneToOneField user linking to User
    # Your code here

Hint

Use user = models.OneToOneField(User, on_delete=models.CASCADE) inside Profile.

4

Add __str__ methods for better display

Add a __str__ method to both User and Profile models. For User, return self.username. For Profile, return f"Profile of {self.user.username}".

Django

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=30)

    # Add __str__ method
    # Your code here

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

    # Add __str__ method
    # Your code here

Hint

Define def __str__(self): in both models returning the specified strings.

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