Model relationships preview in Django

Introduction

Model relationships let you connect data tables in Django. This helps organize and link related information easily.

You want to link a blog post to its author.

You need to connect products to categories in a store.

You want to track which users liked which comments.

You want to store orders linked to customers.

You want to create a many-to-many connection like students and courses.

Syntax

Django

class ModelName(models.Model):
    foreign_key_field = models.ForeignKey(OtherModel, on_delete=models.CASCADE)
    one_to_one_field = models.OneToOneField(OtherModel, on_delete=models.CASCADE)
    many_to_many_field = models.ManyToManyField(OtherModel)

ForeignKey creates a many-to-one link.

OneToOneField creates a one-to-one link.

ManyToManyField creates a many-to-many link.

Examples

Each book links to one author. Many books can have the same author.

Django

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

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

Each user has exactly one profile linked one-to-one.

Django

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

Students and courses have a many-to-many relationship.

Django

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

class Course(models.Model):
    students = models.ManyToManyField(Student)
    title = models.CharField(max_length=200)

Sample Program

This example shows a book linked to an author using ForeignKey. When you print book.author.name, it shows the author's name.

Django

from django.db import models

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

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

# Usage example (in Django shell):
# author = Author.objects.create(name='Alice')
# book = Book.objects.create(author=author, title='Django Basics')
# print(book.author.name)

Important Notes

Always set on_delete to decide what happens if the linked object is deleted.

Use related_name to customize reverse lookups.

Remember to run migrations after changing models.

Summary

Model relationships connect data tables in Django.

ForeignKey is many-to-one, OneToOneField is one-to-one, ManyToManyField is many-to-many.

They help organize and access related data easily.

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'