Как работают методы select_related и prefetch_related?

# select_related и prefetch_related в Django ORM

Эти два метода решают проблему N+1 запросов в Django ORM, но работают по разным принципам и используются для разных типов связей.

Проблема N+1 запросов

Когда вы обращаетесь к связанным объектам, Django выполняет дополнительные запросы для каждого объекта:

from django.db import 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)

# Плохой код — N+1 проблема
books = Book.objects.all()  # 1 запрос
for book in books:          # N дополнительных запросов
    print(book.author.name)

Это создаёт 1 + N запросов (если 10 книг, то 11 запросов в БД)!

select_related — SQL JOIN

select_related использует SQL JOIN для получения связанных данных одним запросом. Работает только для прямых связей (ForeignKey, OneToOneField).

Как работает select_related:

# Хороший код — 1 запрос с JOIN
books = Book.objects.select_related(author)
for book in books:  # Нет дополнительных запросов!
    print(book.author.name)

Генерируемый SQL:

SELECT "books".*, "authors".*
FROM "books"
INNER JOIN "authors" ON "books"."author_id" = "authors"."id"

Данные обоих таблиц получаются в одном запросе!

Примеры использования:

# Одна связь
books = Book.objects.select_related(author)

# Несколько связей
class Review(models.Model):
    book = models.ForeignKey(Book, on_delete=models.CASCADE)
    reviewer = models.ForeignKey(User, on_delete=models.CASCADE)

reviews = Review.objects.select_related(book, reviewer)

# Цепочка связей (ForeignKey -> ForeignKey)
reviews = Review.objects.select_related(book__author)
# Получает: Review -> Book -> Author в одном запросе

# Глубокие цепочки
reviews = Review.objects.select_related(
    book__author,
    book__publisher,
    reviewer__profile
)

prefetch_related — отдельные запросы и кеширование

prefetch_related выполняет отдельные запросы для каждого типа связи, затем кеширует результаты в памяти. Работает для любых связей (ForeignKey, OneToOneField, ManyToMany, обратные связи).

Как работает prefetch_related:

# Две отдельные операции в БД
books = Book.objects.prefetch_related(authors)
for book in books:  # Нет дополнительных запросов!
    for author in book.authors.all():
        print(author.name)

Генерируемые SQL запросы:

-- Запрос 1
SELECT * FROM books WHERE id IN (1, 2, 3, ...)

-- Запрос 2
SELECT * FROM authors 
WHERE books_id IN (1, 2, 3, ...)

Два отдельных запроса, но результаты кешируются в памяти!

Примеры использования:

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

class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)

# ManyToMany — только prefetch_related!
books = Book.objects.prefetch_related(authors)

# Обратные связи (один автор имеет много книг)
authors = Author.objects.prefetch_related(book_set)

# Несколько связей
books = Book.objects.prefetch_related(authors, publisher, reviews)

# С фильтрацией (Prefetch object)
from django.db.models import Prefetch

books = Book.objects.prefetch_related(
    Prefetch(
        reviews,
        queryset=Review.objects.filter(rating__gte=4)
    )
)

Сравнение

Практический пример: интернет-магазин

from django.db import models
from django.db.models import Prefetch

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

class Product(models.Model):
    name = models.CharField(max_length=100)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)

class Review(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    rating = models.IntegerField()

# Плохо — N+1 проблема
products = Product.objects.all()  # 1 запрос
for product in products:  # N запросов за категорию
    print(product.category.name)
    for review in product.review_set.all():  # N*M запросов за отзывы
        print(review.rating)

# Хорошо — оптимизированный запрос
products = Product.objects.select_related(
    category  # ForeignKey
).prefetch_related(
    Prefetch(
        review_set,
        queryset=Review.objects.filter(rating__gte=4).select_related(user)
    )
)

for product in products:  # Всего 3 запроса, а не 1 + N + N*M
    print(product.category.name)
    for review in product.review_set.all():
        print(review.rating, review.user.name)

Когда что использовать

select_related:

• Один-к-одному (OneToOne)
• Много-к-одному (ForeignKey)
• Когда нужны данные в одном SQL запросе
• Когда нужна максимальная производительность

prefetch_related:

• Один-ко-многим (обратные связи)
• Много-ко-многим (ManyToMany)
• Когда нужны сложные фильтры для связанных объектов
• Когда количество связанных объектов велико (экономия памяти)

Производительность: select_related vs prefetch_related

# select_related с большим количеством данных
# Может создать очень большой результирующий набор
reviews = Review.objects.select_related(
    product__category,
    product__images,  # Дублирование категории и продукта для каждого изображения!
    user__profile
)

# prefetch_related более эффективен здесь
reviews = Review.objects.prefetch_related(
    product__category,
    product__images,
    user__profile
)

Правило большого пальца

1. Всегда используй select_related и prefetch_related для избегания N+1
2. Начни с select_related для простых связей
3. Переходи на prefetch_related, если нужна гибкость
4. Профилируй запросы с django-debug-toolbar
5. Используй Prefetch объекты для фильтрации связанных данных

Правильное использование этих методов может улучшить производительность вашего приложения в 10-100 раз!