Дубликаты после JOIN — откуда берутся и как контролировать!

Одна из частых проблем — внезапное размножение строк после JOIN. Это базовое поведение, если не учтена кардинальность связей.

Таблицы:

orders(id, customer_id, amount)
payments(id, order_id, status)

Задача: получить заказы с информацией об оплате.

SELECT 
    o.id,
    o.amount,
    p.status
FROM orders o
LEFT JOIN payments p  
    ON p.order_id = o.id;

Если у одного заказа несколько платежей — в результат попадёт несколько строк. Фактически вы получаете по одной строке на каждое совпадение orders — payments. То есть один заказ повторится столько раз, сколько у него записей в payments.

Для связи 1:N это абсолютно ожидаемо. Где начинаются проблемы — агрегация:

SELECT 
    COUNT(*) AS total_orders
FROM orders o
LEFT JOIN payments p  
    ON p.order_id = o.id;

Здесь COUNT(*) считает строки уже после JOIN, а не заказы. Если у заказа 3 платежа — он попадёт в счёт 3 раза. Это одна из самых частых причин кривых метрик.

Корректный вариант:

SELECT 
    COUNT(DISTINCT o.id) AS total_orders
FROM orders o
LEFT JOIN payments p  
    ON p.order_id = o.id;

Так считаются уникальные заказы, независимо от числа платежей. Но важно помнить, что DISTINCT — это дополнительная операция, и на больших объёмах она может стоить дорого.

И отдельный момент, если вам нужно просто количество заказов без условий по payments, JOIN здесь вообще лишний. Лучше контролировать кардинальность до JOIN

Если задача — проверить наличие успешной оплаты, проще и дешевле использовать EXISTS:

SELECT 
    o.id,
    o.amount
FROM orders o
WHERE EXISTS (
    SELECT 1
    FROM payments p
    WHERE p.order_id = o.id
      AND p.status = 'success'
);

EXISTS работает как semi-join: он проверяет факт наличия строки, но не тянет её в результат. За счёт этого одна строка заказа остаётся одной строкой.

Если JOIN всё-таки нужен — агрегируем заранее:

SELECT 
    o.id,
    o.amount,
    COALESCE(p.has_success, 0) AS has_success
FROM orders o
LEFT JOIN (
    SELECT
        order_id,
        MAX(CASE WHEN status = 'success' THEN 1 ELSE 0 END) AS has_success
    FROM payments
    GROUP BY order_id
) p ON p.order_id = o.id;

Здесь мы сначала приводим payments к одной строке на order_id, и только потом делаем JOIN. После этого результат становится понятным: одна строка на заказ, без раздувания.

Типичная ошибка:

GROUP BY o.id, o.amount, p.status

Это не решит проблему. Такой GROUP BY просто фиксирует текущую детализацию. Если у заказа было несколько статусов — строки никуда не денутся.

🔥 JOIN не создаёт дубликаты сам по себе. Он возвращает строки в соответствии с числом совпадений по условию ON. Если после JOIN строк стало больше — значит реальная связь между таблицами не 1:1, а 1:N или даже N:M.

➡️ SQL Ready | #практика

😎 SQL Server Kit — практическая база инструментов и материалов!

Репозиторий представляет собой обширную коллекцию скриптов, статей, рекомендаций и утилит для администрирования и разработки на SQL. Внутри собраны решения для диагностики производительности, оптимизации запросов, мониторинга, резервного копирования, работы с индексами и анализа состояния базы данных. Также представлены ссылки на проверенные источники и лучшие практики работы с СУБД.

Оставляю ссылочку: GitHub 📱

➡️ SQL Ready | #репозиторий

😍 SQL PostgreSQL Course — информативный курс по SQL с практикой!

Это структурированное обучение по PostgreSQL: от базовых запросов до JOIN’ов, подзапросов и проектирования базы данных. Материал выстроен последовательно, поэтому легко идти шаг за шагом и не теряться в теме. Здесь есть практика с заданиями и ответами, за счёт чего обучение закрепляется.

Оставляю ссылочку: GitHub 📱

➡️ SQL Ready | #репозиторий

Диапазоны как тип данных: убираем двойные условия и баги!

Когда работаешь с интервалами, обычно пишут два условия, и почти всегда где-то ошибаются с границами:

WHERE created_at <= now()
AND shipped_at > now()

Такой код легко сломать и плохо масштабируется:

tstzrange(created_at, shipped_at)

PostgreSQL имеет встроенные range-типы, которые позволяют хранить и сравнивать интервалы как единое значение.

tstzrange — для timestamptz, tsrange — для timestamp:

@> now()

Оператор @> проверяет содержит ли диапазон значение, заменяя сразу два условия.

По умолчанию границы [ ) — аналог created_at <= x AND shipped_at > x:

CREATE INDEX ON orders USING GIST (tstzrange(created_at, shipped_at));

С GiST-индексом такие запросы работают эффективно даже на больших объёмах.

🔥range-типы — это способ убрать класс ошибок с датами и упростить сложную логику.

➡️ SQL Ready | #совет

📂 Напоминалка по тому, как работает PostgreSQL!

Например, каждое подключение создаёт отдельный процесс, а любые изменения сначала попадают в WAL, и только потом гарантированно пишутся в данные.

На картинке — базовая архитектура: подключения и backend-процессы, shared memory, background и auxiliary процессы и физическое хранение.

Сохрани, чтобы не потерять!

➡️ SQL Ready | #ресурс

Исключающие ограничения: гарантия отсутствия пересечений на уровне БД!

Проверять пересекаются ли интервалы через SELECT перед INSERT — классическая ошибка, которая ломается при конкурентных транзакциях.

SELECT 1
FROM bookings
WHERE room_id = 101
AND start_at < $end
AND end_at > $start;

Даже если проверка есть, два параллельных запроса могут пройти её одновременно и записать конфликтующие данные:

CREATE EXTENSION IF NOT EXISTS btree_gist;

PostgreSQL решает это на уровне ограничений через exclusion constraint, который работает корректно даже при конкуренции:

ALTER TABLE bookings
ADD CONSTRAINT no_overlap
EXCLUDE USING gist (
  room_id WITH =,
  tsrange(start_at, end_at) WITH &&
);

🔥 exclusion constraint — это способ переложить сложную логику (пересечения, диапазоны, уникальность по условиям) с приложения на уровень СУБД с полной защитой от состояния гонки.

➡️ SQL Ready | #совет

🐱 Awesome Postgres — огромная база всего, что связано с PostgreSQL!

В этом репозитории собраны лучшие инструменты, библиотеки, GUI-клиенты, ORM, статьи, курсы и сервисы для работы с PostgreSQL. По сути — это подборка всего полезного для backend-разработчика и DBA в одном месте. Внутри есть материалы не только по базовой работе с БД, но и по мониторингу, репликации, производительности, миграциям и архитектуре.

Оставляю ссылочку: GitHub 📱

➡️ SQL Ready | #репозиторий

LAG() в SQL — сравниваем строку с предыдущей без JOIN!

Оконная функция LAG() позволяет получить значение из предыдущей строки внутри группы. Это один из самых полезных инструментов для аналитики, логов и временных рядов.

Таблица:
payments(id, user_id, amount, created_at)

Посмотрим предыдущий платёж каждого пользователя:

SELECT
    user_id,
    amount,
    LAG(amount) OVER (
        PARTITION BY user_id
        ORDER BY created_at
    ) AS prev_amount
FROM payments;

LAG() сдвигает значение на одну строку назад внутри окна пользователя.

Теперь можно сразу посчитать разницу между текущим и прошлым платежом:

SELECT
    user_id,
    amount,
    amount - LAG(amount) OVER (
        PARTITION BY user_id
        ORDER BY created_at
    ) AS diff
FROM payments;

Так удобно анализировать рост, падение и аномалии в данных без дополнительных JOIN.

Можно находить моменты изменения значения, например смену статуса:

SELECT *
FROM (
    SELECT
        user_id,
        status,
        LAG(status) OVER (
            PARTITION BY user_id
            ORDER BY created_at
        ) AS prev_status
    FROM user_logs
) t
WHERE status <> prev_status;

Запрос покажет только строки, где статус изменился относительно предыдущего события.

🔥 LAG() часто используют для анализа трендов, поиска изменений, расчёта дельт и работы с временными рядами.

➡️ SQL Ready | #практика

📂 Напоминалка по DB Sharding!

Шардинг помогает масштабировать базу данных, распределяя данные между несколькими серверами. На картинке — основные стратегии партиционирования и шардинга.

Например, key-based sharding использует hash-функцию для равномерного распределения записей, а range-based sharding делит данные по диапазонам значений.

Сохрани, чтобы не потерять!

➡️ SQL Ready | #ресурс

Генерация пропущенных дат в отчётах: почему LEFT JOIN не помогает!

Классическая задача — построить отчёт по дням. Например, количество заказов по датам. И внезапно оказывается, что в выдаче нет некоторых дней.

Таблица:

orders(id, created_at)

Плохой вариант:

SELECT
    DATE(created_at) AS day,
    COUNT(*) AS orders_count
FROM orders
GROUP BY DATE(created_at)
ORDER BY day;

Проблема: если в какой-то день не было заказов — строки просто не будет. В аналитике это почти всегда ошибка, потому что отсутствие строки не равно ноль значений.

Попытка через LEFT JOIN сама по себе не помогает — без таблицы дат нечего достраивать. Правильный подход — сначала явно сгенерировать календарь, а потом присоединить данные.

В PostgreSQL для этого есть generate_series:

WITH calendar AS (
    SELECT generate_series(
        DATE '2026-01-01',
        DATE '2026-01-10',
        INTERVAL '1 day'
    )::date AS day
)
SELECT
    c.day,
    COUNT(o.id) AS orders_count
FROM calendar c
LEFT JOIN orders o
  ON DATE(o.created_at) = c.day
GROUP BY c.day
ORDER BY c.day;

Теперь: каждый день присутствует; если заказов нет — COUNT(o.id) вернёт 0.

Почему именно COUNT(o.id), а не COUNT(*): COUNT(*) посчитает строку календаря даже без совпадений — всегда ≥ 1; COUNT(o.id) считает только реальные заказы — корректный 0 при отсутствии данных.

Ещё один важный момент — условие в JOIN: ON DATE(o.created_at) = c.day. Так писать удобно, но это ломает использование индекса по created_at.

Лучше диапазон:

ON o.created_at >= c.day
AND o.created_at <  c.day + INTERVAL '1 day'

Это позволяет использовать индекс и ускоряет запрос на больших таблицах.

Расширение задачи — накопительный итог по дням (используется тот же CTE calendar):

SELECT
    c.day,
    COUNT(o.id) AS orders_count,
    SUM(COUNT(o.id)) OVER (ORDER BY c.day) AS running_total
FROM calendar c
LEFT JOIN orders o
  ON o.created_at >= c.day
 AND o.created_at <  c.day + INTERVAL '1 day'
GROUP BY c.day
ORDER BY c.day;

Если нужно ограничение по периоду по данным, а не вручную:

WITH bounds AS (
    SELECT
        MIN(created_at)::date AS min_day,
        MAX(created_at)::date AS max_day
    FROM orders
),
calendar AS (
    SELECT generate_series(min_day, max_day, INTERVAL '1 day')::date AS day
    FROM bounds
)
SELECT ...

Календарь строится автоматически по данным. Если created_at — timestamptz, границы дня зависят от timezone.

🔥 Если в отчёте есть время — сначала формируйте ось времени, потом присоединяйте данные. Иначе вы работаете не с нулями, а с отсутствием строк, что даёт искажённую картину.

➡️ SQL Ready | #практика

😍 SQL шпаргалка для начинающих — база по работе с бд!

Удобный и понятный справочник, где разобраны основные SQL-запросы и конструкции: SELECT, WHERE, JOIN, INSERT, UPDATE и другие ключевые команды. Всё объясняется простым языком с примерами, чтобы быстро понять логику работы с данными и начать применять это в реальных задачах

📌 Оставляю ссылочку: ermita.one

➡️ SQL Ready | #ресурс

BUFFERS: как увидеть цену запроса?

Обычный EXPLAIN ANALYZE показывает время выполнения, но почти ничего не говорит о том, сколько данных было прочитано с диска и из памяти.

EXPLAIN (ANALYZE, BUFFERS)
SELECT ...

Опция BUFFERS добавляет статистику по страницам памяти:
shared hit — страницы найдены в PostgreSQL shared buffers.
shared read — страницы пришлось загрузить в shared buffers; это может быть физический диск или OS page cache.

Buffers: shared hit=15000 read=2

Такой запрос почти полностью работает из памяти, что хорошо.

А здесь видно узкое место: запрос массово читает диск, даже если по времени более менее.

Buffers: shared hit=10 read=15000

🔥 Два запроса с одинаковым execution time могут иметь абсолютно разную нагрузку на систему.

➡️ SQL Ready | #совет

📂 Напоминалка по Data Engineering и аналитической архитектуре!

Например, Data Warehouse хранит уже очищенные и структурированные данные для BI и отчетности, Data Lake позволяет складировать сырые данные любого типа и обрабатывать их по мере необходимости, а Data Mesh распределяет владение данными между бизнес-доменами и превращает данные в полноценные data products.

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

Сохрани, чтобы не потерять!

➡️ SQL Ready | #ресурс

Почему NOT IN может вернуть пустой результат из-за NULL!

Одна из самых неприятных ловушек SQL — поведение NOT IN при наличии NULL. Запрос выглядит абсолютно корректно, но внезапно перестаёт возвращать строки.

Таблицы:

users(id)
bans(user_id)

Допустим, нужно получить пользователей, которых нет в bans. Часто пишут так:

SELECT *
FROM users
WHERE id NOT IN (
    SELECT user_id
    FROM bans
);

Пока в bans.user_id нет NULL — всё работает нормально. Но представим данные:

bans
-------
1
2
NULL

Теперь запрос внезапно вернет:

0 rows

Хотя пользователи без бана есть. Почему так происходит — SQL сравнивает условие примерно как:

id <> 1
AND id <> 2
AND id <> NULL

Но:

id <> NULL

не даёт TRUE или FALSE. Результат: UNKNOWN. А в WHERE проходят только TRUE. Из-за этого всё условие целиком перестаёт выполняться.

Это особенность трёхзначной логики SQL: TRUE, FALSE, UNKNOWN

Любое сравнение с NULL даёт UNKNOWN:

NULL = 1
NULL <> 1
NULL = NULL

Поэтому NOT IN с NULL внутри подзапроса становится опасным.

Безопасный вариант — NOT EXISTS:

SELECT *
FROM users u
WHERE NOT EXISTS (
    SELECT 1
    FROM bans b
    WHERE b.user_id = u.id
);

Почему EXISTS работает нормально: сравнение идёт построчно; NULL не ломает всю проверку; оптимизатор обычно хорошо превращает это в anti-join.

Ещё вариант — явно убрать NULL:

SELECT *
FROM users
WHERE id NOT IN (
    SELECT user_id
    FROM bans
    WHERE user_id IS NOT NULL
);

Но на практике: NOT EXISTS обычно считается более безопасным и читаемым решением.

Отдельный момент: NOT IN () и NOT EXISTS могут давать разные планы выполнения в зависимости от СУБД. Но логически для nullable данных: NOT EXISTS почти всегда предпочтительнее.

Быстрая проверка проблемы:

SELECT COUNT(*)
FROM bans
WHERE user_id IS NULL;

Если такие строки есть — NOT IN уже потенциально опасен.

🔥 NOT IN и NULL плохо сочетаются. Если в подзапросе появляется хотя бы один NULL, условие может перестать возвращать строки вообще. Для таких проверок надёжнее использовать NOT EXISTS.

➡️ SQL Ready | #практика

❤️ SQL DEV — большая база для изучения SQL и PostgreSQL!

Здесь собрано огромное количество материалов по SQL: запросы, JOIN’ы, подзапросы, оконные функции, индексы, оптимизация и работа с PostgreSQL. Репозиторий отлично подходит как для изучения базы, так и для углубления в более сложные темы. Особенно полезно то, что здесь много практических примеров и разборов реальных SQL-конструкций.

Оставляю ссылочку: GitHub 📱

➡️ SQL Ready | #репозиторий

📂 Напоминалка по оптимизации баз данных!

Например, индексы ускоряют поиск данных, а репликация помогает распределять нагрузку и повышать отказоустойчивость.

На картинке — 9 основных подходов для улучшения производительности базы данных, которые полезно держать под рукой.

Сохрани, чтобы не потерять!

➡️ SQL Ready | #ресурс

PostgreSQL может избежать полной сортировки таблицы при ORDER BY ... LIMIT!

Большинство думает, что ORDER BY всегда сортирует вообще всю таблицу. Но в PostgreSQL для LIMIT есть отдельная оптимизация — Top-N Heap Sort.

SELECT *
FROM orders
ORDER BY created_at DESC
LIMIT 10;

Если нужен только top-10 результат, PostgreSQL не обязан сортировать миллионы строк полностью. Вместо этого он держит в памяти только N лучших строк во время scan.

Это видно прямо в execution plan:

Sort Method: top-N heapsort

Особенно интересно становится на огромных таблицах, где полный sort мог бы уйти на диск:

SET work_mem = '4MB';

EXPLAIN ANALYZE
SELECT *
FROM events
ORDER BY created_at DESC
LIMIT 50;

Даже при маленьком work_mem PostgreSQL может избежать полной сортировки всех строк и работать заметно быстрее именно благодаря оптимизации Top-N.

А если добавить подходящий индекс:

CREATE INDEX idx_events_created_at
ON events (created_at DESC);

🔥 PostgreSQL вообще сможет обойтись без Sort и просто сделать Index Scan в нужном порядке.

➡️ SQL Ready | #совет

Почему индекс может не использоваться, даже если он есть!

Очень частая ситуация: индекс создан, запрос написан вроде нормально, но SQL всё равно делает Seq Scan или Full Table Scan.

Имеем такую таблицу:

users(
    id,
    email,
    created_at
)

Индекс:

CREATE INDEX idx_users_email
ON users(email);

Кажется, что такой запрос точно должен использовать индекс:

SELECT *
FROM users
WHERE email = 'test@example.com';

И обычно действительно будет Index Scan.

Но достаточно небольшой детали — и индекс может перестать использоваться. Например:

SELECT *
FROM users
WHERE LOWER(email) = 'test@example.com';

Проблема в том, что индекс построен по колонке: email. А в условии используется выражение:

LOWER(email)

Для оптимизатора это уже не то же самое условие. В итоге серверу часто приходится: применять LOWER() к строкам; сравнивать результат; читать гораздо больше данных, чем ожидалось.

Исправляется это expression/functional index:

CREATE INDEX idx_users_email_lower
ON users(LOWER(email));

То же самое часто происходит с датами:

SELECT *
FROM orders
WHERE DATE(created_at) = '2025-01-10';

Из-за:

DATE(created_at)

обычный индекс по created_at может не помочь, потому что функция применяется к колонке.

Правильнее писать диапазон:

SELECT *
FROM orders
WHERE created_at >= '2025-01-10'
  AND created_at <  '2025-01-11';

Так условие остаётся sargable — то есть пригодным для эффективного использования индекса.

Ещё одна частая проблема — преобразования типов. Например, плохо:

WHERE user_id::text = '100'

Если user_id — integer, то здесь преобразование применяется к колонке. В такой ситуации обычный индекс по user_id может не использоваться.

Правильнее:

WHERE user_id = 100

Важно: простое условие вида:

WHERE user_id = '100'

в некоторых СУБД может нормально привести литерал к integer и всё равно использовать индекс. Проблема чаще начинается там, где преобразуется сама колонка или выражение становится сложнее.

Популярная ошибка с LIKE:

WHERE email LIKE '%gmail.com'

Здесь обычный B-Tree индекс обычно бесполезен. Так как поиск начинается не с начала строки; сервер не может эффективно использовать упорядоченность индекса.

Если таблица маленькая: 100–1000 строк, то Full Scan может быть дешевле, чем прыжки по индексу.

🔥 Наличие индекса ещё не гарантирует его использование. Функции над колонками, преобразования типов, неправильные LIKE, OR-условия и устаревшая статистика могут сделать индекс бесполезным или менее выгодным для оптимизатора.

➡️ SQL Ready | #практика

😎 SQL Cheatsheet — удобная шпаргалка для повседневной работы!

Этот репозиторий хорошо подойдёт тем, кто постоянно работает с базами данных и хочет быстро освежать в памяти нужные SQL-конструкции. Здесь всё подано компактно и по делу: запросы, JOIN’ы, агрегации, подзапросы и др. Особенно удобно использовать для подготовки к собеседованиям.

Оставляю ссылочку: GitHub 📱

➡️ SQL Ready | #репозиторий

🎓 PostgreSQL должен быть спроектирован до первого инцидента.

В enterprise-среде PostgreSQL — это уже не просто база данных, а часть критичной инфраструктуры с требованиями к доступности, восстановлению, безопасности и мониторингу.

На курсе «Архитектура PostgreSQL для корпоративных систем» разбираем, как строить устойчивую PostgreSQL-инфраструктуру под реальные корпоративные нагрузки.

📌 В фокусе курса:
• High Availability (высокая доступность)
• Disaster Recovery (аварийное восстановление)
• failover-сценарии
• RPO/RTO
• резервирование и мониторинг
• архитектурные ошибки и точки отказа

🐾 АИСыч напоминает: б бы «Backup — это не стратегия. Стратегия — это проверенное восстановление».

На курсе отдельно разбираем, как проектировать PostgreSQL-инфраструктуру так, чтобы система переживала сбои без потери критичных данных.

🎁 Для наших подписчиков действует скидка 20% по промокоду: SQLREADY20
Записаться на курс прямо сейчас

А ещё больше практики, ИИ и ИБ — в MAX Академии, где сейчас проходит розыгрыш курса за 1 рубль 🔥


Реклама АНО ДПО ЦПК "АИС", ИНН: 7720346012, erid: 2SDnjdvRDWz