Перейти на PRO

В чем разница между prefetch_related и select_related в Django ORM

Тип вопроса: Django Вероятность: 24% Категория: Python Разработчик

Ответ

Оба метода, select_related и prefetch_related, в Django ORM предназначены для оптимизации запросов к базе данных и решения проблемы "N+1 запросов". Однако они используют разные стратегии и подходят для разных типов связей.

select_related()

  • Как работает: Выполняет SQL JOIN на уровне базы данных, получая связанные объекты в одном запросе. Это создает более сложный, но единственный запрос.
  • Когда использовать: Для связей "один-к-одному" (OneToOneField) и "один-ко-многим" (ForeignKey).
  • Ограничение: Не работает для связей "многие-ко-многим" (ManyToManyField) и обратных связей ForeignKey.

Пример:

# models.py
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 запросов)
# 1 запрос для всех книг + N запросов для каждого автора
books = Book.objects.all()
for book in books:
    print(book.title, book.author.name)

# С select_related (1 запрос)
# Используется JOIN для получения книг и авторов одним запросом
books = Book.objects.select_related('author').all()
for book in books:
    print(book.title, book.author.name) # Дополнительный запрос к БД не выполняется

prefetch_related()

  • Как работает: Выполняет отдельный запрос для связанных объектов и "соединяет" их на уровне Python. Обычно это один запрос для основной модели и по одному дополнительному запросу для каждой связанной модели (используя оператор WHERE ... IN (...)).
  • Когда использовать: Для связей "многие-ко-многим" (ManyToManyField) и обратных связей ForeignKey.

Пример:

# models.py
class Topping(models.Model):
    name = models.CharField(max_length=30)

class Pizza(models.Model):
    name = models.CharField(max_length=50)
    toppings = models.ManyToManyField(Topping)

# С prefetch_related (2 запроса)
# 1-й запрос: SELECT * FROM "pizza";
# 2-й запрос: SELECT * FROM "topping" WHERE id IN (...);
pizzas = Pizza.objects.prefetch_related('toppings').all()
for pizza in pizzas:
    # Дополнительный запрос к БД не выполняется
    print(f"{pizza.name}: {', '.join(t.name for t in pizza.toppings.all())}")

Ключевое различие

Метод SQL-операция Тип связей
select_related JOIN ForeignKey, OneToOneField
prefetch_related Отдельный SELECT ManyToManyField, обратный ForeignKey

Ответ 18+ 🔞

Слушай, давай разберем эту дичь с Django ORM, а то народ путается, как последние идиоты. Есть два метода — select_related и prefetch_related. Оба, в принципе, чтобы не ебать мозг базе данных лишними запросами, эту самую проблему "N+1" решают. Но делают они это по-разному, пиздец как по-разному.

select_related() — это как взять всё одним махом.

Представь, ты идешь в магазин за хлебом и колбасой. Можно, конечно, как мудак, сходить два раза: сначала за хлебом, потом за колбасой. А можно одним заходом, взять и то, и другое. Вот select_related — это один здоровенный SQL-запрос с JOIN, который сразу цепляет связанные объекты. Работает только для связей «один к одному» или «один ко многим» — то есть для ForeignKey и OneToOneField. Для «многие ко многим» — нихуя не работает, забудь.

Вот смотри, без него — пиздец:

# Без оптимизации. Запрос на все книги, а потом для КАЖДОЙ книги — отдельный запрос за автором.
# Это и есть тот самый N+1, ебаный в рот.
books = Book.objects.all() # 1 запрос
for book in books:
    print(book.title, book.author.name) # +N запросов. Овердохуища запросов!

А вот с ним — красота:

# С select_related. Один запрос, и всё нахуй подтянул через JOIN.
books = Book.objects.select_related('author').all() # 1 запрос, но здоровенный
for book in books:
    print(book.title, book.author.name) # Никаких доп. запросов! Вообще!

prefetch_related() — это как собрать всё по списку.

А вот это уже для других случаев. Допустим, у тебя пицца и топпинги. Связь «многие ко многим». Тут JOINом не возьмешь, будет каша. Поэтому prefetch_related делает так: сначала один запрос за всеми пиццами, потом ОТДЕЛЬНЫЙ запрос за ВСЕМИ топпингами для этих пицц, а потом уже на уровне Python аккуратно всё соединяет. Обычно это 2 запроса, а не N+1, что уже охуенно.

Вот как это выглядит:

# С prefetch_related. Сначала за пиццами, потом за топпингами.
pizzas = Pizza.objects.prefetch_related('toppings').all()
# Где-то внутри Django: "SELECT * FROM pizza;" — раз.
# Потом: "SELECT * FROM topping WHERE pizza_id IN (...);" — два.
for pizza in pizzas:
    # И тут уже всё готово, никаких запросов в цикле!
    print(f"{pizza.name}: {', '.join(t.name for t in pizza.toppings.all())}")

Так в чем разница, блядь? Да элементарно, Ватсон!

Метод Что делает на SQL Для каких связей сработает
select_related Один жирный JOIN Только ForeignKey и OneToOneField (прямые связи)
prefetch_related Отдельные SELECTы ManyToManyField и обратные связи ForeignKey

Короче, запомни: если связь простая и можно сделать JOIN — select_related. Если связь хитрая, «многие ко многим» или обратная — prefetch_related. Главное — не путай их, а то наделаешь делов, и потом сиди, ебёшься с производительностью. Всё, вопрос закрыт.

© ХакСобесов, 2026
support@hacksobesov.com