Model relationships preview in Django - Step-by-Step Execution

Concept Flow - Model relationships preview

Define Models

↓

Add Relationship Fields

↓

Create Instances

↓

Link Instances via Relationships

↓

Query Related Data

↓

Access Related Objects

This flow shows how Django models are defined with relationships, instances are created and linked, and related data is accessed.

Execution Sample

Django

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)

Defines two models: Author and Book, where each Book links to one Author using a ForeignKey.

Execution Table

Step	Action	Evaluation	Result
1	Define Author model	Author with name field	Model ready
2	Define Book model with ForeignKey to Author	Book with title and author link	Model ready
3	Create Author instance: name='Alice'	Author object created	Author(id=1, name='Alice')
4	Create Book instance: title='Django Basics', author=Author(id=1)	Book object created	Book(id=1, title='Django Basics', author=1)
5	Query Book's author	Access book.author	Author(id=1, name='Alice')
6	Query Author's books	Access author.book_set.all()	QuerySet with Book(id=1)
7	Exit	All relationships linked and accessible	End of preview

💡 All model relationships created and linked; queries return related objects correctly.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
Author instance	None	Author(id=1, name='Alice')	Author(id=1, name='Alice')	Author(id=1, name='Alice')
Book instance	None	None	Book(id=1, title='Django Basics', author=1)	Book(id=1, title='Django Basics', author=1)

Key Moments - 2 Insights

Why does book.author return an Author object, not just an ID?

Because Django's ForeignKey creates a link to the related Author object, so accessing book.author returns the full Author instance, as shown in step 5.

How can we get all books written by an author?

Using author.book_set.all() Django automatically creates a reverse relation named book_set, shown in step 6, to access all related Book objects.

Visual Quiz - 3 Questions

Look at the execution table, what is the author of the Book instance at step 4?

A None

B Author(id=1, name='Alice')

C Book(id=1, title='Django Basics')

D Author(id=2, name='Bob')

💡 Hint

Check step 4 in the execution table where the Book instance is created with author=Author(id=1).

At which step do we first create an Author instance?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the action column in the execution table for when the Author object is created.

If we add a second Book linked to the same Author, how would author.book_set.all() change?

A It would include both Book instances

B It would only show the first Book

C It would show no books

D It would cause an error

💡 Hint

Refer to the explanation in key moments about author.book_set.all() returning all related books.

Concept Snapshot

Django model relationships use fields like ForeignKey to link models.
Create instances and assign related objects.
Access related data via attributes (e.g., book.author) or reverse sets (author.book_set).
This connects data like real-life linked records.
Use on_delete to control deletion behavior.

Full Transcript

In Django, models can be linked using relationships like ForeignKey. First, you define models with fields and relationship fields. Then you create instances of these models. For example, an Author instance and a Book instance linked to that Author. When you access book.author, Django returns the linked Author object, not just an ID. Similarly, you can get all books by an author using author.book_set.all(). This preview shows how models relate and how to access related data step-by-step.

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'