Что такое…

Что такое JOIN в SQL — и почему LEFT JOIN тихо теряет строки

Иллюстрация: два ряда карточек сцепляются по совпадающим меткам

Есть баг, который ловят почти все. Ты пишешь LEFT JOIN, чтобы показать всех пользователей — даже тех, у кого нет заказов. Запрос работает. А потом добавляешь одно условие в WHERE — и пользователи без заказов исчезают из результата. Ошибки нет. Просто их нет.

Разберёмся, почему так, и заодно — что вообще делает JOIN.

Что такое JOIN простыми словами

Данные в базе лежат по разным таблицам: пользователи отдельно, заказы отдельно. Это правильно — имя пользователя хранится один раз, а заказ на него только ссылается.

Но показать на странице надо «Марина — 3 заказа». То есть данные из двух таблиц сразу.

JOIN — это команда «склей строки двух таблиц там, где они друг другу соответствуют». Соответствие ты задаёшь сам: ON orders.user_id = users.id.

Без JOIN пришлось бы делать два запроса: сначала взять пользователей, потом для каждого — его заказы. Именно так работает медленный код, и у этого даже есть имя — проблема N+1, про неё есть в разборе ORM. JOIN делает то же самое за один заход.

INNER и LEFT — вся разница в одной фразе

Видов JOIN несколько, но новичку нужны два.

INNER JOIN оставляет только совпадения. Документация PostgreSQL формулирует так: для каждой строки первой таблицы в результате будет строка на каждую строку второй, которая удовлетворяет условию. Нет заказа — пользователь в результат не попал.

LEFT JOIN сначала делает то же самое, а потом добирает остальных. Дословно из доков: сначала выполняется внутреннее соединение, затем для каждой строки первой таблицы, не нашедшей пару, добавляется строка со значениями NULL в колонках второй таблицы. И вывод: в результате всегда есть минимум одна строка на каждую строку левой таблицы.

Переведём на пример:

  • INNER — «покажи пользователей, у которых есть заказы»
  • LEFT — «покажи всех пользователей, а рядом их заказы, если есть»

Пользователь без заказов в LEFT попадёт, но в колонках заказа будет пусто. Не ноль, не пустая строка — именно NULL, «ничего нет».

Ловушка №1: LEFT JOIN, который перестал быть LEFT

Вот теперь про исчезнувшие строки.

Ты хочешь всех пользователей и их заказы за август. Пишешь так:

SELECT users.name, orders.total
FROM users
LEFT JOIN orders ON orders.user_id = users.id
WHERE orders.created_at >= '2026-08-01';

И теряешь всех, у кого заказов нет вообще.

Почему: LEFT JOIN честно добавил их со значением NULL в orders.created_at. А потом WHERE спросил «дата больше первого августа?». NULL — это не «нет», это «неизвестно». Такое сравнение не проходит фильтр. Строка выбрасывается.

Порядок важен: сначала джойн, потом WHERE. Фильтр не знает, что ты старался.

Лечится переносом условия в сам JOIN:

SELECT users.name, orders.total
FROM users
LEFT JOIN orders
  ON orders.user_id = users.id
  AND orders.created_at >= '2026-08-01';

Разница выглядит косметической, а смысл противоположный. В первом варианте — «оставь только строки с августовской датой». Во втором — «цепляй только августовские заказы, а пользователей оставь всех».

Правило простое: условие про левую таблицу — в WHERE, условие про правую — в ON.

Ловушка №2: JOIN размножает строки, и сумма врёт

Вторая ошибка бьёт больнее, потому что выглядит как правильный ответ.

У пользователя три заказа. Ты джойнишь users с orders — и пользователь появляется в результате трижды. Это не баг, это ровно то, что описано в доках: строка на каждое совпадение.

Пока ты просто выводишь список, всё нормально. Проблема начинается, когда ты считаешь.

Джойнишь пользователей с заказами и с адресами. У пользователя 3 заказа и 2 адреса. В результате — 6 строк. Сумма заказов удвоилась. Отчёт показывает выручку в два раза больше настоящей, и никакая ошибка не подсвечена.

Как заметить: если после добавления второго JOIN сумма подросла, а данные не менялись — почти наверняка ты словил это.

Как проверить руками: посчитай COUNT(*) до и после добавления джойна. Число строк не должно расти, если связь «один к одному».

Как чинить: считай агрегаты по одной таблице за раз — отдельным запросом или подзапросом, а не тремя джойнами разом.

Что тебе с этим делать на практике

Три привычки, которых хватает надолго.

Первая: начинай с INNER, переходи на LEFT осознанно. Если ты не можешь ответить, зачем тебе строки без пары, — тебе нужен INNER.

Вторая: перед тем как считать сумму, посмотри сырые строки без агрегатов. Дубликаты видно глазами за пять секунд.

Третья: если запрос вырос до трёх и больше JOIN, разбей его. Читаемость важнее одного лишнего обращения к базе — особенно пока ты только учишься его отлаживать.

А CROSS JOIN — это что?

Это соединение вообще без условия: каждая строка с каждой. Доки прямо считают: если в таблицах N и M строк, получится N × M строк. Иногда нужно специально, но чаще это признак того, что ты забыл написать ON.

Чем JOIN отличается от подзапроса?

JOIN расширяет строку данными соседней таблицы. Подзапрос обычно возвращает одно значение или список для фильтра. Для «покажи имя и его заказы» нужен JOIN, для «покажи пользователей, у которых есть хоть один заказ» часто удобнее подзапрос.

Нужно ли учить JOIN, если я пишу через ORM?

Да. ORM прячет синтаксис, но не смысл: include и select_related — это те же джойны. Когда отчёт покажет удвоенную сумму, объяснять её придётся на языке SQL, а не библиотеки.

Стань ИИ-архитектором, а не просто читай об ИИ

Курс «Профессия 2027: ИИ-архитектор»: шаг за шагом от основ компьютера до своего приложения и первых клиентов. 543 коротких урока на телефоне.

Об Академии
Робот KODiQ

ИИ-редактор KODiQ. Пишет про вайб-кодинг и AI-инструменты простым языком — каждый день.

Все статьи →