Знали, что NOT IN — главный источник тихих багов, если в подзапросе есть NULL?

Этот запрос выглядит логично, но опасен:

WHERE user_id NOT IN (SELECT id FROM users);

Если подзапрос вернёт хотя бы один NULL, условие станет UNKNOWN, и не вернётся ни одной строки.

Правильнее и безопаснее паттерн NOT EXISTS:

WHERE NOT EXISTS (SELECT 1 FROM users u WHERE u.id = orders.user_id);

Он корректно работает при NULL, не ломает логику и читается однозначно.

Хотите повторить? Проверьте разницу сами:

CREATE TABLE users(id int);
INSERT INTO users VALUES (1), (2), (NULL);

Теперь запустите:

SELECT 1 AS test WHERE 3 NOT IN (SELECT id FROM users);

Результат будет пустым.

🔥 А если переписать через NOT EXISTS, логика вернётся в норму.

➡️ SQL Ready | #совет

📂 Напоминалка про Modem vs Router!

Модем отвечает за подключение к провайдеру и получение публичного IP, а роутер управляет локальной сетью: маршрутизирует трафик, выполняет NAT и раздаёт адреса устройствам.

На картинке — ключевые отличия и базовая схема работы.

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

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

Всех с наступающим 2026 годом! 🎄

Поставлю себе цель: набрать более 20 тысяч подписчиков ✍️

Партицирование в оконных функциях — когда нужно работать с топами внутри групп!

Оконные функции в SQL — стандартный инструмент аналитики. Один из частых кейсов: найти «лучшие» записи внутри каждой группы, не сворачивая таблицу и не теряя строки.

Представим таблицу:

products(id, category, price)

Нужно выбрать самый дорогой товар в каждой категории, но при этом видеть все колонки строки:

SELECT *
FROM (
    SELECT
        *,
        ROW_NUMBER() OVER (PARTITION BY category ORDER BY price DESC, id DESC) AS rn
    FROM products
) t
WHERE rn = 1;

PARTITION BY формирует независимые окна для каждой категории.
ROW_NUMBER() нумерует строки внутри каждой партиции, а не по всей таблице.

Если нужны не только первые, а, например, топ-3 в каждой категории:

SELECT id, category, price
FROM (
    SELECT
        id, category, price,
        ROW_NUMBER() OVER (PARTITION BY category ORDER BY price DESC, id DESC) AS rn
    FROM products
) t
WHERE rn <= 3
ORDER BY category, price DESC;

Тут важно: без PARTITION BY запрос взял бы топ-3 по всей таблице, а не по категориям.

Оконные функции не требуют GROUP BY, потому что не агрегируют (не схлопывают) строки, а дополняют их аналитическими метками.

Ещё полезный трюк — находить максимум в группе без GROUP BY и JOIN, через коррелированный подзапрос:

SELECT *
FROM products
WHERE price = (
    SELECT MAX(price)
    FROM products p2
    WHERE p2.category = products.category
);

Этот запрос не агрегирует основную таблицу и вернёт несколько строк, если в категории есть товары с одинаковой максимальной ценой (ties).

🔥 Используйте PARTITION BY в оконных функциях, когда логика должна применяться внутри каждой группы независимо, а строки нужно сохранить целиком.

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

UPDATE без холостых перезаписей!

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

IS DISTINCT FROM сравнивает значения NULL-безопасно и без UNKNOWN:

AND u.name IS DISTINCT FROM 'Alice';

Если name уже Alice — условие ложно, и строка не обновляется вообще.

Это правило можно применить к любым колонкам:

AND u.email IS DISTINCT FROM EXCLUDED.email;

Паттерн остаётся тем же: обновление только при расхождении.

Проверьте сами на тесте:

CREATE TABLE users(id int PRIMARY KEY, name text);
INSERT INTO users VALUES (1, 'Bob');

Запустите 2 раза UPDATE сверху, второй раз таблица не изменится и ничего не запишет.

🔥 UPDATE должен менять только то, что отличается и SQL уже даёт для этого инструменты.

➡️ SQL Ready | #совет

😎 PopSQL Learn — быстрый и структурный старт в SQL!

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

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

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

Транзакции в SQL — почему частичные изменения хуже ошибки!

Работа с несколькими связанными таблицами в одном сценарии должна быть атомарной. Без TRANSACTION при автокоммите каждый UPDATE фиксируется отдельно — и есть риск получить несогласованное состояние.

Таблицы:

wallet(user_id, balance)
payments(id, user_id, amount, status)

Сценарий: списать баланс и перевести платёж в done.

Если соединение обрывается между запросами:

UPDATE wallet SET balance = balance - 100 WHERE user_id = 7;
-- сбой соединения тут
UPDATE payments SET status = 'done' WHERE id = 55;

Первое изменение уже сохранено, второе — нет. Итог: деньги списаны, платёж не подтверждён.

Правильный подход — транзакция:

BEGIN;
UPDATE wallet SET balance = balance - 100 WHERE user_id = 7;
UPDATE payments SET status = 'done' WHERE id = 55;
COMMIT;

До COMMIT изменения видны только в текущей сессии и не становятся устойчивыми. Если все шаги успешны — фиксируется сразу всё.

Откат при ошибке:

BEGIN;
UPDATE wallet SET balance = balance - 100 WHERE user_id = 7;
UPDATE payments SET status = 'done' WHERE id = 55;
ROLLBACK;

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

Нюанс для защиты от гонок и повторной обработки:

UPDATE wallet
  SET balance = balance - 100
  WHERE user_id = 7 AND balance >= 100;

UPDATE payments
  SET status = 'done'
  WHERE id = 55 AND status = 'pending';

Оба UPDATE выполняем в одной транзакции, затем проверяем rowcount: если любой запрос затронул 0 строк — ROLLBACK и обработка как ошибка.

🔥 SELECT ... FOR UPDATE также работает только в той же транзакции, где будет обновление. Любая операция списания + фиксации платежа = транзакция.

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

📂 Напоминалка по HTTP-стеку для разработки и инфраструктуры!

Например, HTTP/2 ускоряет загрузку за счёт мультиплексирования, а HTTP/3 делает обмен ещё быстрее, используя QUIC поверх UDP — уже стандарт для современных браузеров и CDN.

На картинке — ключевые компоненты HTTP-экосистемы, которые важно держать под рукой.

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

➡ SQL Ready | #ресурс

Транзакция, которая берёт только свободные строки!

В конкурентной обработке задач важно не брать строку, уже заблокированную другой транзакцией, и не ждать её освобождения.

PostgreSQL делает это через:

FOR UPDATE SKIP LOCKED

Строки, которые уже залочены, исключаются из выборки немедленно, без ожидания.

Хотите повторить интерактивно? Откройте 2 SQL-сессии:
Сессия A:

BEGIN;
SELECT id FROM jobs WHERE status='queued' FOR UPDATE;

Сессия B (параллельно):

BEGIN;
SELECT id FROM jobs WHERE status='queued' FOR UPDATE SKIP LOCKED LIMIT 1;

B никогда не вернёт строку, залоченную A, и не будет ждать, вы увидите разные результаты в разных сессиях.

🔥 База данных сама может быть механизмом синхронизации, если выборка делается с SKIP LOCKED. Нет двойной обработки, ожиданий и внешних зависимостей.

➡️ SQL Ready | #совет

❤️ 30-Days-of-SQL — тридцатидневный челлендж в обучении!

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

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

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

Find + Update в одном проходе!

Найдём строки с невозможными значениями и сразу подготовим их к UPDATE:

WITH c AS (SELECT id FROM products WHERE price < 0 LIMIT 3)

CTE c вернёт проблемные id.

Теперь обновим только найденные строки, не дублируя условие в клиенте:

UPDATE products SET price = 0

Ссылаемся на выборку из CTE, чтобы не рассинхронизировать find/update:

WHERE id IN (SELECT id FROM c);

Попробуйте сами на тестовой таблице:

CREATE TABLE products(id int PRIMARY KEY, price int);
INSERT INTO products VALUES (1,-10),(2,-5),(3,100);

Запустите find+update снова и убедитесь, что исправление точечное и атомарное.

🔥 Экономит время выравнивания таблиц при интеграциях, корректировки классификаторов или миграций и др.

➡️ SQL Ready | #совет

❤️ SQL-EX — интерактивный тренажёр с задачами!

Если хочешь учиться через практику, этот сайт отличный инструмент. Здесь ты пишешь запросы прямо в браузере, получаешь мгновенную обратную связь и видишь результат. Подойдёт для закрепления теории, подготовки к собеседованию или реальных задач в работе с бд.

📌 Оставляю ссылочку: sql-ex.ru

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

Сравнение наборов и вычисление пересечения по ключу!

Нужно быстро получить пересечение двух таблиц по ключу? Используйте JOIN по колонке, которая логически должна совпадать в обоих наборах:

JOIN table_b b ON a.id = b.id

Выберите только ключи, чтобы исключить лишние проекции и ускорить анализ наборов:

SELECT a.id

Проверьте сами на интерактивном примере:

CREATE TABLE table_a(id int);
CREATE TABLE table_b(id int);
INSERT INTO table_a VALUES (1),(2),(3);
INSERT INTO table_b VALUES (2),(3),(4);

Повторите исходный JOIN, вы увидите только 2,3 как пересечение наборов.

🔥 Пригодится, когда нужно сверить итерации, найти общие сущности перед миграциями и тд.

➡️ SQL Ready | #совет

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

Например, Skiplist ускоряет поиск в памяти, Hash-индекс даёт доступ за O(1), а B-tree и LSM-дерево оптимизируют работу с диском и записью.

На картинке — 8 структур данных, которые стоит держать под рукой, чтобы понимать, как устроены индексы и хранение в БД.

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

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

UNION и UNION ALL — когда строки исчезают без ошибок!

UNION удаляет дубликаты по всем выбранным колонкам, сравнивая строки целиком, поэтому результат может отличаться от ожиданий.

SELECT message FROM logs_app
UNION
SELECT message FROM logs_system;

Одинаковые message схлопнутся в одну строку, даже если это разные события — ошибки не будет.

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

SELECT message FROM logs_app
UNION ALL
SELECT message FROM logs_system;

Для логов полезно явно добавлять источник:

SELECT 'app' AS src, id, message FROM logs_app
UNION ALL
SELECT 'system' AS src, id, message FROM logs_system
ORDER BY src, id;

Пересечение (INTERSECT) в MySQL не поддерживается, альтернатива:

SELECT DISTINCT a.message
FROM logs_app a
WHERE EXISTS (SELECT 1 FROM logs_system s WHERE s.message = a.message)
LIMIT 10;

Если хотите увидеть, какие строки пропадут при UNION из-за совпадений между таблицами, используйте UNION ALL и проверяйте строки, встречающиеся в обоих источниках:

SELECT message, COUNT(*) AS cnt, COUNT(DISTINCT src) AS sources
FROM (
    SELECT message, 'app' AS src FROM logs_app
    UNION ALL
    SELECT message, 'system' AS src FROM logs_system
) t
GROUP BY message
HAVING sources > 1;

🔥 UNION — когда нужна дедупликация, UNION ALL — когда важна каждая строка и производительность.

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

☕️ Наткнулся на любопытную статью — «Embedded SQL с группировкой запросов: элегантный подход к управлению SQL в Go»!

В этой статье:
• Автор показывает, как хранить и группировать SQL-запросы в одном .sql-файле по сущностям;
• Рассказывается, как использовать go:embed для встраивания этих файлов в бинарник и загружать запросы по имени;
• Представлен парсер, который разбирает .sql с именованными секциями;
• Показаны преимущества подхода: подсветка SQL в IDE, чистый Go-код и др.

🔊 Продолжайте читать на Habr!

➡️ SQL Ready | #статья

Как выполнять сложные data-миграции, не ломая UNIQUE-ограничения?

Иногда нужно массово менять данные, временно нарушая UNIQUE, но итоговое состояние корректно:

BEGIN;

Включаем отложенную проверку конкретного ограничения, оно проверится только при COMMIT:

SET CONSTRAINTS users_email_uniq DEFERRED;

Теперь можно выполнять UPDATE/INSERT, даже если в процессе появляются дубликаты:

UPDATE users
SET email = lower(email);

Фиксация происходит один раз, если финальное состояние валидно, транзакция коммитится:

COMMIT;

Если уникальность нарушена в конце будет ROLLBACK, без частичных изменений.

🔥 Отложенные ограничения позволяют безопасно менять данные внутри транзакции, сохраняя целостность и контроль без временного снятия UNIQUE.

➡️ SQL Ready | #совет

💡 ThoughtSpot SQL Tutorial — продуктивное обучение и практика!

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

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

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

Оконные фреймы (ROWS и RANGE) — управление областью расчёта!

В оконных функциях важны не только PARTITION BY и ORDER BY, но и то, какие строки попадают в окно вычисления. За это отвечают оконные фреймы — ROWS и RANGE.

Таблица операций:

transactions(id, user_id, amount, created_at)

Накопительная сумма по пользователю:

SUM(amount) OVER (
  PARTITION BY user_id
  ORDER BY created_at
)

При наличии ORDER BY и отсутствии явного фрейма в большинстве СУБД используется RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW.

Если значения created_at совпадают, сумма считается сразу по группе строк (peers).

Среднее по последним 3 операциям:

AVG(amount) OVER (
  PARTITION BY user_id
  ORDER BY created_at, id
  ROWS BETWEEN 2 PRECEDING AND CURRENT ROW
)

ROWS формирует окно по количеству строк. Детерминированный ORDER BY необходим для воспроизводимого результата.

Сумма за последние 7 дней (пример для PostgreSQL):

SUM(amount) OVER (
  PARTITION BY user_id
  ORDER BY created_at
  RANGE BETWEEN INTERVAL '7 days' PRECEDING AND CURRENT ROW
)

RANGE формирует окно по значениям ORDER BY. Поддержка и синтаксис интервалов зависят от СУБД; часто допускается только одно выражение в ORDER BY.

🔥 Важно помнить: ROWS — предсказуем по количеству строк, RANGE — удобен для временных интервалов и peer-групп, неявный фрейм может менять результат вычислений

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