Как вы моделируете связи в ORM?

Question

Accepted Answer

Django ORM моделирует три фундаментальные связи баз данных с помощью специализированных типов полей: **ForeignKey** (один-ко-многим), **ManyToManyField** (многие-ко-многим) и **OneToOneField** (один-к-одному). Они определяют, как таблицы связаны между собой, и предоставляют удобный Python-доступ к связанным объектам.

## ForeignKey — один-ко-многим (самый распространённый)

```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)
```

`ForeignKey` моделирует отношение "много книг принадлежат одному автору". Поведение `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL` и т.д.) **обязательно** и определяет, что произойдёт с книгами, если автор будет удалён.

## ManyToManyField — многие-ко-многим

```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 автоматически создаёт **таблицу связей** для `ManyToManyField` — вы просто используете `.add()`, `.remove()`, `.all()`. (Если нужно добавить дополнительные данные к связи, используйте модель `through`.)

## OneToOneField — один-к-одному

```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()
```

`OneToOneField` обеспечивает строгую связь один-к-одному — обычно используется для расширения модели (например, Profile расширяет User).

## Опции on_delete (важно выбрать правильно)

```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
```

## Запросы через связи

```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'
```

## Почему это важно

Правильное моделирование связей является фундаментом работы с реляционными данными в Django — почти каждое реальное приложение содержит связанные сущности (пользователи и посты, заказы и товары, статьи и теги), поэтому понимание трёх типов полей связей является обязательным знанием.

Знание того, когда использовать каждый тип — **ForeignKey** для один-ко-многим (самый распространённый, как книги, принадлежащие автору), **ManyToManyField** для многие-ко-многим (как статьи и теги, при этом Django автоматически управляет таблицей связей) и **OneToOneField** для один-к-одному (как расширение пользователя профилем) — необходимо для разработки любой нетривиальной модели данных.

ORM делает работу со связанными данными **удобной и естественной для Python** (доступ к `book.author` и `author.books.all()` происходит естественно, запросы через связи с использованием `__`), но два аспекта требуют внимания: выбор правильного **поведения `on_delete`** (обязательное, влияющее на результат решение — `CASCADE` удаляет связанные объекты, `PROTECT` предотвращает удаление, `SET_NULL` оставляет их без связи — неправильный выбор может привести к случайной потере данных или ошибкам целостности) и использование `related_name` для удобного обратного доступа.

Понимание моделирования связей, опций on_delete и запросов через связи является ключевым для построения правильных, хорошо структурированных моделей данных Django, и это напрямую связано с оптимизацией запросов (так как наивный обход связей вызывает проблему N+1), что делает это знание одновременно фундаментальным и часто проверяемым на собеседованиях.