How do you model relationships in the ORM?

Question

IT Interview Practice · Accepted Answer

Django's ORM models the three fundamental database relationships with dedicated field types: **ForeignKey** (one-to-many), **ManyToManyField** (many-to-many), and **OneToOneField** (one-to-one). These define how tables relate and give you Pythonic access to related objects.

## ForeignKey — one-to-many (the most common)

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

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(
        Author,
        on_delete=models.CASCADE,        # what happens if the author is deleted
        related_name="books",            # access the reverse: author.books
    )
```

```python
# access related objects naturally:
book.author                # the Author this book belongs to (forward)
author.books.all()         # all Books by this author (reverse, via related_name)
```

A `ForeignKey` models "many books belong to one author." The `on_delete` behavior (`CASCADE`, `PROTECT`, `SET_NULL`, etc.) is **required** and defines what happens to the books if the author is deleted.

## ManyToManyField — many-to-many

```python
class Article(models.Model):
    title = models.CharField(max_length=200)
    tags = models.ManyToManyField("Tag", related_name="articles")   # many tags ↔ many articles

class Tag(models.Model):
    name = models.CharField(max_length=50)
```

```python
article.tags.add(tag1, tag2)        # associate tags
article.tags.all()                   # all tags on this article
tag.articles.all()                   # all articles with this tag (reverse)
```

Django automatically creates the **join table** behind a `ManyToManyField` — you just use `.add()`, `.remove()`, `.all()`. (For extra data on the relationship, use a `through` model.)

## OneToOneField — one-to-one

```python
class User(models.Model):
    username = models.CharField(max_length=50)

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)   # one profile per user
    bio = models.TextField()
```

A `OneToOneField` enforces a strict one-to-one link — commonly used to extend a model (e.g. a Profile extending a User).

## on_delete options (important to choose correctly)

```text
CASCADE   → delete related objects too (delete author → delete their books)
PROTECT   → prevent deletion if related objects exist (raises an error)
SET_NULL  → set the FK to NULL (requires null=True) — keep the books, orphan them
SET_DEFAULT / SET(...) → set to a default/computed value
RESTRICT  → similar to PROTECT, with nuances
```

## Querying across relationships

```python
# traverse relationships in queries with __ (double underscore)
Book.objects.filter(author__name="Tolkien")        # books whose author's name is Tolkien
Article.objects.filter(tags__name="python")         # articles tagged 'python'
```

## Why it matters

Modeling relationships correctly is fundamental to working with relational data in Django — almost every real application has related entities (users and posts, orders and items, articles and tags), so understanding the three relationship field types is essential everyday knowledge.

Knowing when to use each — **ForeignKey** for one-to-many (the most common, like books belonging to an author), **ManyToManyField** for many-to-many (like articles and tags, with Django auto-managing the join table), and **OneToOneField** for one-to-one (like extending a user with a profile) — is necessary for designing any non-trivial data model.

The ORM makes related data **Pythonic and convenient** (accessing `book.author` and `author.books.all()` naturally, querying across relationships with `__`), but two aspects require care: choosing the correct **`on_delete` behavior** (a required, consequential decision — `CASCADE` deletes related objects, `PROTECT` prevents deletion, `SET_NULL` orphans them — getting it wrong can cause accidental data loss or integrity errors), and using `related_name` for clear reverse access.

Understanding relationship modeling, the on_delete options, and cross-relationship querying is core to building correct, well-designed Django data models, and it directly connects to query optimization (since traversing relationships naively causes N+1 problems), making it both foundational and frequently-tested knowledge.

ForeignKey — one-to-many (the most common)

ManyToManyField — many-to-many

OneToOneField — one-to-one

on_delete options (important to choose correctly)

Querying across relationships

Why it matters

Related questions