Что такое проблема N+1 в Django ORM и когда нужен select_related, а когда prefetch_related?
Проверила команда Сопровод · Обновлено
Короткий ответ
Проблема N+1 — один запрос за списком объектов и еще N запросов за связанными данными, по одному на каждый объект в цикле. В Django так бывает при обращении к order.customer в цикле по заказам. select_related подтягивает внешний ключ и связь один-к-одному через JOIN в том же запросе. prefetch_related делает второй запрос с IN для обратных связей и многие-ко-многим.
Почему этот вопрос задают
Страница со списком из 50 заказов незаметно отправляет 51 запрос, и с ростом данных она тормозит все сильнее. По ответу видно, представляете ли вы SQL за строкой на ORM и умеете ли сократить число запросов.
Как рассуждать
- Опишите симптом: запрос за списком и еще по запросу на каждый элемент в цикле
- Объясните причину: ORM грузит связанный объект лениво, при первом обращении к атрибуту
- Назовите
select_relatedдля внешнего ключа и один-к-одному: один запрос сJOIN - Назовите
prefetch_relatedдля обратных связей и многие-ко-многим: второй запрос сIN
Ответ с примером
Сервис доставки пиццы выводит список заказов с именами клиентов. Код на sqlite3 из стандартной библиотеки повторяет запросы, которые Django отправит в базу. Заказы приходят одним запросом, и за клиентом каждого заказа цикл идет отдельно: set_trace_callback(print) показывает шесть запросов на пять заказов. То же делает Django, когда в цикле по Order.objects.all() вы читаете order.customer.name. Вариант с JOIN получает все за один запрос, такой SQL строит Order.objects.select_related("customer").
Для обратной связи, например всех заказов клиента через customer.orders при related_name="orders" у внешнего ключа, JOIN размножил бы строки клиента. Здесь нужен Customer.objects.prefetch_related("orders"): Django делает второй запрос с WHERE customer_id IN (...) и раскладывает заказы по клиентам в Python.
db = sqlite3.connect(":memory:")
db.executescript("""CREATE TABLE customers (id INTEGER PRIMARY KEY, name TEXT);
INSERT INTO customers VALUES (1, 'Анна'), (2, 'Олег'), (3, 'Ира');
CREATE TABLE orders (id INTEGER PRIMARY KEY, customer_id INTEGER);
INSERT INTO orders (customer_id) VALUES (1), (2), (1), (3), (2);""")
db.set_trace_callback(print)
for (customer_id,) in db.execute("SELECT customer_id FROM orders").fetchall():
db.execute("SELECT name FROM customers WHERE id = ?", (customer_id,)).fetchone()
print("---")
db.execute("SELECT o.id, c.name FROM orders o JOIN customers c ON c.id = o.customer_id")SELECT customer_id FROM orders SELECT name FROM customers WHERE id = 1 SELECT name FROM customers WHERE id = 2 SELECT name FROM customers WHERE id = 1 SELECT name FROM customers WHERE id = 3 SELECT name FROM customers WHERE id = 2 --- SELECT o.id, c.name FROM orders o JOIN customers c ON c.id = o.customer_id
select_related и prefetch_related: в чем разница
| Свойство | select_related | prefetch_related |
|---|---|---|
| Сколько запросов | один, с JOIN | основной и еще по одному на каждую связь |
| Какие связи | внешний ключ и один-к-одному | любые, включая обратный внешний ключ и многие-ко-многим |
| Где соединяются данные | в базе | в Python |
| Риск | широкие строки при нескольких JOIN | длинный список в IN и память под объекты |
| Пример | Order.objects.select_related("customer") | Customer.objects.prefetch_related("orders") |
Как ответить сильнее
Что добавит опытный кандидат
Что спросят следом
Доступно по подписке
Приемы опытных и готовые ответы
Частые ошибки
«
prefetch_relatedделает тот жеJOIN, только хитрее»Уточните, что это отдельный запрос с
INпо собранным идентификаторам. Соединение строк происходит в Python, в памяти процесса«Добавлю индекс на
customer_id, и N+1 пропадет»Объясните, что индекс ускорит каждый из N запросов, но их число останется прежним, как и сетевая задержка на каждый
«В
select_relatedможно передать связь многие-ко-многим»Скажите, что Django ответит ошибкой
FieldError:select_relatedработает только со связями к одному объекту. Для многие-ко-многим нуженprefetch_related«Перепишу все на сырой SQL, так надежнее»
Покажите, что ORM решает задачу одной строкой с
select_related. Сырой SQL оставьте для запросов, которые ORM выражает плохо, например для рекурсивного обхода дерева черезWITH RECURSIVE
Сигналы для интервьюера
Сильный ответ
Сам переводит цикл на ORM в SQL-запросы, считает их и выбирает между select_related и prefetch_related по типу связи
Тревожный сигнал
Знает оба метода, а N+1 в шаблоне или сериализаторе API без подсказки не замечает
Красный флаг
Не видит проблемы в запросе на каждую строку и предлагает лечить медленную страницу кэшем или мощным сервером
Как еще могут спросить
- Что такое проблема N+1 запросов в Django ORM?
- В чем разница между
select_relatedиprefetch_relatedв Django? - Как в Django уменьшить число запросов к базе при обходе связанных объектов?
- Когда использовать
prefetch_relatedвместоselect_related?











