ITMy statistics
SQL Quiz
410 SQL questions in 35 topics (Junior — 157, Middle — 174, Senior — 79). Pick topics, a level and how many questions you want; every answer comes with an explanation.
SELECT and filtering, JOINs, GROUP BY and aggregates, subqueries, NULL, window functions, indexes and transactions.
All SQL questions 410
Tap an option to check yourself, or "Show answer".
Learn step by step: SQL: from the First Query to Pro150 lessons · theory, examples and exercisesStudy a topic with the course lessons (34)
- Типы данных: 7. Типы данных: обзор, 28. Автоинкремент: IDENTITY и последовательности, 73. Дата и время: типы, 76. Приведение типов
- NULL: 8. NULL: значение «неизвестно», 15. Работа с NULL: IS NULL и COALESCE, 35. Агрегаты и NULL
- SELECT и WHERE: 11. Столбцы и псевдонимы, 12. Фильтрация: WHERE, 14. IN, BETWEEN и LIKE, 38. Порядок выполнения запроса
- Псевдонимы и DISTINCT: 11. Столбцы и псевдонимы, 18. DISTINCT: уникальные значения
- Операторы и выражения: 13. AND, OR, NOT и приоритет, 14. IN, BETWEEN и LIKE, 19. Выражения и простые функции
- Сортировка и LIMIT: 16. Сортировка: ORDER BY, 17. LIMIT и OFFSET
- CASE и функции: 19. Выражения и простые функции, 39. Условная агрегация: CASE внутри SUM, 59. CASE: условные выражения, 71. Строковые функции
- INSERT, UPDATE, DELETE: 21. INSERT: добавление строк, 22. UPDATE: изменение строк, 23. DELETE: удаление строк, 29. TRUNCATE и DELETE: в чём разница
- DDL и ограничения: 24. CREATE TABLE, 25. Ограничения: PRIMARY KEY, NOT NULL, UNIQUE, CHECK, DEFAULT, 26. ALTER TABLE и DROP TABLE, 86. Целостность данных на уровне базы
- Ключи и связи: 27. Внешние ключи, 28. Автоинкремент: IDENTITY и последовательности, 82. Связи «один ко многим» и «многие ко многим», 84. Ключи: естественные и суррогатные
- GROUP BY и агрегаты: 31. Агрегатные функции: COUNT, SUM, AVG, MIN, MAX, 32. GROUP BY, 34. COUNT(DISTINCT) и варианты COUNT, 35. Агрегаты и NULL
- HAVING: 33. HAVING: фильтр по группам
- JOIN: 41. Зачем нужны JOIN, 42. INNER JOIN, 43. LEFT JOIN, 44. RIGHT JOIN и FULL JOIN
- Подзапросы: 49. Поиск «без пары»: анти-соединения, 51. Скалярные подзапросы, 52. IN и EXISTS с подзапросами, 53. Коррелированные подзапросы
- CTE и рекурсия: 55. CTE: WITH, 56. Рекурсивные CTE
- UNION и множества: 57. UNION, INTERSECT, EXCEPT
- Оконные функции: 61. Оконные функции: идея, 62. PARTITION BY и ORDER BY в окне, 63. ROW_NUMBER, RANK, DENSE_RANK, 64. LAG и LEAD
- Аналитические запросы: 64. LAG и LEAD, 65. Накопительные итоги и рамки окна, 69. Пропуски и острова, 70. Практикум: аналитика пользователей
- Даты и строки: 71. Строковые функции, 73. Дата и время: типы, 74. Функции дат: сдвиги, обрезка, разница
- JSON в базе: 77. JSON в SQL
- Нормализация: 81. Нормализация: 1НФ, 2НФ, 3НФ, 85. Денормализация: когда и зачем
- Проектирование схемы: 82. Связи «один ко многим» и «многие ко многим», 83. ER-диаграммы, 85. Денормализация: когда и зачем, 86. Целостность данных на уровне базы
- Индексы: 91. Как работают индексы, 92. B-tree индекс, 93. Составные индексы, 100. Практикум: ускоряем запрос
- Индексы: продвинутое: 93. Составные индексы, 99. Частичные индексы и индексы по выражениям
- Оптимизация запросов: 94. EXPLAIN и EXPLAIN ANALYZE, 95. Чтение плана запроса, 97. Типичные причины медленных запросов, 100. Практикум: ускоряем запрос
- Найдите ошибку в запросе: 97. Типичные причины медленных запросов, 145. Антипаттерны SQL
- MVCC и обслуживание: 98. Статистика, ANALYZE и VACUUM, 106. MVCC: многоверсионность
- Транзакции и блокировки: 101. ACID, 102. Транзакции: BEGIN, COMMIT, ROLLBACK, 103. Уровни изоляции, 104. Блокировки
- Представления и процедуры: 111. Представления (VIEW), 112. Материализованные представления, 113. Функции на PL/pgSQL, 115. Триггеры
- PostgreSQL: 113. Функции на PL/pgSQL, 117. UPSERT: INSERT ... ON CONFLICT, 119. Полнотекстовый поиск, 144. Другие диалекты: MySQL, SQL Server, Oracle, SQLite
- Масштабирование и репликация: 120. Партиционирование таблиц, 133. Репликация: обзор
- Безопасность и права: 121. SQL-инъекции и параметризованные запросы, 131. Пользователи, роли и права, 136. Безопасность сервера базы данных
- MySQL и InnoDB: 144. Другие диалекты: MySQL, SQL Server, Oracle, SQLite
- Практические задачи: 148. Сборник задач для тренировки
SELECT и WHERE7
В каком порядке СУБД логически обрабатывает предложения запроса
SELECT?- SELECT → FROM → WHERE → GROUP BY → HAVING → ORDER BY → LIMIT
- FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT
- FROM → WHERE → SELECT → GROUP BY → HAVING → ORDER BY → LIMIT
- FROM → SELECT → WHERE → GROUP BY → ORDER BY → HAVING → LIMIT
Сначала определяется источник строк (
FROM), затем они фильтруются (WHERE), группируются (GROUP BY/HAVING), и только потом вычисляется список SELECT; ORDER BY и LIMIT работают с уже готовым результатом. Порядок написания (SELECT первым) не совпадает с порядком выполнения — отсюда, например, недоступность алиасов в WHERE.Найдите ошибку в запросе: нужно вывести отделы, где больше двух сотрудников.
SELECT dept_id, COUNT(*)
FROM employees
WHERE COUNT(*) > 2
GROUP BY dept_id;GROUP BYдолжен стоять передWHERE- У
COUNT(*)обязательно должен быть алиас - Ошибки нет, запрос вернёт отдел 1
- Агрегатную функцию нельзя использовать в
WHERE— условие надо перенести вHAVING
WHERE фильтрует отдельные строки до группировки, когда агрегаты ещё не посчитаны, поэтому COUNT(*) там запрещён. Условия по агрегатам пишут в HAVING COUNT(*) > 2, который выполняется после GROUP BY.Сколько строк вернёт запрос?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT COUNT(*) FROM employees
WHERE dept_id = NULL;- 1
- 6
- 0
- Ошибка синтаксиса
Сравнение с NULL через
= даёт не TRUE, а UNKNOWN (NULL), а WHERE пропускает только строки с TRUE, поэтому не подходит ни одна строка. Чтобы найти Gleb, нужно писать WHERE dept_id IS NULL — тогда получится 1.Сколько строк вернёт запрос?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT COUNT(*) FROM employees
WHERE salary > 3500 OR salary <= 3500;- 6
- 0
- 4
- 5
Для Dina
salary равен NULL, и оба сравнения дают UNKNOWN, а UNKNOWN OR UNKNOWN = UNKNOWN — строка отфильтровывается. «Условие-тавтология» в SQL не гарантирует возврат всех строк, если в столбце есть NULL.Какие сотрудники попадут в результат?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT name FROM employees
WHERE salary BETWEEN 3000 AND 4000;- Boris, Vera, Gleb, Egor
- Boris, Gleb, Egor
- Только Vera
- Boris, Vera, Gleb, Dina, Egor
BETWEEN a AND b включает обе границы: это salary >= 3000 AND salary <= 4000. Dina не попадает — её salary NULL, сравнение даёт UNKNOWN.Какие имена из списка Anna, Boris, Olga, Tom подходят под условие
name LIKE '_o%'?- Boris, Olga, Tom
- Olga
- Boris, Tom
- Только Boris
_ означает ровно один любой символ, % — любую (в том числе пустую) последовательность. Шаблон требует, чтобы вторая буква была o: Boris и Tom подходят, а у Olga O стоит первой.Сколько строк посчитает запрос?
-- products.price: 5, 10, 15, 20
SELECT COUNT(*)
FROM products
WHERE price BETWEEN 20 AND 10;- 2 — порядок границ в
BETWEENне важен - 0 — это то же, что
price >= 20 AND price <= 10 - Ошибка: нижняя граница больше верхней
- 4 — условие с перевёрнутыми границами игнорируется
x BETWEEN a AND b — всего лишь сокращение для x >= a AND x <= b. При a > b ни одно значение не удовлетворяет обоим условиям сразу, и СУБД не выдаёт ни ошибки, ни предупреждения — молча возвращает пустой результат. Ловушка типична, когда границы приходят из пользовательского ввода. В PostgreSQL есть BETWEEN SYMMETRIC, который сам упорядочивает границы; в MySQL их нужно поменять местами заранее (например, через LEAST/GREATEST).Псевдонимы и DISTINCT7
Что произойдёт при выполнении запроса в PostgreSQL 16 или MySQL 8?
SELECT name, salary * 12 AS annual
FROM employees
WHERE annual > 50000;- Ошибка: столбец
annualне найден - Вернутся сотрудники с годовой зарплатой больше 50000
- Вернётся пустой результат, так как
annualравен NULL - Запрос выполнится, но условие
WHEREбудет проигнорировано
WHERE логически выполняется до SELECT, поэтому алиас annual там ещё не существует — MySQL выдаст Unknown column 'annual' in 'where clause', PostgreSQL — column "annual" does not exist. Нужно повторить выражение: WHERE salary * 12 > 50000 или вынести вычисление в подзапрос/CTE. (SQLite такое допускает как нестандартное расширение.)Что вернёт запрос?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT COUNT(DISTINCT dept_id)
FROM employees;- 3
- 6
- 2
- 5
COUNT(DISTINCT col) считает различные НЕ-NULL значения: 1 и 2. NULL не учитывается — хотя SELECT DISTINCT dept_id вернул бы 3 строки (1, 2 и NULL).Сколько строк вернёт запрос?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT DISTINCT dept_id, salary
FROM employees;- 5
- 6
- 3
- 4
DISTINCT удаляет дубликаты по всей комбинации выбранных столбцов, а не по первому. Повторяется только пара (1, 3000) у Boris и Egor, поэтому из 6 строк остаётся 5; пары (NULL, 3000) и (2, NULL) — отдельные уникальные строки.Сколько строк вернёт запрос?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT DISTINCT manager_id
FROM employees;- 2 — NULL отбрасывается
- 6
- 4 — каждый NULL отдельно
- 3
Для
DISTINCT (как и для GROUP BY) все NULL считаются одинаковыми и схлопываются в одну строку: результат 1, 3 и NULL. Это отличается от сравнения NULL = NULL, которое даёт UNKNOWN.Что произойдёт в PostgreSQL 16?
SELECT DISTINCT dept_id
FROM employees
ORDER BY salary;- Отделы отсортируются по минимальной зарплате
- Отделы отсортируются по зарплате первой найденной строки
- Ошибка: при SELECT DISTINCT выражения ORDER BY должны быть в списке SELECT
- ORDER BY будет проигнорирован
После
DISTINCT одному dept_id соответствует несколько значений salary, и сортировать по ним однозначно нельзя, поэтому PostgreSQL выдаёт ошибку. Нужно либо добавить столбец в SELECT, либо сгруппировать и сортировать по агрегату: GROUP BY dept_id ORDER BY MIN(salary).Как по стандарту SQL (работает и в PostgreSQL) задать алиас столбца с пробелом?
SELECT salary AS 'Monthly pay'SELECT salary AS "Monthly pay"SELECT salary AS [Monthly pay]SELECT salary AS Monthly pay
В стандарте двойные кавычки обозначают идентификатор, а одинарные — строковый литерал; PostgreSQL на
AS '…' выдаст синтаксическую ошибку. Квадратные скобки — синтаксис SQL Server, MySQL также понимает обратные кавычки.Что произойдёт при выполнении запроса (PostgreSQL или MySQL)?
SELECT employees.name
FROM employees e
WHERE e.salary > 3000;- Ошибка: после задания алиаса к таблице надо обращаться через
e - Вернутся имена всех сотрудников, условие не применится
- Запрос выполнится, имя таблицы и алиас взаимозаменяемы
- Ошибка: алиас таблицы нельзя использовать в WHERE
Алиас в
FROM employees e заменяет имя таблицы во всём запросе, поэтому employees.name не распознаётся (MySQL: Unknown column 'employees.name', PostgreSQL: invalid reference to FROM-clause entry). Нужно писать e.name.NULL10
Каков результат выражения
NULL = NULL в SQL?- TRUE
- NULL (UNKNOWN)
- FALSE
- Ошибка выполнения
NULL означает «неизвестное значение», и два неизвестных нельзя признать равными или неравными — результат сравнения UNKNOWN, то есть NULL. Поэтому для проверки используют
IS NULL, а для NULL-безопасного сравнения — IS NOT DISTINCT FROM (PostgreSQL) или <=> (MySQL).Что вернёт запрос в MySQL 8 (TRUE/FALSE выводятся как 1/0)?
SELECT NULL AND FALSE, NULL OR TRUE, NOT NULL;- 0, 1, NULL
- NULL, NULL, NULL
- 0, 1, 1
- NULL, 1, NULL
В трёхзначной логике
UNKNOWN AND FALSE = FALSE (при любом значении неизвестного результат ложен), UNKNOWN OR TRUE = TRUE, а NOT UNKNOWN остаётся UNKNOWN. Ошибка — считать, что любой NULL «заражает» всё выражение: для AND/OR это не так.Какие отделы вернёт запрос «отделы без сотрудников»?
-- departments: (1, IT), (2, Sales), (3, HR)
-- employees.dept_id: 1, 1, 2, NULL, 2, 1
SELECT name FROM departments
WHERE id NOT IN (SELECT dept_id FROM employees);- HR
- IT, Sales
- Ни одного
- IT, Sales, HR
id NOT IN (1, 2, NULL) раскрывается в id <> 1 AND id <> 2 AND id <> NULL; последнее сравнение всегда UNKNOWN, поэтому всё выражение не бывает TRUE. Один NULL в подзапросе под NOT IN «обнуляет» результат — это классическая ловушка.Какой вариант корректно вернёт HR — отдел без сотрудников, — если
employees.dept_id может быть NULL (данные как в предыдущем примере)?WHERE id NOT IN (SELECT DISTINCT dept_id FROM employees)WHERE NOT EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id)WHERE id <> ALL (SELECT dept_id FROM employees)WHERE id NOT IN (SELECT COALESCE(dept_id, NULL) FROM employees)
NOT EXISTS проверяет лишь наличие строк, и строка с NULL просто не совпадает по e.dept_id = d.id, поэтому HR возвращается. DISTINCT оставляет NULL в списке, <> ALL эквивалентен NOT IN, а COALESCE(dept_id, NULL) ничего не меняет. Альтернатива — добавить в подзапрос WHERE dept_id IS NOT NULL.Что вернёт выражение?
SELECT COALESCE(NULL, NULL, 'x', 'y');- NULL
- 'y'
- 'x'
- 'xy'
COALESCE возвращает первый аргумент, не равный NULL, и дальше не смотрит. Это стандартная функция; IFNULL/NVL — её частные двухаргументные аналоги в отдельных СУБД.Что будет во втором столбце для Dina (
salary = NULL)?SELECT name, salary + 500
FROM employees
WHERE id = 5;- 500
- NULL
- 0
- Ошибка: нельзя складывать с NULL
Любая арифметическая операция с NULL даёт NULL: неизвестное плюс 500 — тоже неизвестное. Если отсутствие зарплаты надо считать нулём, пишут
COALESCE(salary, 0) + 500 — получится 500.Что вернёт запрос в PostgreSQL 16?
SELECT 10 / NULLIF(0, 0);- NULL
- 0
- 10
- Ошибку division by zero
NULLIF(a, b) возвращает NULL, если a = b, иначе a. Деление на NULL даёт NULL вместо ошибки — это стандартный приём защиты от деления на ноль: total / NULLIF(cnt, 0). Без NULLIF PostgreSQL выдал бы ошибку division by zero (а MySQL — NULL с предупреждением).Что вернёт запрос?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT COUNT(*), COUNT(salary)
FROM employees;- 6 и 6
- 5 и 5
- 6 и 0
- 6 и 5
COUNT(*) считает строки целиком, а COUNT(столбец) — только строки, где значение не NULL. У Dina salary NULL, поэтому второй результат 5.Что вернёт
AVG(salary)?-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT AVG(salary) FROM employees;- 3000
- 3600
- NULL
- 18000
Агрегатные функции (кроме
COUNT(*)) игнорируют NULL: сумма 18000 делится на 5 непустых значений, а не на 6 строк. Если NULL нужно считать нулём, пишут AVG(COALESCE(salary, 0)) — получится 3000.Что вернёт запрос?
SELECT CASE NULL
WHEN NULL THEN 'yes'
ELSE 'no'
END;- 'no'
- 'yes'
- NULL
- Ошибка синтаксиса
Простой
CASE x WHEN v сравнивает через x = v, а NULL = NULL — UNKNOWN, поэтому ветка не срабатывает и выполняется ELSE. Для проверки на NULL нужен поисковый CASE: CASE WHEN x IS NULL THEN ….Типы данных10
В MySQL 8 столбец
created_at имеет тип DATETIME. Попадёт ли строка с created_at = '2024-01-31 10:00:00' в результат?SELECT * FROM orders
WHERE created_at BETWEEN '2024-01-01' AND '2024-01-31';- Да, BETWEEN включает 31 января целиком
- Нет, BETWEEN не работает с датами — нужна ошибка
- Да, время при сравнении DATETIME с датой отбрасывается
- Нет: граница превращается в 2024-01-31 00:00:00
Строка
'2024-01-31' при сравнении с DATETIME становится полуночью 31 января, поэтому всё, что позже 00:00:00 этого дня, отсекается. Надёжный шаблон — полуоткрытый интервал: created_at >= '2024-01-01' AND created_at < '2024-02-01'.Чем
CHAR(10) отличается от VARCHAR(10)?- CHAR хранит до 10 байт, VARCHAR — до 10 символов
- CHAR дополняет значение пробелами до 10 символов, VARCHAR хранит строку как есть
- CHAR не может содержать цифры
- Разницы нет, это синонимы
CHAR(n) — строка фиксированной длины: короткое значение дополняется пробелами (при сравнении и выводе хвостовые пробелы обычно игнорируются/обрезаются). VARCHAR(n) хранит фактическую длину до n. CHAR оправдан для кодов фиксированной длины вроде 'USD'.Что верно про
VARCHAR(n) и TEXT в PostgreSQL 16?- Хранятся одинаково и по скорости не отличаются; VARCHAR(n) лишь проверяет длину
- VARCHAR быстрее, потому что длина ограничена
- TEXT нельзя индексировать
- TEXT хранится вне строки и всегда медленнее VARCHAR
В PostgreSQL
text, varchar и varchar(n) используют одно и то же внутреннее представление; единственное отличие varchar(n) — проверка максимальной длины при записи. Документация прямо рекомендует text или varchar без ограничения, если лимит не нужен по бизнес-логике. (В MySQL TEXT и VARCHAR действительно различаются.)Какой тип лучше подходит для хранения денежных сумм?
- FLOAT
- DOUBLE PRECISION
- REAL
- DECIMAL(12, 2)
DECIMAL/NUMERIC хранит число точно в десятичном виде, поэтому 0.10 + 0.20 даёт ровно 0.30. FLOAT/DOUBLE/REAL — двоичные числа с плавающей точкой, многие десятичные дроби в них представимы лишь приближённо, и ошибки округления накапливаются в суммах.Что вернёт запрос в MySQL 8?
SELECT 0.1 + 0.2 = 0.3;- NULL
- 0
- 1
- 0.30000000000000004
В MySQL литералы вида
0.1 имеют тип DECIMAL (точная арифметика), поэтому сумма ровно 0.3 и сравнение даёт 1. С плавающей точкой было бы иначе: например, в SQLite такие литералы — REAL, и тот же запрос вернёт 0.Какое максимальное значение помещается в столбец
DECIMAL(5, 2)?- 99999.99
- 999.99
- 99.999
- 99999
Первый параметр — общее число значащих цифр (precision), второй — сколько из них после запятой (scale). 5 цифр, из них 2 дробные, значит 3 целые: максимум 999.99. Попытка записать больше вызовет ошибку (в строгом режиме MySQL и в PostgreSQL).
Что вернёт
CAST('2024-03-15 14:30:00' AS DATE)?- 2024-03-15
- 2024-03-15 00:00:00
- NULL — у даты не может быть времени
- 14:30:00
Тип DATE хранит только календарную дату без времени, поэтому при приведении время отбрасывается. Если нужна дата со временем — TIMESTAMP (PostgreSQL) / DATETIME или TIMESTAMP (MySQL).
Что вернёт
SELECT '10' < '9'; (MySQL выводит TRUE как 1)?- Ошибка приведения типов
- 0 — 10 больше 9
- NULL
- 1 — строки сравниваются посимвольно
Оба операнда — строки, поэтому сравнение лексикографическое: первый символ
'1' меньше '9', и '10' < '9' истинно. Отсюда «странная» сортировка номеров, хранящихся в VARCHAR: 1, 10, 2, … Числа нужно хранить в числовых типах.Что вернёт
SELECT 'abc' = 'ABC'; в MySQL 8 (кодировка по умолчанию utf8mb4) и в PostgreSQL 16?- TRUE в обеих СУБД
- FALSE в обеих СУБД
- MySQL — 1, PostgreSQL — false
- MySQL — 0, PostgreSQL — true
Сравнение строк определяется collation. Коллация MySQL 8 по умолчанию
utf8mb4_0900_ai_ci нечувствительна к регистру (ci) и к акцентам (ai), поэтому строки равны. В PostgreSQL обычные коллации чувствительны к регистру; без учёта регистра сравнивают через lower(), ILIKE или тип citext.Что произойдёт при выполнении запроса в PostgreSQL 16?
SELECT 2147483647 + 1;- Вернётся 2147483648 — тип автоматически расширится до
bigint - Вернётся -2147483648 — значение «перевалит» через границу диапазона
- Ошибка
integer out of range - Вернётся NULL
Целочисленный литерал, помещающийся в 4 байта, имеет в PostgreSQL тип
integer, и сумма двух integer тоже integer. Значение 2147483648 в него не помещается, а PostgreSQL не расширяет тип и не «заворачивает» значение молча, а бросает ошибку integer out of range. Чтобы получить 2147483648, приведите операнд: 2147483647::bigint + 1. На ту же ошибку натыкаются счётчики и id типа INT, подобравшиеся к 2³¹ − 1.Операторы и выражения9
Как найти строки, где
discount_text содержит символ % буквально (например, «50%»)?WHERE discount_text LIKE '%%%'WHERE discount_text LIKE '%!%%' ESCAPE '!'WHERE discount_text = '%'WHERE discount_text LIKE '%[%]%'— работает во всех СУБД
В
LIKE знак % — метасимвол, поэтому его экранируют: ESCAPE '!' объявляет ! экранирующим, и !% означает буквальный процент. Синтаксис [%] есть только в SQL Server, а = сравнивает строку целиком без шаблонов. В MySQL и PostgreSQL по умолчанию экранирующий символ — обратный слэш.Какие сотрудники попадут в результат?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT name FROM employees
WHERE dept_id = 1 OR dept_id = 2 AND salary > 3500;- Anna, Boris, Vera, Egor
- Только Vera
- Anna, Vera
- Anna, Boris, Vera, Dina, Egor
AND имеет более высокий приоритет, чем OR, поэтому условие читается как dept_id = 1 OR (dept_id = 2 AND salary > 3500): все из отдела 1 плюс Vera. Dina не проходит, т. к. NULL > 3500 — UNKNOWN. Если имелось в виду «отделы 1 или 2 с зарплатой больше 3500», нужны скобки.Нужны сотрудники отделов 1 или 2 с зарплатой больше 3500. Какое условие правильное?
WHERE dept_id = 1 OR 2 AND salary > 3500WHERE dept_id = 1 OR dept_id = 2 AND salary > 3500WHERE dept_id = (1 OR 2) AND salary > 3500WHERE dept_id IN (1, 2) AND salary > 3500
IN (1, 2) эквивалентен (dept_id = 1 OR dept_id = 2) уже со скобками, поэтому AND применяется к обоим отделам. Без скобок AND связывается сильнее OR, а 1 OR 2 — это логическое выражение, а не «список значений».Что вернёт запрос в PostgreSQL 16?
SELECT 'Hi ' || NULL AS a,
CONCAT('Hi ', NULL) AS b;- a = 'Hi ', b = 'Hi '
- a = NULL, b = 'Hi '
- a = NULL, b = NULL
- a = 'Hi ', b = NULL
Оператор
|| следует общему правилу: операция с NULL даёт NULL. Функция CONCAT в PostgreSQL игнорирует NULL-аргументы. Осторожно: в MySQL всё иначе — там CONCAT('Hi ', NULL) возвращает NULL, а NULL пропускает только CONCAT_WS.Что вернёт запрос в MySQL 8 с настройками
sql_mode по умолчанию?SELECT 'a' || 'b';- 0
- NULL
- 'ab'
- Синтаксическую ошибку
В MySQL
|| по умолчанию — синоним логического OR (устаревший), а не конкатенация: строки 'a' и 'b' приводятся к числу 0, и 0 OR 0 = 0. Конкатенацией || становится только с режимом PIPES_AS_CONCAT (или ANSI); переносимо — CONCAT('a', 'b').Что вернёт
SELECT 5 / 2; в PostgreSQL 16 и в MySQL 8?- 2.5 в обеих СУБД
- 2 в обеих СУБД
- PostgreSQL — 2.5, MySQL — 2
- PostgreSQL — 2, MySQL — 2.5000
В PostgreSQL (и SQLite, SQL Server) деление двух целых — целочисленное, дробная часть отбрасывается. В MySQL
/ всегда даёт десятичный результат, а целочисленное деление делается оператором DIV. Чтобы получить 2.5 в PostgreSQL, приводят один операнд: 5 / 2.0 или 5::numeric / 2.Что вернёт
SELECT -7 / 2; в PostgreSQL 16?- -4
- -3.5
- -3
- 3
Целочисленное деление в PostgreSQL усекает результат в сторону нуля (как в C), а не округляет вниз: -3.5 → -3. Ожидание -4 — привычка из Python, где
// округляет к минус бесконечности.Что вернёт запрос в MySQL 8?
SELECT NULL <=> NULL, 1 <=> NULL, NULL = NULL;- NULL, NULL, NULL
- 1, 0, NULL
- 1, NULL, NULL
- 1, 0, 1
<=> — NULL-безопасное равенство MySQL: оно всегда возвращает 1 или 0, считая два NULL равными. Обычное = с NULL даёт NULL. Стандартный аналог, доступный в PostgreSQL, — IS NOT DISTINCT FROM.Что вернёт запрос в PostgreSQL 16?
SELECT ROUND(2.5) AS a,
ROUND(-2.5) AS b,
ROUND(2.345, 2) AS c;- a = 3, b = -3, c = 2.35
- a = 2, b = -2, c = 2.34 — половина округляется к чётному
- a = 3, b = -2, c = 2.35 — половина округляется вверх
- a = 3, b = -3, c = 2.34
Литералы
2.5 и 2.345 в PostgreSQL имеют тип numeric — точное десятичное число, и для него ROUND округляет половину от нуля: 2.5 → 3, -2.5 → -3, 2.345 → 2.35. Для double precision результат может быть другим: ROUND(2.5::float8) обычно даёт 2 (половина к чётному), а 2.345 в двоичном виде вообще не представимо точно. Поэтому денежные расчёты ведут в numeric, а не во float.Сортировка и LIMIT10
Запрос
SELECT name FROM employees ORDER BY dept_id; (у Gleb dept_id = NULL). Где окажется Gleb?- Первым и в PostgreSQL, и в MySQL
- Последним и в PostgreSQL, и в MySQL
- В PostgreSQL — первым, в MySQL — последним
- В PostgreSQL — последним, в MySQL — первым
Стандарт оставляет положение NULL на усмотрение СУБД. PostgreSQL (и Oracle) считает NULL больше любого значения — при ASC они в конце; MySQL и SQLite считают NULL меньше — при ASC они в начале. В PostgreSQL порядок задаётся явно через
NULLS FIRST / NULLS LAST.В MySQL 8 нет
NULLS LAST. Как отсортировать dept_id по возрастанию, но с NULL в конце?ORDER BY dept_id NULLS LASTORDER BY COALESCE(dept_id, 0)ORDER BY dept_id IS NULL, dept_idORDER BY dept_id DESC
dept_id IS NULL даёт 0 для обычных строк и 1 для NULL, поэтому NULL уходят в конец, а второй ключ сортирует остальные. NULLS LAST в MySQL — синтаксическая ошибка, COALESCE(…, 0) поставит NULL в начало, а DESC просто перевернёт порядок.Что вернёт запрос?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT name, salary FROM employees
WHERE salary IS NOT NULL
ORDER BY 2 DESC, 1
LIMIT 3;- Ошибка: в ORDER BY нельзя писать числа
- Anna, Vera, Egor
- Anna, Boris, Dina
- Anna, Vera, Boris
ORDER BY 2 означает «по второму столбцу списка SELECT» (salary), 1 — по name. Среди трёх зарплат 3000 по алфавиту первый Boris. Позиционная сортировка допустима, но хрупка: при изменении списка столбцов смысл меняется молча.Что означает
ORDER BY dept_id, salary DESC?- Оба столбца сортируются по убыванию
- salary — по убыванию, затем dept_id по возрастанию
- dept_id — по возрастанию, внутри отдела salary — по убыванию
- Ошибка: DESC нужно указать для каждого столбца
Направление
ASC/DESC относится только к ближайшему ключу сортировки; без указания действует ASC. Второй ключ упорядочивает строки только внутри групп с одинаковым первым.Что вернёт запрос?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT name FROM employees
WHERE salary IS NOT NULL
ORDER BY salary DESC, id
LIMIT 2 OFFSET 1;- Anna, Vera
- Vera, Boris
- Boris, Gleb
- Vera, Gleb
Порядок: Anna (5000), Vera (4000), Boris (3000, id 2), Gleb, Egor.
OFFSET 1 пропускает одну строку, LIMIT 2 берёт следующие две — Vera и Boris.Какие строки вернёт в MySQL
SELECT id FROM t ORDER BY id LIMIT 3, 2;, если в t id от 1 до 6?- 4, 5
- 3, 4
- 1, 2, 3
- 2, 3, 4
В MySQL форма
LIMIT смещение, количество — сначала смещение: пропустить 3, взять 2. Это то же, что LIMIT 2 OFFSET 3; путаница порядка аргументов — частая ошибка.Что верно про
OFFSET 10 ROWS FETCH FIRST 5 ROWS ONLY?- Это синтаксис только PostgreSQL
- Он работает только без ORDER BY
- Это синтаксис MySQL, аналог LIMIT 10, 5
- Это стандарт SQL; PostgreSQL его поддерживает, а MySQL 8 — нет
FETCH FIRST … ROWS ONLY введён в стандарт SQL:2008 и поддерживается PostgreSQL, Oracle 12c+, SQL Server (с ORDER BY). LIMIT/OFFSET — нестандартное, но популярное расширение; MySQL 8 понимает только его.Что верно про
SELECT * FROM employees LIMIT 3; без ORDER BY?- Вернутся 3 строки с наименьшими id
- Вернутся 3 последние вставленные строки
- Вернутся какие-то 3 строки, порядок не гарантирован
- Запрос выдаст ошибку
Таблица в реляционной модели — неупорядоченное множество; без
ORDER BY СУБД возвращает строки в любом удобном ей порядке, и он может меняться от плана запроса. Для стабильной пагинации нужен ORDER BY по уникальному ключу.Сколько строк вернёт запрос в PostgreSQL 16?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT name FROM employees
ORDER BY salary
FETCH FIRST 1 ROWS WITH TIES;- 1
- 3
- 5
- 0 — WITH TIES требует LIMIT
WITH TIES добавляет к выборке все строки, равные последней по ключу ORDER BY. Минимальная зарплата 3000 у Boris, Gleb и Egor, поэтому вернутся три строки (NULL Dina в PostgreSQL при ASC идёт в конце). Без ORDER BY WITH TIES использовать нельзя.В каком порядке выведутся имена?
-- employees:
-- id | name | dept_id | salary | manager_id
-- 1 | Anna | 1 | 5000 | NULL
-- 2 | Boris | 1 | 3000 | 1
-- 3 | Vera | 2 | 4000 | 1
-- 4 | Gleb | NULL | 3000 | 3
-- 5 | Dina | 2 | NULL | 3
-- 6 | Egor | 1 | 3000 | 1
SELECT name FROM employees
ORDER BY CASE WHEN dept_id = 2 THEN 0 ELSE 1 END,
name;- Dina, Vera, Anna, Boris, Egor, Gleb
- Anna, Boris, Dina, Egor, Gleb, Vera
- Vera, Dina, Anna, Boris, Egor, Gleb
- Gleb, Dina, Vera, Anna, Boris, Egor
Сортировать можно по любому выражению:
CASE даёт 0 для отдела 2 и 1 для остальных (для NULL условие не TRUE — тоже 1), а внутри групп сортировка по имени. Так поднимают «приоритетные» строки наверх.JOIN14
Сколько строк вернёт запрос?
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT COUNT(*)
FROM customers c
JOIN orders o ON o.customer_id = c.id;- 3
- 2
- 4
- 9
JOIN (он же INNER JOIN) оставляет только пары строк, для которых условие ON истинно: у Анны два заказа, у Бориса один — итого 3. Вера без заказов в результат не попадает; 9 получилось бы при CROSS JOIN.Сколько строк вернёт запрос?
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT COUNT(*)
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id;- 3
- 4
- 6
- 9
LEFT JOIN возвращает все совпавшие пары (3 строки: 2 для Анны и 1 для Бориса) плюс по одной строке для каждой строки левой таблицы без пары — Веру с NULL в столбцах orders. Итого 4: левая таблица не «ограничивает» число строк сверху, у клиента с несколькими заказами строк будет несколько.В
customers 3 строки, в orders 3 строки. Что вернёт SELECT COUNT(*) FROM customers CROSS JOIN orders?- 3
- 6
- 9
- Ошибка: нет условия ON
CROSS JOIN — декартово произведение: каждая строка первой таблицы сочетается с каждой строкой второй, 3 × 3 = 9. Условие ON для него не нужно; 6 — частая ошибка, когда количества складывают вместо умножения.Какой запрос эквивалентен
SELECT * FROM a RIGHT JOIN b ON a.id = b.a_id (с точностью до порядка столбцов)?SELECT * FROM a LEFT JOIN b ON a.id = b.a_idSELECT * FROM b JOIN a ON a.id = b.a_idSELECT * FROM a FULL JOIN b ON a.id = b.a_idSELECT * FROM b LEFT JOIN a ON a.id = b.a_id
RIGHT JOIN сохраняет все строки правой таблицы — это то же самое, что LEFT JOIN с переставленными таблицами. Поэтому на практике RIGHT JOIN почти всегда переписывают через LEFT JOIN: так запрос читается слева направо от «главной» таблицы.В таблице
orders есть заказ с customer_id = NULL. Попадёт ли он в результат customers c JOIN orders o ON o.customer_id = c.id?- Нет: сравнение с NULL даёт UNKNOWN
- Да, в паре с каждым клиентом
- Да, в паре с клиентом, у которого
idтоже NULL - Нет, запрос завершится ошибкой
Условие
o.customer_id = c.id при NULL даёт UNKNOWN, а JOIN оставляет только пары, где условие TRUE. Даже NULL = NULL — это не TRUE, поэтому строки с NULL-ключом не соединяются ни с чем (чтобы их увидеть, нужен внешний JOIN со стороны orders).Что вернёт запрос?
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT c.name, o.id
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.status = 'paid';- Анна 10; Борис 12; Вера NULL
- Анна 10; Борис 12
- Анна 10; Анна 11; Борис 12; Вера NULL
- Анна 10; Борис 12; Анна NULL
Классическая ловушка:
WHERE выполняется после соединения, и у Веры o.status равен NULL, поэтому условие = 'paid' её отбрасывает. Фильтр по правой таблице в WHERE фактически превращает LEFT JOIN во INNER JOIN; чтобы сохранить всех клиентов, условие нужно перенести в ON.Что вернёт запрос?
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT c.name, o.id
FROM customers c
LEFT JOIN orders o
ON o.customer_id = c.id AND o.status = 'paid';- Анна 10; Борис 12
- Анна 10; Анна NULL; Борис 12; Вера NULL
- Анна 10; Борис 12; Вера NULL
- Анна 10; Анна 11; Борис 12; Вера NULL
Условие в
ON влияет только на то, какие заказы «подцепятся», а все строки левой таблицы LEFT JOIN сохраняет в любом случае. У Анны подходит только заказ 10 (заказ 11 — new), лишней строки «Анна NULL» не будет, потому что одна пара для неё нашлась; Вера остаётся с NULL.Сколько строк вернёт запрос?
SELECT COUNT(*)
FROM (SELECT 1 AS id UNION ALL SELECT 1 UNION ALL SELECT 2) a
JOIN (SELECT 1 AS id UNION ALL SELECT 1 UNION ALL SELECT 3) b
ON a.id = b.id;- 2
- 3
- 1
- 4
Каждая из двух строк
a со значением 1 соединяется с каждой из двух строк b со значением 1: 2 × 2 = 4. JOIN по неуникальному ключу размножает строки — так и появляются «дубли» после соединения с таблицей «один-ко-многим» или «многие-ко-многим».Сколько строк вернёт self join?
-- employees(id, name, manager_id):
-- (1,'Ольга',NULL), (2,'Пётр',1), (3,'Иван',1), (4,'Мария',2)
SELECT e.name, m.name AS manager
FROM employees e
JOIN employees m ON m.id = e.manager_id;- 3
- 4
- 2
- 16
Self join — это обычный JOIN таблицы с самой собой под разными псевдонимами. Пару «сотрудник — руководитель» нашли Пётр, Иван и Мария; у Ольги
manager_id равен NULL, и INNER JOIN её отбрасывает. Чтобы вывести и её (с manager = NULL), нужен LEFT JOIN.Как получить результат
FULL OUTER JOIN в MySQL 8?- Написать
FULL OUTER JOIN— MySQL 8 его поддерживает LEFT JOIN...UNION...RIGHT JOINс теми же таблицамиLEFT JOIN...UNION ALL...LEFT JOINс теми же таблицами- Использовать
CROSS JOINс условием вWHERE
MySQL (включая 8.x) не поддерживает
FULL [OUTER] JOIN — это синтаксическая ошибка. Его эмулируют объединением LEFT JOIN и RIGHT JOIN через UNION, который уберёт совпавшие пары, попавшие в обе половины. С UNION ALL совпавшие строки задвоятся (если только во второй половине не отфильтровать их через WHERE a.id IS NULL).Что вернёт запрос?
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
-- order_items(order_id, product_id, qty):
-- (10,1,2), (10,2,1), (12,1,5)
SELECT c.name, o.id, i.product_id
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
JOIN order_items i ON i.order_id = o.id;- 4 строки, включая «Вера NULL NULL»
- 4 строки, включая «Анна 11 NULL»
- 3 строки, Веры среди них нет
- 5 строк: все заказы и все клиенты
Соединения выполняются слева направо: после
LEFT JOIN у Веры o.id = NULL, а следующий INNER JOIN с условием i.order_id = o.id такие строки отбрасывает — как и заказ 11 без позиций. Остаются Анна 10 (×2 товара) и Борис 12. Чтобы сохранить клиентов без заказов, второй JOIN тоже должен быть LEFT.Сколько строк вернёт запрос?
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT COUNT(*)
FROM customers c
LEFT JOIN orders o
ON o.customer_id = c.id AND c.city = 'Минск';- 2
- 3
- 1
- 4
Условие на левую таблицу в
ON не фильтрует её строки: LEFT JOIN всё равно вернёт каждого клиента. Анна (Минск) получит 2 заказа, а Борис и Вера — по одной строке с NULL, итого 4. Чтобы оставить только клиентов из Минска, условие c.city = ... нужно писать в WHERE.Какой запрос правильно находит клиентов без заказов (anti-join)?
... LEFT JOIN orders o ON o.customer_id = c.id WHERE o.id IS NULL... LEFT JOIN orders o ON o.customer_id = c.id WHERE o.id = NULL... JOIN orders o ON o.customer_id = c.id WHERE o.id IS NULL... LEFT JOIN orders o ON o.customer_id = c.id AND o.id IS NULL
Anti-join через
LEFT JOIN: соединяем и оставляем строки, где у правой таблицы нет пары — её ключ (NOT NULL-столбец, например PK) равен NULL. = NULL никогда не бывает TRUE, после INNER JOIN NULL-строк не остаётся, а условие IS NULL в ON лишь не даст присоединить ни один заказ и вернёт всех клиентов.В таблице
a 3 строки, таблица b пуста. Что вернёт запрос (PostgreSQL 16 / MySQL 8 / SQLite)?SELECT
(SELECT COUNT(*) FROM a CROSS JOIN b) AS c1,
(SELECT COUNT(*) FROM a LEFT JOIN b ON TRUE) AS c2;- c1 = 3, c2 = 3
- c1 = 0, c2 = 3
- c1 = 0, c2 = 0
- c1 = 3, c2 = 0
Декартово произведение с пустой таблицей пусто: каждой строке
a не с чем составить пару, 3 × 0 = 0. То же относится к неявному соединению через запятую FROM a, b — классическая ловушка, когда необязательная таблица (настройки, справочник) оказывается пустой и запрос внезапно ничего не возвращает. LEFT JOIN сохраняет все строки левой таблицы, заполняя столбцы b значениями NULL, поэтому строк остаётся 3.GROUP BY и агрегаты14
Что вернёт запрос?
SELECT COUNT(*), COUNT(x), COUNT(DISTINCT x)
FROM (SELECT 10 AS x UNION ALL SELECT 10
UNION ALL SELECT NULL UNION ALL SELECT 40) t;- 4, 4, 3
- 4, 3, 2
- 3, 3, 2
- 4, 3, 3
COUNT(*) считает строки (4), COUNT(x) — только не-NULL значения (3), COUNT(DISTINCT x) — различные не-NULL значения (10 и 40, то есть 2). NULL не считается ни отдельным значением, ни «ещё одним различным».Что вернёт
AVG(x)?SELECT AVG(x)
FROM (SELECT 10 AS x UNION ALL SELECT 10
UNION ALL SELECT NULL UNION ALL SELECT 40) t;- 15
- NULL
- 20
- 60
Агрегатные функции (кроме
COUNT(*)) игнорируют NULL: AVG = 60 / 3 = 20, а не 60 / 4 = 15. Если NULL нужно считать нулём, пишут AVG(COALESCE(x, 0)). NULL в результате был бы только при отсутствии не-NULL значений.Что вернёт запрос, если отменённых заказов нет?
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT COUNT(*), SUM(amount)
FROM orders
WHERE status = 'cancelled';- 0 и 0
- Ни одной строки
- NULL и NULL
- 0 и NULL
Агрегат без
GROUP BY всегда возвращает ровно одну строку, даже по пустому набору. COUNT по пустому набору даёт 0, а SUM, AVG, MIN, MAX — NULL. Поэтому в отчётах пишут COALESCE(SUM(amount), 0).Сколько строк вернёт запрос?
SELECT city, COUNT(*)
FROM (SELECT 'Минск' AS city UNION ALL SELECT 'Гомель'
UNION ALL SELECT NULL UNION ALL SELECT NULL
UNION ALL SELECT 'Минск') t
GROUP BY city;- 3
- 2
- 4
- 5
В
GROUP BY все NULL попадают в одну группу, хотя NULL = NULL в условиях не TRUE. Группы: Минск (2), Гомель (1), NULL (2) — итого 3 строки. Ответ 4 — частое заблуждение, что каждый NULL образует свою группу.Что вернёт запрос для Веры?
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT c.name, COUNT(*) AS cnt
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name;- 0
- 1
- NULL
- Вера не попадёт в результат
После
LEFT JOIN у Веры есть одна строка (с NULL в столбцах orders), а COUNT(*) считает строки — получается 1. Чтобы посчитать именно заказы, нужно COUNT(o.id): он пропускает NULL и даст 0.Что вернёт запрос?
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT c.name, SUM(o.amount) AS total
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name;- Анна 300; Борис 50; Вера 0
- Анна 300; Борис 50
- Анна 300; Борис 50; Вера NULL
- Анна 100; Борис 50; Вера NULL
У Веры в группе только одна строка с
o.amount = NULL, а SUM по одним NULL возвращает NULL, а не 0. Для отчёта используют COALESCE(SUM(o.amount), 0). Строку Веры сохраняет LEFT JOIN, а у Анны суммируются оба заказа: 100 + 200.Что вернёт запрос (условная агрегация)?
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT customer_id,
SUM(CASE WHEN status = 'paid' THEN amount ELSE 0 END) AS paid,
SUM(amount) AS total
FROM orders
GROUP BY customer_id;- (1, 300, 300), (2, 50, 50)
- (1, 100, 100), (2, 50, 50)
- (1, 100, 300), (2, 0, 50)
- (1, 100, 300), (2, 50, 50)
SUM(CASE ...) считает сумму только по строкам, подходящим под условие, а остальные даёт 0 — так в одном проходе получают несколько «срезов» без лишних подзапросов. Фильтр в WHERE убрал бы неоплаченные заказы и из total тоже.Что вернёт запрос в PostgreSQL?
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT COUNT(*) FILTER (WHERE status = 'paid') AS paid_cnt,
COUNT(*) AS all_cnt
FROM orders;- 2 и 3
- Ошибка синтаксиса: FILTER не существует
- 3 и 3
- 2 и 2
FILTER (WHERE ...) — стандартный SQL-синтаксис условной агрегации, поддерживаемый PostgreSQL (и SQLite 3.30+): условие применяется только к этому агрегату. Это то же, что SUM(CASE WHEN status = 'paid' THEN 1 ELSE 0 END). В MySQL 8 FILTER нет — там пишут SUM(status = 'paid') или CASE.Что произойдёт в MySQL 8 с настройками
sql_mode по умолчанию?-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT customer_id, status, SUM(amount)
FROM orders
GROUP BY customer_id;- Вернётся статус первого заказа каждого клиента
- Ошибка: столбец
statusне в GROUP BY и не агрегирован - Вернётся статус последнего заказа
- Группировка пойдёт по
customer_idиstatus
С MySQL 5.7 в
sql_mode по умолчанию включён ONLY_FULL_GROUP_BY: в SELECT можно указывать только столбцы из GROUP BY, агрегаты или функционально зависимые от ключа группировки столбцы — иначе ошибка 1055. Старые версии без этого режима возвращали произвольное (не «первое») значение. Исправление — агрегировать (MAX(status)) или использовать ANY_VALUE(status).Нужна сумма
amount по заказам, у которых есть позиции (это заказы 10 и 12: 100 + 50 = 150). Что вернёт запрос?-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
-- order_items(order_id, product_id, qty):
-- (10,1,2), (10,2,1), (12,1,5)
SELECT SUM(o.amount)
FROM orders o
JOIN order_items i ON i.order_id = o.id;- 150
- 350
- 250
- 300
«Fan-out»: JOIN с дочерней таблицей размножает строку заказа на число его позиций — заказ 10 встречается дважды, и
SUM получает 100 + 100 + 50 = 250. Сначала агрегируйте/отфильтруйте детали (подзапрос, EXISTS) и только потом суммируйте поля родителя; SUM(DISTINCT o.amount) — не исправление, он схлопнет разные заказы с одинаковой суммой.Целочисленный столбец
x содержит значения 1 и 2. Что вернёт SELECT SUM(x) / COUNT(x) FROM t в SQLite/PostgreSQL и в MySQL?- 1.5 везде
- 1 везде
- 1.5 в SQLite/PostgreSQL, 1 в MySQL
- 1 в SQLite/PostgreSQL, 1.5000 в MySQL
В SQLite и PostgreSQL деление целого на целое — целочисленное, и 3 / 2 = 1. В MySQL оператор
/ всегда даёт дробный результат (1.5000), а целочисленное деление — это DIV. Поэтому для среднего лучше использовать AVG(x) или явно приводить тип (SUM(x)::numeric / COUNT(x)).Что вернёт запрос в MySQL?
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT status, SUM(amount) AS s
FROM orders
GROUP BY status WITH ROLLUP;- 3 строки: new 200; paid 150; NULL 350
- 2 строки: new 200; paid 150
- 3 строки: new 200; paid 150; total 350
- 4 строки: new 200; paid 150; NULL 150; NULL 350
WITH ROLLUP (в стандарте и PostgreSQL — GROUP BY ROLLUP(status)) добавляет итоговые строки по каждому уровню группировки; в итоговой строке сгруппированный столбец равен NULL. Отличить такой NULL от настоящего NULL в данных помогает функция GROUPING(status) (MySQL 8.0+, PostgreSQL), возвращающая 1 для итоговой строки.Какие выражения по стандарту SQL можно указывать в
SELECT запроса с GROUP BY dept?- Любые столбцы таблицы
dept, агрегаты и выражения от них- Только агрегатные функции
- Только
dept
После группировки каждой группе соответствует одна строка, поэтому в
SELECT допустимы столбцы из GROUP BY, агрегатные функции и выражения из них (стандарт также разрешает столбцы, функционально зависимые от ключа группировки, например другие поля той же таблицы при группировке по её PK). Произвольный столбец неоднозначен — в группе может быть несколько разных значений.Таблица
orders пуста. Что вернут два запроса?SELECT COUNT(*) FROM orders; -- запрос 1
SELECT COUNT(*) FROM orders GROUP BY status; -- запрос 2- Оба вернут одну строку со значением 0
- Оба вернут пустой результат
- Запрос 1 — одну строку со значением 0, запрос 2 — ни одной строки
- Запрос 1 — одну строку со значением NULL, запрос 2 — одну строку со значением 0
Агрегат без
GROUP BY сворачивает всю выборку в одну группу, которая существует всегда, даже если строк нет, — поэтому COUNT(*) возвращает одну строку с 0 (а SUM или MAX — с NULL). С GROUP BY группы образуются только из имеющихся строк: нет строк — нет групп — нет и строк результата. Код, который ожидает от запроса с GROUP BY «всегда одну строку», на пустых данных получит пустой результат.HAVING6
Чем
WHERE отличается от HAVING?HAVINGфильтрует строки до группировки,WHERE— группы после- Ничем,
HAVING— устаревший синонимWHERE WHEREфильтрует строки до группировки,HAVING— группы послеHAVINGработает только с JOIN,WHERE— с одной таблицей
WHERE применяется к исходным строкам до GROUP BY и не может ссылаться на агрегаты. HAVING применяется к уже сформированным группам и обычно содержит условия на агрегаты (HAVING COUNT(*) > 1).В чём ошибка запроса?
SELECT customer_id, COUNT(*)
FROM orders
WHERE COUNT(*) > 1
GROUP BY customer_id;COUNT(*)нельзя указывать вSELECTвместе со столбцом- Нужно писать
COUNT(customer_id)вместоCOUNT(*) GROUP BYдолжен стоять передWHERE- Агрегат нельзя использовать в
WHERE— нужноHAVING COUNT(*) > 1
WHERE выполняется до группировки, когда агрегатов ещё нет, поэтому СУБД выдаёт ошибку (в MySQL — Invalid use of group function). Условие на агрегат переносится в HAVING после GROUP BY. Порядок WHERE → GROUP BY в запросе написан верно.Что вернёт запрос?
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT customer_id, COUNT(*)
FROM orders
GROUP BY customer_id
HAVING COUNT(*) > 1;- Одну строку: (1, 2)
- (1, 2) и (2, 1)
- Одну строку: (2, 1)
- Пустой результат
Сначала строки группируются: у клиента 1 два заказа, у клиента 2 — один.
HAVING оставляет только группы, где COUNT(*) > 1, то есть клиента 1.В
orders 3 строки. Что вернёт запрос SELECT COUNT(*) FROM orders HAVING COUNT(*) > 5?- Одну строку со значением 0
- Ни одной строки
- Одну строку со значением 3
- Ошибку: HAVING без GROUP BY
Без
GROUP BY вся таблица считается одной группой, и HAVING может её отфильтровать — тогда результат пустой (0 строк), а не строка с нулём. Это допустимо в стандарте, PostgreSQL, MySQL и SQLite 3.39+. 0 был бы при условии в WHERE, отсекающем все строки.Как поведёт себя запрос в MySQL 8 и в PostgreSQL 16?
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT customer_id, SUM(amount) AS total
FROM orders
GROUP BY customer_id
HAVING total > 100;- Ошибка в обеих СУБД
- Работает в обеих СУБД
- В MySQL работает, в PostgreSQL ошибка: столбец
totalне существует - В PostgreSQL работает, в MySQL ошибка
По логическому порядку
HAVING выполняется до SELECT, поэтому стандарт и PostgreSQL не видят там псевдонимов из списка выборки — нужно повторить выражение: HAVING SUM(amount) > 100. MySQL делает расширение и разрешает псевдонимы в HAVING. Переносимый вариант — всегда писать агрегат целиком.Каков логический порядок выполнения частей запроса
SELECT?- SELECT → FROM → WHERE → GROUP BY → HAVING → ORDER BY
- FROM → WHERE → HAVING → GROUP BY → SELECT → ORDER BY
- FROM → GROUP BY → WHERE → HAVING → SELECT → ORDER BY
- FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY
Сначала формируется набор строк (
FROM/JOIN), затем фильтруются строки (WHERE), строятся группы (GROUP BY), фильтруются группы (HAVING), вычисляется список выборки (SELECT, DISTINCT) и только потом сортировка и LIMIT. Поэтому псевдонимы из SELECT доступны в ORDER BY, но не в WHERE.Подзапросы11
Чем коррелированный подзапрос отличается от некоррелированного?
- Коррелированный ссылается на столбцы внешнего запроса
- Коррелированный всегда стоит в
FROM, некоррелированный — вWHERE - Коррелированный возвращает одно значение, некоррелированный — много
- Некоррелированный нельзя использовать с
IN
Коррелированный подзапрос использует значения текущей строки внешнего запроса (например,
WHERE o.customer_id = c.id), поэтому логически вычисляется для каждой внешней строки. Некоррелированный не зависит от внешнего запроса и может быть вычислен один раз. Место в запросе и количество возвращаемых значений тут ни при чём.Что вернёт запрос?
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT id
FROM orders
WHERE amount > (SELECT AVG(amount) FROM orders);- 10 и 11
- 11
- 12
- Ошибку: агрегат в WHERE
Скалярный подзапрос вычисляет среднее (100 + 200 + 50) / 3 ≈ 116.67, и условию удовлетворяет только заказ 11 (200). Ошибки нет: агрегат находится внутри подзапроса, а не напрямую в
WHERE внешнего запроса.Что вернёт запрос?
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT id, customer_id
FROM orders o
WHERE amount = (SELECT MAX(amount)
FROM orders o2
WHERE o2.customer_id = o.customer_id);- Только (11, 1)
- (10, 1), (11, 1) и (12, 2)
- (11, 1) и (12, 2)
- Ошибку: подзапрос возвращает несколько значений
Подзапрос коррелированный: для каждой строки он считает максимум по заказам того же клиента. Для клиента 1 это 200 (заказ 11), для клиента 2 — 50 (заказ 12). Если бы связи
o2.customer_id = o.customer_id не было, вернулся бы только глобальный максимум — заказ 11.Что произойдёт при выполнении запроса в MySQL 8 или PostgreSQL?
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT c.name,
(SELECT o.amount FROM orders o
WHERE o.customer_id = c.id) AS amount
FROM customers c;- Для Анны вернётся первая сумма — 100
- Для Анны вернутся две строки
- Для Анны вернётся NULL
- Ошибка: подзапрос вернул больше одной строки
Скалярный подзапрос обязан вернуть не больше одной строки; у Анны два заказа, поэтому MySQL выдаёт
Subquery returns more than 1 row, а PostgreSQL — more than one row returned by a subquery used as an expression. Для Веры (0 строк) было бы NULL. SQLite молча берёт первую строку — опасное поведение, на которое нельзя полагаться.Что вернёт запрос, если в
orders есть заказ с customer_id = NULL?-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders.customer_id: 1, 1, 2, NULL
SELECT name
FROM customers
WHERE id NOT IN (SELECT customer_id FROM orders);- Пустой результат
- Вера
- Вера и NULL
- Анна, Борис, Вера
3 NOT IN (1, 1, 2, NULL) раскрывается в 3 <> 1 AND 3 <> 2 AND 3 <> NULL, а последнее сравнение — UNKNOWN, поэтому всё условие не TRUE ни для одной строки. Это главная ловушка NOT IN: один NULL в подзапросе обнуляет результат. Используйте NOT EXISTS или добавьте WHERE customer_id IS NOT NULL.Что вернёт запрос, если в
orders есть заказ с customer_id = NULL?-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders.customer_id: 1, 1, 2, NULL
SELECT name
FROM customers c
WHERE NOT EXISTS (SELECT 1 FROM orders o
WHERE o.customer_id = c.id);- Пустой результат
- Вера
- Анна, Борис, Вера
- Ошибку: NULL в подзапросе
NOT EXISTS проверяет лишь, нашлась ли хотя бы одна строка: для Веры условие o.customer_id = 3 не TRUE ни для одной строки (в том числе для NULL), подзапрос пуст, и Вера попадает в результат. В отличие от NOT IN, NULL здесь ничего не ломает, поэтому для anti-join предпочитают NOT EXISTS.Влияет ли список столбцов в подзапросе
EXISTS (SELECT ... FROM orders WHERE ...) на результат?- Да, нужно писать
SELECT *, иначе условие всегда ложно - Да,
SELECT 1быстрее и возвращает другой результат - Нет,
EXISTSпроверяет только наличие хотя бы одной строки - Да, при
SELECT NULLусловие всегда ложно
EXISTS возвращает TRUE, если подзапрос вернул хотя бы одну строку, а значения в этих строках не важны — даже SELECT NULL даст TRUE. Писать SELECT 1 или SELECT * — дело вкуса; оптимизаторы современных СУБД их не различают.Сколько строк вернёт запрос и чем он отличается от
JOIN?-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT name
FROM customers
WHERE id IN (SELECT customer_id FROM orders);- 3 строки: Анна дважды, Борис
- 3 строки: Анна, Борис, Вера
- 1 строка: Анна
- 2 строки: Анна, Борис
IN (как и EXISTS) — это semi-join: строка внешней таблицы попадает в результат один раз, сколько бы совпадений ни было. Обычный JOIN с orders вернул бы Анну дважды (по числу заказов), и пришлось бы добавлять DISTINCT.Что вернёт запрос? (Заказов дороже 1000 нет — подзапрос пуст.)
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера',NULL)
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT name
FROM customers
WHERE 5 > ALL (SELECT amount FROM orders
WHERE amount > 1000);- Всех трёх клиентов:
> ALLпо пустому набору — TRUE - Ни одной строки: сравнение с пустым набором — UNKNOWN
- Одну строку с NULL
- Ошибку: подзапрос не вернул строк
x > ALL (...) истинно, если нет ни одного значения, для которого условие ложно, — для пустого набора это TRUE (а x > ANY (...) по пустому набору, наоборот, FALSE). Отсюда частый баг: «больше максимума» через > ALL пропускает всё при пустом подзапросе, а через > (SELECT MAX(...)) — ничего, ведь MAX пустого набора — NULL.Что произойдёт в MySQL 8 при выполнении
SELECT COUNT(*) FROM (SELECT customer_id FROM orders GROUP BY customer_id)?- Вернётся 2
- Ошибка: у производной таблицы должен быть псевдоним
- Вернётся 3
- Вернётся NULL
В MySQL каждый подзапрос в
FROM (derived table) обязан иметь псевдоним, иначе ошибка 1248 Every derived table must have its own alias; правильно — ... GROUP BY customer_id) t. В PostgreSQL до 15-й версии включительно псевдоним тоже был обязателен, а с PostgreSQL 16 его можно опустить.Каких клиентов вернёт запрос?
-- customers: (1, 'Анна'), (2, 'Борис'), (3, 'Вера')
-- orders.customer_id: 1, 1, 3
SELECT name
FROM customers c
WHERE EXISTS (SELECT NULL FROM orders o
WHERE o.customer_id = c.id);- Ни одного — подзапрос возвращает только NULL, а NULL не истина
- Всех троих —
EXISTSбез сравнения всегда истинно - Ошибка: в
EXISTSнужно выбирать*или1 - Анну и Веру
EXISTS проверяет только, вернул ли подзапрос хотя бы одну строку; что стоит в его списке выборки — *, 1 или NULL — не имеет значения, СУБД это даже не вычисляет. Для Анны и Веры заказы находятся (строка со значением NULL — всё равно строка), для Бориса — нет. Поэтому SELECT 1, SELECT * и SELECT NULL внутри EXISTS эквивалентны и по результату, и по скорости.UNION и множества8
Чем
UNION отличается от UNION ALL?UNION ALLудаляет дубликаты,UNION— нетUNIONтребует одинаковых имён столбцов,UNION ALL— нетUNIONудаляет дубликаты,UNION ALLоставляет все строкиUNION ALLсортирует результат,UNION— нет
UNION после объединения убирает повторяющиеся строки (что требует сортировки или хеширования), UNION ALL просто склеивает результаты. Если дубликатов быть не может или они нужны, UNION ALL быстрее. Ни один из них не гарантирует порядок без ORDER BY.Сколько строк вернёт запрос
SELECT 1 UNION SELECT 1 UNION ALL SELECT 1?- 1
- 3
- Ошибка: нельзя смешивать UNION и UNION ALL
- 2
Операции выполняются слева направо:
SELECT 1 UNION SELECT 1 даёт одну строку, а затем UNION ALL добавляет ещё одну без удаления дубликатов — итого 2. Если поменять местами (... UNION ALL ... UNION ...), последний UNION уберёт все дубликаты и останется 1 строка.Что произойдёт при выполнении
SELECT id, name FROM customers UNION SELECT customer_id FROM orders?- Ошибка: разное количество столбцов
- Недостающий столбец заполнится NULL
- Вернутся только столбцы
id - Второй SELECT будет проигнорирован
Все части
UNION/INTERSECT/EXCEPT должны возвращать одинаковое число столбцов с совместимыми типами (MySQL: The used SELECT statements have a different number of columns). Если нужно выровнять, недостающий столбец добавляют явно: SELECT customer_id, NULL FROM orders.Как будет называться столбец результата запроса
SELECT 'a' AS first_col UNION SELECT 'b' AS second_col?second_colfirst_colfirst_col, second_col— два столбца- Ошибка: разные имена столбцов
Имена столбцов результата берутся из первого
SELECT, псевдонимы в следующих частях игнорируются. Поэтому и в ORDER BY после UNION нужно ссылаться на имена из первой части.Какой из запросов корректен и отсортирует весь объединённый результат?
SELECT id FROM a ORDER BY id UNION SELECT id FROM bSELECT id FROM a UNION ORDER BY id SELECT id FROM bSELECT id FROM a UNION SELECT id FROM b ORDER BY idSELECT id FROM a ORDER BY id UNION SELECT id FROM b ORDER BY id
ORDER BY в конце относится ко всему результату UNION, а не к последнему SELECT. ORDER BY внутри отдельной части без скобок — ошибка (MySQL: Incorrect usage of UNION and ORDER BY, SQLite: ORDER BY clause should come after UNION); даже в скобках он не гарантирует порядок итогового результата без LIMIT.Что вернёт запрос в MySQL 8.0.31+ (или PostgreSQL)?
-- orders(id, customer_id, amount, status):
-- (10,1,100,'paid'), (11,1,200,'new'), (12,2,50,'paid')
SELECT customer_id FROM orders WHERE status = 'paid'
INTERSECT
SELECT customer_id FROM orders WHERE status = 'new';- 1 и 2
- 2
- Ошибку: MySQL не поддерживает INTERSECT
- 1
INTERSECT оставляет строки, присутствующие в обоих результатах: оплаченные заказы есть у клиентов 1 и 2, новые — только у 1. В MySQL INTERSECT и EXCEPT появились лишь в 8.0.31; в более ранних версиях это синтаксическая ошибка, и пересечение писали через IN/EXISTS или JOIN.Что вернёт запрос?
SELECT x FROM (SELECT 1 AS x UNION ALL SELECT 1
UNION ALL SELECT 2 UNION ALL SELECT 3) t
EXCEPT
SELECT 3;- 1, 2
- 1, 1, 2
- 3
- 1, 1, 2, 3
EXCEPT возвращает строки первого результата, которых нет во втором, и, как UNION, по умолчанию удаляет дубликаты — поэтому 1 встречается один раз. Сохранить кратность можно с EXCEPT ALL (есть в PostgreSQL и MySQL 8.0.31+, но не в SQLite).Что вернёт
SELECT 1 UNION SELECT 'a' в MySQL и в PostgreSQL?- Ошибку в обеих СУБД
- MySQL: две строки (
1иaстрокой), PostgreSQL: ошибка - MySQL: ошибка, PostgreSQL: две строки
- Две строки в обеих СУБД
MySQL приводит столбец к «общему» типу — здесь к строке — и возвращает
'1' и 'a'. PostgreSQL строже: тип столбца определяется как integer, и литерал 'a' к нему не приводится (invalid input syntax for type integer). Для переносимости типы в частях UNION выравнивают явно через CAST.DDL и ограничения7
Сколько строк окажется в таблице после выполнения кода (PostgreSQL 16 / MySQL 8)?
CREATE TABLE u (
id INT PRIMARY KEY,
email VARCHAR(100) UNIQUE
);
INSERT INTO u VALUES (1, NULL);
INSERT INTO u VALUES (2, NULL);
SELECT COUNT(*) FROM u;- 1 — второй INSERT упадёт с ошибкой уникальности
- 2 — несколько NULL в UNIQUE-столбце допустимы
- 0 — UNIQUE-столбец не может содержать NULL
- 2, но второй NULL автоматически заменится на ''
Ограничение UNIQUE сравнивает значения, а
NULL = NULL даёт UNKNOWN, а не TRUE, поэтому NULL-ы не считаются дубликатами — в PostgreSQL, MySQL и SQLite можно вставить сколько угодно NULL. Исключение — SQL Server (там допускается только один NULL) и PostgreSQL 15+ с явным UNIQUE NULLS NOT DISTINCT.Чем ограничение
PRIMARY KEY отличается от UNIQUE?- Ничем, это синонимы
- UNIQUE допускает только один NULL, а PRIMARY KEY — ни одного
- PRIMARY KEY = UNIQUE + NOT NULL, и в таблице он может быть только один
- PRIMARY KEY не создаёт индекс, а UNIQUE создаёт
Первичный ключ уникален и не допускает NULL (все его столбцы неявно NOT NULL), и объявить его можно лишь один раз на таблицу, тогда как UNIQUE-ограничений может быть сколько угодно и они допускают NULL. Оба ограничения создают уникальный индекс.
Что вернёт последний SELECT?
CREATE TABLE t (
id INT,
status VARCHAR(10) DEFAULT 'new'
);
INSERT INTO t (id) VALUES (1);
INSERT INTO t (id, status) VALUES (2, NULL);
SELECT id, status FROM t ORDER BY id;- (1, 'new'), (2, 'new')
- (1, NULL), (2, NULL)
- (1, 'new'), (2, NULL)
- Ошибка: нельзя вставить NULL в столбец с DEFAULT
DEFAULT подставляется только когда столбец не указан в INSERT (или указано ключевое слово
DEFAULT). Явно переданный NULL — это полноценное значение, и он сохраняется как есть; чтобы запретить его, нужен NOT NULL.В таблице
t уже есть 2 строки. Что произойдёт после выполнения команды?ALTER TABLE t ADD COLUMN qty INT NOT NULL DEFAULT 0;- Ошибка: в существующих строках qty будет NULL
- Столбец добавится, у существующих строк qty = NULL
- Столбец добавится только для новых строк
- Столбец добавится, у существующих строк qty = 0
При добавлении столбца с DEFAULT существующие строки получают значение по умолчанию, поэтому NOT NULL не нарушается. А вот
ADD COLUMN qty INT NOT NULL без DEFAULT в непустой таблице в PostgreSQL упадёт с ошибкой (в MySQL в strict-режиме подставится неявный ноль для INT).Что произойдёт при выполнении второго INSERT (PostgreSQL 16)?
CREATE TABLE orders (
id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
note TEXT
);
INSERT INTO orders (note) VALUES ('a');
INSERT INTO orders (id, note) VALUES (100, 'b');- Строка вставится с id = 100
- Ошибка: в столбец GENERATED ALWAYS нельзя явно писать без OVERRIDING SYSTEM VALUE
- Строка вставится с id = 2, явное значение будет проигнорировано
- Строка вставится с id = 100, а счётчик перескочит на 101
GENERATED ALWAYS AS IDENTITY запрещает явно задавать значение — нужно писать INSERT ... OVERRIDING SYSTEM VALUE VALUES (...). Вариант GENERATED BY DEFAULT AS IDENTITY (как и старый SERIAL) явное значение примет, но счётчик при этом не сдвинется.Что произойдёт в PostgreSQL при выполнении этого кода?
CREATE TABLE t (id SERIAL PRIMARY KEY, name TEXT);
INSERT INTO t (id, name) VALUES (1, 'a'), (2, 'b');
INSERT INTO t (name) VALUES ('c');- Строка 'c' получит id = 3
- Ошибка уже на первом INSERT: в SERIAL нельзя писать явно
- Ошибка duplicate key: последовательность выдаст id = 1
- Строка 'c' получит id = 0
SERIAL — это просто INT с DEFAULT nextval('t_id_seq'). Явная вставка id не трогает последовательность, поэтому следующий nextval вернёт 1 и случится нарушение PRIMARY KEY. После ручной вставки/импорта нужно выровнять счётчик через setval(...). В MySQL AUTO_INCREMENT в такой ситуации сам подтянулся бы до MAX(id)+1.Что произойдёт при выполнении INSERT?
CREATE TABLE p (
id INT,
price NUMERIC CHECK (price > 0)
);
INSERT INTO p VALUES (1, NULL);- Строка вставится: CHECK отклоняет только FALSE, а NULL > 0 даёт UNKNOWN
- Ошибка нарушения CHECK, потому что NULL не больше нуля
- Строка вставится с price = 0
- Ошибка: столбец с CHECK неявно становится NOT NULL
CHECK считается нарушенным только когда условие равно FALSE; для NULL результат UNKNOWN, и строка проходит. В отличие от WHERE, который отбрасывает UNKNOWN, здесь UNKNOWN трактуется как «не нарушено». Если NULL недопустим, добавьте
NOT NULL отдельно.INSERT, UPDATE, DELETE11
Какая команда удаляет не только данные, но и саму таблицу (структуру, индексы, ограничения)?
- DELETE FROM t
- TRUNCATE TABLE t
- ALTER TABLE t DROP ROWS
- DROP TABLE t
DROP TABLE удаляет объект целиком. DELETE удаляет строки (можно с WHERE, построчно, с триггерами), TRUNCATE быстро очищает всю таблицу, но таблица и её структура остаются. Команды ALTER TABLE ... DROP ROWS не существует.Что верно про
TRUNCATE TABLE t в MySQL 8 (InnoDB) по сравнению с DELETE FROM t?- TRUNCATE срабатывает с триггерами ON DELETE и сохраняет AUTO_INCREMENT
- TRUNCATE не вызывает триггеры DELETE, сбрасывает AUTO_INCREMENT и делает неявный COMMIT
- TRUNCATE поддерживает WHERE и откатывается через ROLLBACK
- Разницы нет, TRUNCATE — просто алиас DELETE без WHERE
В MySQL TRUNCATE — это DDL: таблица фактически пересоздаётся, триггеры ON DELETE не срабатывают, счётчик AUTO_INCREMENT сбрасывается, а сама команда вызывает неявный коммит, поэтому откатить её нельзя. Кроме того, TRUNCATE не выполнится, если на таблицу ссылаются внешние ключи других таблиц.
Нужно проставить
orders.customer_name из таблицы customers. Какой вариант корректен для PostgreSQL?-- orders(id, customer_id, customer_name)
-- customers(id, name)- UPDATE orders o JOIN customers c ON c.id = o.customer_id SET o.customer_name = c.name;
- UPDATE orders SET customer_name = c.name JOIN customers c ON c.id = orders.customer_id;
- UPDATE orders o SET customer_name = c.name FROM customers c WHERE c.id = o.customer_id;
- UPDATE orders, customers c SET customer_name = c.name WHERE c.id = customer_id;
В PostgreSQL присоединение в UPDATE делается через
FROM + условие в WHERE. Синтаксис UPDATE a JOIN b ON ... SET ... и перечисление таблиц через запятую после UPDATE — это MySQL, в PostgreSQL он не работает. Целевую таблицу не нужно повторять во FROM — иначе получится самосоединение.Как правильно скопировать неактивных пользователей в таблицу
archive?-- users(id, name, active)
-- archive(id, name)- INSERT INTO archive (id, name) VALUES (SELECT id, name FROM users WHERE active = 0);
- INSERT INTO archive (id, name) SELECT id, name FROM users WHERE active = 0;
- SELECT id, name INTO archive FROM users WHERE active = 0 VALUES;
- INSERT archive FROM users (id, name) WHERE active = 0;
INSERT ... SELECT пишется без VALUES: результат SELECT целиком становится набором вставляемых строк, столбцы сопоставляются по порядку. Вариант с VALUES (SELECT ...) трактует подзапрос как одно скалярное значение и падает, если он возвращает больше одной строки или столбца.Каким станет содержимое
stock (PostgreSQL 16)?CREATE TABLE stock (sku TEXT PRIMARY KEY, qty INT);
INSERT INTO stock VALUES ('A', 5);
INSERT INTO stock VALUES ('A', 3), ('B', 2)
ON CONFLICT (sku)
DO UPDATE SET qty = stock.qty + EXCLUDED.qty;- A = 3, B = 2
- A = 5, B = 2
- Ошибка duplicate key для 'A'
- A = 8, B = 2
EXCLUDED — это строка, которую пытались вставить (qty = 3), а stock.qty — текущее значение в таблице (5), поэтому A станет 8; строка B конфликта не вызвала и просто вставилась. В MySQL аналог — ON DUPLICATE KEY UPDATE qty = qty + VALUES(qty) (или алиас новой строки в 8.0.19+).Как в PostgreSQL одним запросом вставить строку и сразу получить сгенерированный
id?- INSERT INTO users (name) VALUES ('Ann') RETURNING id;
- INSERT INTO users (name) VALUES ('Ann') OUTPUT id;
- INSERT INTO users (name) VALUES ('Ann'); SELECT LAST_INSERT_ID();
- SELECT id FROM (INSERT INTO users (name) VALUES ('Ann'));
RETURNING в PostgreSQL возвращает любые столбцы вставленных (а также обновлённых/удалённых) строк прямо из INSERT/UPDATE/DELETE. OUTPUT — синтаксис SQL Server, LAST_INSERT_ID() — функция MySQL, где RETURNING для INSERT нет (он есть в MariaDB и SQLite 3.35+).Какое число затронутых строк (affected rows) сообщит MySQL 8 для
INSERT ... ON DUPLICATE KEY UPDATE, если строка с таким ключом уже была и её значение изменилось?- 0
- 1
- 2
- -1
По документации MySQL affected rows для такой команды: 1 — строка вставлена, 2 — существующая строка обновлена, 0 — существующая строка «обновлена» теми же значениями (если не задан флаг CLIENT_FOUND_ROWS). Поэтому по числу 1/2 приложение может понять, была вставка или обновление.
В таблице одна строка
a = 1, b = 2. Что в ней окажется после UPDATE в MySQL 8 и в PostgreSQL?UPDATE t SET a = b, b = a;- В обеих СУБД a = 2, b = 1
- MySQL: a = 2, b = 2; PostgreSQL: a = 2, b = 1
- MySQL: a = 2, b = 1; PostgreSQL: a = 2, b = 2
- В обеих СУБД a = 2, b = 2
По стандарту SQL (PostgreSQL, SQLite) все выражения справа вычисляются по старым значениям строки, поэтому значения меняются местами. В MySQL присваивания однотабличного UPDATE выполняются слева направо, и
b = a видит уже новое a = 2. Для обмена в MySQL нужна временная переменная или выражение без зависимости от порядка.Что произойдёт при выполнении этого запроса в MySQL 8?
DELETE FROM users
WHERE id IN (
SELECT id FROM users WHERE last_login < '2020-01-01'
);- Удалятся пользователи, не заходившие с 2020 года
- Удалятся все пользователи
- Ничего не удалится: подзапрос видит пустую таблицу
- Ошибка 1093: нельзя указывать изменяемую таблицу в FROM подзапроса
MySQL запрещает в UPDATE/DELETE читать ту же таблицу в подзапросе (ошибка 1093 «You can't specify target table ... for update in FROM clause»). Здесь подзапрос вообще не нужен:
DELETE FROM users WHERE last_login < '2020-01-01'; в сложных случаях переписывают через DELETE u FROM users u JOIN .... В PostgreSQL такой запрос работает без ошибок.Что произойдёт, если выполнить
UPDATE products SET price = price * 1.1; без WHERE?- Ошибка: UPDATE без WHERE запрещён стандартом SQL
- Обновится только первая строка таблицы
- Цена увеличится на 10% у всех строк таблицы
- Ничего не обновится, пока не указан WHERE
Без WHERE UPDATE (как и DELETE) затрагивает все строки таблицы — это одна из самых частых аварий на проде. Блокировать такие запросы может только клиентская настройка, например
--safe-updates (sql_safe_updates) в MySQL, но это не стандартное поведение.Что вернёт последний
SELECT (PostgreSQL 16 или MySQL 8)?CREATE TABLE src (first_name TEXT, last_name TEXT);
CREATE TABLE dst (last_name TEXT, first_name TEXT);
INSERT INTO src VALUES ('Анна', 'Иванова');
INSERT INTO dst SELECT * FROM src;
SELECT last_name FROM dst;Иванова— столбцы сопоставляются по именам- Ошибка: порядок столбцов в таблицах не совпадает
Анна— значения раскладываются по позициям, а не по именам
INSERT ... SELECT (как и INSERT ... VALUES) сопоставляет значения со столбцами по порядку: первый столбец выборки попадает в первый столбец таблицы (или списка столбцов), имена не учитываются. Типы совпадают (оба TEXT), поэтому ошибки нет — имя молча оказывается в last_name. Надёжная форма — явно перечислять столбцы с обеих сторон: INSERT INTO dst (first_name, last_name) SELECT first_name, last_name FROM src.Ключи и связи8
Сколько строк останется в
orders после удаления клиента 1?CREATE TABLE customers (id INT PRIMARY KEY);
CREATE TABLE orders (
id INT PRIMARY KEY,
customer_id INT REFERENCES customers(id) ON DELETE CASCADE
);
INSERT INTO customers VALUES (1), (2);
INSERT INTO orders VALUES (10, 1), (11, 1), (12, 2);
DELETE FROM customers WHERE id = 1;
SELECT COUNT(*) FROM orders;- 3
- 1
- 0
- Ошибка: на клиента 1 ссылаются заказы
ON DELETE CASCADE удаляет все дочерние строки вместе с родителем: заказы 10 и 11 исчезнут, останется только заказ 12. Ошибка была бы при действии по умолчанию (NO ACTION) или RESTRICT.Каким будет
customer_id у заказов после удаления клиента 1?CREATE TABLE orders (
id INT PRIMARY KEY,
customer_id INT REFERENCES customers(id) ON DELETE SET NULL
);
-- orders: (10, 1), (11, 1), (12, 2)
DELETE FROM customers WHERE id = 1;- 10 → NULL, 11 → NULL, 12 → 2
- Заказы 10 и 11 будут удалены
- 10 → 0, 11 → 0, 12 → 2
- У всех заказов customer_id станет NULL
ON DELETE SET NULL обнуляет ссылку только у строк, указывавших на удалённого родителя; остальные не трогаются. Столбец при этом должен допускать NULL — если объявить его NOT NULL, удаление родителя закончится ошибкой.Чем в PostgreSQL отличается
ON DELETE RESTRICT от ON DELETE NO ACTION?- RESTRICT запрещает удаление, а NO ACTION молча оставляет «висячие» ссылки
- Ничем, во всех СУБД это полные синонимы
- NO ACTION удаляет дочерние строки, RESTRICT — нет
- RESTRICT проверяется сразу, а проверку NO ACTION можно отложить (DEFERRABLE) до конца транзакции
Оба действия не дают удалить родителя, на которого есть ссылки. Разница в моменте проверки: RESTRICT срабатывает немедленно, а NO ACTION — в конце оператора, а для ограничения
DEFERRABLE INITIALLY DEFERRED — при COMMIT, что позволяет в одной транзакции удалить родителя и «перевесить» ссылки. В MySQL InnoDB RESTRICT и NO ACTION ведут себя одинаково.FK объявлен как
customer_id INT REFERENCES customers(id) без ON DELETE. Что будет при удалении клиента, у которого есть заказы?- Заказы клиента удалятся автоматически
- У заказов customer_id станет NULL
- Удаление завершится ошибкой нарушения внешнего ключа
- Клиент удалится, заказы останутся со старым customer_id
Действие по умолчанию —
NO ACTION: удалять родителя, на которого ссылаются, нельзя, СУБД вернёт ошибку FOREIGN KEY. Каскадное удаление или обнуление ссылок происходит только если явно указать ON DELETE CASCADE / SET NULL.Как правильно смоделировать связь «многие-ко-многим» между студентами и курсами?
- Добавить в students столбец course_ids со списком через запятую
- Создать таблицу enrollments(student_id, course_id) с двумя FK и PK по паре столбцов
- Добавить в courses столбец student_id
- Добавить FK в обе таблицы: students.course_id и courses.student_id
Связь M:N реализуется промежуточной (junction) таблицей с внешними ключами на обе стороны; составной PK (или UNIQUE) по паре не даёт записать студента на курс дважды. Один FK в одной из таблиц даёт лишь «один-ко-многим», а список через запятую нарушает 1НФ.
У одного автора много книг, у книги один автор. Где должен находиться внешний ключ?
- В таблице books: books.author_id → authors.id
- В таблице authors: authors.book_id → books.id
- Только в отдельной таблице author_books
- В обеих таблицах, ссылаясь друг на друга
В связи «один-ко-многим» FK кладут на сторону «многих»: каждая книга хранит ссылку на своего единственного автора. Столбец
authors.book_id позволил бы автору иметь лишь одну книгу, а отдельная таблица нужна только для «многие-ко-многим».Что верно про суррогатные и естественные ключи?
- Естественный ключ (email, ИНН) всегда лучше: он несёт смысл и никогда не меняется
- Суррогатный ключ нельзя использовать вместе с UNIQUE на естественных полях
- Суррогатный ключ (id) стабилен и компактен, но уникальность бизнес-полей всё равно нужно обеспечивать UNIQUE
- Суррогатные ключи запрещены во 2НФ и 3НФ
Суррогатный ключ не зависит от бизнес-данных, не меняется и делает FK короткими, но сам по себе не мешает завести двух пользователей с одним email — для этого добавляют UNIQUE на естественный ключ. Естественные ключи на практике меняются (email, номер паспорта), и их смена каскадом бьёт по всем ссылающимся таблицам.
Включены внешние ключи. Что произойдёт при этих двух вставках в
orders (таблица customers пуста)?CREATE TABLE orders (
id INT PRIMARY KEY,
customer_id INT REFERENCES customers(id)
);
INSERT INTO orders VALUES (10, NULL); -- (1)
INSERT INTO orders VALUES (11, 99); -- (2)- Обе вставки упадут с ошибкой FK
- Обе вставки пройдут, FK проверяется только при удалении
- (1) упадёт с ошибкой, (2) пройдёт
- (1) пройдёт, (2) упадёт с ошибкой FK
NULL во внешнем ключе означает «ссылки нет», и он не проверяется на существование родителя. Значение 99 проверяется, и раз такого клиента нет — нарушение FK. Если ссылка обязательна, к FK нужно добавить
NOT NULL.Нормализация6
Какое требование нормализации нарушает таблица ниже?
-- users
-- id | name | phones
-- 1 | Ann | '+375291111111, +375292222222'
-- 2 | Bob | '+375293333333'- 3НФ — транзитивная зависимость
- 1НФ — значения не атомарны
- 2НФ — частичная зависимость от ключа
- Таблица нормализована, нарушений нет
1НФ требует, чтобы в каждой ячейке было одно атомарное значение, а здесь в
phones список. Искать, индексировать и обновлять отдельный телефон в такой строке неудобно; правильно вынести телефоны в таблицу user_phones(user_id, phone).Ключ таблицы —
(order_id, product_id). Какая нормальная форма нарушена?-- order_items
-- order_id | product_id | qty | product_name
-- 1 | 7 | 2 | 'Чайник'
-- 2 | 7 | 1 | 'Чайник'- 1НФ
- 3НФ, но не 2НФ
- 2НФ: product_name зависит только от части ключа (product_id)
- BCNF, но 3НФ соблюдена
2НФ запрещает зависимость неключевых атрибутов от части составного ключа.
qty зависит от всего ключа, а product_name — только от product_id, поэтому название дублируется в каждой строке заказа. Решение — хранить его в products.Ключ —
id. Что не так с таблицей с точки зрения нормализации?-- employees
-- id | name | dept_id | dept_name
-- 1 | Ann | 10 | 'Продажи'
-- 2 | Bob | 10 | 'Продажи'- Нарушена 3НФ: dept_name зависит от dept_id, а тот — от id (транзитивная зависимость)
- Нарушена 2НФ: dept_name зависит от части ключа
- Нарушена 1НФ: dept_name не атомарен
- Всё в порядке: таблица с одностолбцовым ключом всегда в 3НФ
Цепочка
id → dept_id → dept_name — транзитивная зависимость неключевого атрибута через другой неключевой атрибут, что нарушает 3НФ. 2НФ здесь соблюдена автоматически: ключ из одного столбца, у него нет «частей». Лечится выносом отделов в таблицу departments.Чем нормальная форма Бойса–Кодда (BCNF) строже 3НФ?
- BCNF дополнительно запрещает NULL в неключевых столбцах
- BCNF требует, чтобы у таблицы был только один потенциальный ключ
- BCNF запрещает составные первичные ключи
- В BCNF детерминант любой нетривиальной функциональной зависимости должен быть потенциальным ключом
3НФ допускает зависимость X → A, если A — ключевой (входящий в какой-либо потенциальный ключ) атрибут; BCNF это исключение убирает. Классический пример: (студент, предмет) → преподаватель и преподаватель → предмет — таблица в 3НФ, но не в BCNF, так как «преподаватель» не является ключом.
Вы храните в
orders денормализованное поле customer_name, копию из customers. Что из этого верно?- Чтение ускоряется (нет JOIN), но при смене имени нужно обновлять копии, иначе данные разойдутся
- Это ускоряет и чтение, и запись без каких-либо минусов
- Денормализация всегда ошибка и не применяется в реальных системах
- СУБД сама синхронизирует копию с таблицей customers
Денормализация — осознанный обмен: меньше JOIN и быстрее отчёты ценой дублирования, лишней работы при записи и риска аномалий обновления. Синхронизацию обеспечиваете вы (триггеры, код приложения, материализованные представления). Иногда копия как раз и нужна — например, имя на момент заказа.
Что называют аномалией обновления в ненормализованной таблице?
- Ошибку при UPDATE без WHERE
- Взаимную блокировку двух UPDATE
- Ситуацию, когда один факт хранится в нескольких строках и при изменении части копий данные расходятся
- Невозможность изменить первичный ключ
Если, например, название отдела записано у каждого сотрудника, переименование нужно сделать во всех строках; пропустили одну — база противоречит сама себе. Нормализация устраняет такие аномалии (а также аномалии вставки и удаления), храня каждый факт в одном месте.
Индексы10
На столбце
last_name есть обычный B-tree индекс. Какое условие может эффективно использовать его для поиска?- WHERE last_name LIKE '%ов'
- WHERE last_name LIKE 'Ива%'
- WHERE last_name LIKE '%ван%'
- Ни одно: LIKE никогда не использует индексы
B-tree упорядочен по началу строки, поэтому
LIKE 'Ива%' превращается в диапазонный поиск. Шаблон с ведущим % не знает начала значения — придётся перебирать всё (для таких задач нужны полнотекстовые или триграммные индексы, например pg_trgm). В PostgreSQL для префиксного LIKE при не-C collation может понадобиться индекс с text_pattern_ops.Есть составной индекс
(a, b, c). Какое условие НЕ может использовать его для поиска по дереву (правило левого префикса)?CREATE INDEX ix_abc ON t (a, b, c);- WHERE a = 1
- WHERE a = 1 AND b > 5
- WHERE b = 2 AND c = 3
- WHERE a = 1 AND b = 2 AND c = 3
Составной индекс отсортирован сначала по a, затем по b, затем по c, поэтому искать можно только по левому префиксу столбцов. Без условия на
a значения b и c разбросаны по всему индексу. (Некоторые оптимизаторы умеют skip scan, например MySQL 8.0.13+, но это частный случай, а не обычный поиск.)На
created_at есть индекс, но запрос делает полный скан. Как переписать условие, чтобы индекс использовался (MySQL 8)?SELECT * FROM orders
WHERE YEAR(created_at) = 2024;- WHERE YEAR(created_at) = '2024'
- WHERE created_at LIKE '2024%'
- WHERE DATE_FORMAT(created_at, '%Y') = '2024'
- WHERE created_at >= '2024-01-01' AND created_at < '2025-01-01'
Функция над индексированным столбцом делает условие «несаргируемым»: индекс хранит значения
created_at, а не YEAR(created_at). Диапазон по самому столбцу индекс использует. Альтернатива — функциональный индекс по выражению (MySQL 8.0.13+, PostgreSQL).Таблица InnoDB:
users(id INT PRIMARY KEY, email VARCHAR(100), name VARCHAR(100)), индекс только INDEX(email). Будет ли этот запрос выполнен только по индексу (covering index, «Using index» в EXPLAIN)?SELECT id, email FROM users WHERE email = 'a@b.c';- Нет, потому что id не перечислен в индексе
- Да: вторичный индекс InnoDB хранит значение первичного ключа
- Нет, покрывающими бывают только составные индексы
- Да, но только если добавить FORCE INDEX
Каждая запись вторичного индекса InnoDB содержит значение PK как указатель на строку, поэтому
id и email берутся прямо из индекса без обращения к таблице. Если же добавить в SELECT name, понадобится поиск строки по кластерному индексу.Какой основной минус у большого количества индексов на таблице?
- SELECT начинает работать медленнее
- Таблица перестаёт поддерживать транзакции
- Каждый INSERT/UPDATE/DELETE должен обновлять все затронутые индексы, плюс они занимают место
- Нельзя будет добавить внешние ключи
Индекс — отдельная структура, которую СУБД поддерживает при каждом изменении данных, поэтому лишние индексы замедляют запись и раздувают диск и память. На чтение лишний индекс обычно не вредит, разве что оптимизатору сложнее выбирать план.
В таблице 10 млн строк, столбец
is_active принимает два значения, примерно 50/50. Почему индекс по нему почти бесполезен для WHERE is_active = 1?- B-tree не умеет индексировать столбцы типа BOOLEAN
- Низкая селективность: условие выбирает половину таблицы, и полный скан выходит дешевле
- Индексы работают только для уникальных столбцов
- Индекс используется только при ORDER BY
Индекс выгоден, когда условие отбирает малую долю строк; на половине таблицы множество случайных чтений обходится дороже последовательного скана, и оптимизатор выберет его. Если же нужно найти редкое значение (1% строк), такой индекс полезен — в PostgreSQL для этого удобен частичный индекс
WHERE is_active.Почему в InnoDB случайный UUID (v4) в качестве PRIMARY KEY часто хуже, чем автоинкрементный BIGINT?
- InnoDB не позволяет использовать строковые первичные ключи
- UUID не гарантирует уникальность, поэтому нужны дополнительные проверки
- Таблица хранится в порядке PK (кластерный индекс): случайные вставки дробят страницы, а длинный PK копируется во все вторичные индексы
- Автоинкремент быстрее только при чтении, на вставку тип ключа не влияет
В InnoDB строки физически лежат в B-tree первичного ключа. Монотонный ключ дописывается в конец, а случайный UUID вставляется в произвольные страницы, вызывая их расщепление и фрагментацию. Кроме того, каждая запись вторичного индекса хранит PK, так что 16–36 байт вместо 8 раздувают все индексы. Смягчают это упорядоченные по времени UUID (v7) и хранение в
BINARY(16).Что означает
type = ALL в выводе EXPLAIN в MySQL?- Использованы все индексы таблицы
- Полное сканирование таблицы (full table scan)
- Запрос вернёт все столбцы
- Поиск по первичному ключу, самый быстрый вариант
ALL — худший тип доступа: читается каждая строка таблицы. Хорошие типы — const/eq_ref/ref (поиск по индексу) и range; поиск по PK обычно даёт const. На больших таблицах ALL в часто выполняемом запросе — повод проверить индексы и условия.Столбец
phone VARCHAR(20) проиндексирован. Почему этот запрос в MySQL 8 делает полный скан?SELECT * FROM users WHERE phone = 79001234567;- Сравнение строки с числом приводит строки к числу для каждой записи, и индекс по строке не применим
- MySQL не использует индексы для столбцов VARCHAR длиннее 10 символов
- Число слишком велико для INT, поэтому запрос всегда вернёт пустой результат
- Индекс не используется, потому что в условии нет LIMIT
При сравнении строкового столбца с числом MySQL приводит обе стороны к числу, то есть по сути вычисляет функцию над каждым значением столбца — индекс по строкам не годится. К тому же '+79001234567' или '079001234567' тоже совпадут. Пишите литерал строкой:
WHERE phone = '79001234567'. Обратный случай (числовой столбец и строковый литерал) индекс не ломает.Какой индекс лучше всего подходит для запроса: сразу сужает поиск по
status и отдаёт строки уже упорядоченными по created_at?SELECT * FROM orders
WHERE status = 'new'
ORDER BY created_at
LIMIT 20;- INDEX (created_at, status)
- INDEX (status) и отдельно INDEX (created_at)
- INDEX (status, created_at)
- INDEX (created_at) — фильтр по status не важен
В индексе
(status, created_at) строки с одинаковым status уже упорядочены по created_at: СУБД находит диапазон status = 'new' и читает первые 20 записей по порядку. При (created_at, status) равенство по второму столбцу не даёт сузить поиск, а из двух отдельных индексов для одной таблицы обычно используется только один (читая по порядку created_at, придётся отбрасывать строки с другим status).Транзакции и блокировки9
Что означает буква I в ACID?
- Integrity — данные удовлетворяют ограничениям
- Indexing — изменения сразу попадают в индексы
- Immutability — закоммиченные данные нельзя изменить
- Isolation — параллельные транзакции не мешают друг другу (в рамках уровня изоляции)
ACID — Atomicity (всё или ничего), Consistency (из корректного состояния в корректное), Isolation (изолированность параллельных транзакций) и Durability (закоммиченное не теряется при сбое). Целостность по ограничениям относится к C, а степень изоляции регулируется уровнями изоляции.
Изначально в
t одна строка x = 1. Что вернёт последний SELECT?BEGIN;
INSERT INTO t (x) VALUES (2);
DELETE FROM t WHERE x = 1;
ROLLBACK;
SELECT x FROM t;- 1
- 2
- 1 и 2
- Пустой результат
ROLLBACK отменяет все изменения транзакции целиком — и вставку, и удаление, поэтому таблица возвращается к исходному состоянию. Это атомарность: частично применённой транзакции не бывает.
Какие значения окажутся в таблице
t (изначально пустой)?BEGIN;
INSERT INTO t VALUES (1);
SAVEPOINT s1;
INSERT INTO t VALUES (2);
ROLLBACK TO SAVEPOINT s1;
INSERT INTO t VALUES (3);
COMMIT;- 1, 2, 3
- 1, 3
- 3
- Таблица пуста: ROLLBACK отменил транзакцию
ROLLBACK TO SAVEPOINT откатывает только изменения после точки сохранения (вставку 2), а транзакция продолжается: вставка 3 и коммит выполняются. Полностью отменяет транзакцию лишь обычный ROLLBACK без TO.Какой уровень изоляции используется по умолчанию в MySQL (InnoDB) и в PostgreSQL?
- Обе: READ COMMITTED
- Обе: SERIALIZABLE
- MySQL — REPEATABLE READ, PostgreSQL — READ COMMITTED
- MySQL — READ COMMITTED, PostgreSQL — REPEATABLE READ
InnoDB по умолчанию работает на REPEATABLE READ, а PostgreSQL — на READ COMMITTED (каждый оператор видит свежий снимок). Из-за этого один и тот же код может вести себя по-разному при переносе между СУБД. SERIALIZABLE по умолчанию не используется нигде из-за накладных расходов.
Транзакция дважды выполняет
SELECT COUNT(*) FROM orders WHERE status = 'new' и получает 5, затем 6, потому что другая транзакция вставила и закоммитила новую строку. Как называется эта аномалия?- Фантомное чтение (phantom read)
- Грязное чтение (dirty read)
- Потерянное обновление (lost update)
- Взаимная блокировка (deadlock)
Фантом — повторный запрос по условию возвращает новые (или пропавшие) строки. Неповторяемое чтение — это когда изменились значения уже прочитанной строки, а грязное чтение — чтение незакоммиченных данных; здесь вставка была закоммичена. Стандарт допускает фантомы вплоть до REPEATABLE READ, хотя в PostgreSQL и InnoDB снимок на этом уровне их для обычных SELECT не показывает.
Две транзакции параллельно выполняют этот код для одного счёта (READ COMMITTED). Баланс был 100, каждая добавляет 50. Что может получиться и как это исправить?
-- приложение:
SELECT balance FROM accounts WHERE id = 1; -- 100
-- new = 100 + 50
UPDATE accounts SET balance = 150 WHERE id = 1;
COMMIT;- Всегда 200: UPDATE блокирует строку, поэтому гонки нет
- Ошибка deadlock в обеих транзакциях
- Может получиться 150 (lost update); поможет только уровень READ UNCOMMITTED
- Может получиться 150 (lost update); поможет SELECT ... FOR UPDATE или атомарный UPDATE balance = balance + 50
Обе транзакции прочитали 100 и обе записали 150 — одно пополнение потеряно. UPDATE действительно блокирует строку, но значение уже вычислено в приложении по устаревшему чтению. Помогают
SELECT ... FOR UPDATE (вторая транзакция ждёт), атомарное SET balance = balance + 50 или оптимистическая блокировка с версией.Что делает СУБД (MySQL InnoDB, PostgreSQL) при обнаружении взаимной блокировки (deadlock) двух транзакций?
- Ждёт, пока одна из транзакций не будет закоммичена вручную
- Откатывает одну из транзакций с ошибкой deadlock, вторая продолжает работу
- Откатывает обе транзакции
- Перезапускает транзакцию-жертву автоматически
СУБД находит цикл ожидания и выбирает «жертву», которую откатывает с ошибкой (в MySQL 1213, в PostgreSQL SQLSTATE 40P01); вторая получает блокировку и идёт дальше. Сама СУБД транзакцию не повторяет — это задача приложения. Снизить вероятность deadlock помогают одинаковый порядок захвата строк и короткие транзакции.
Как здесь реализована оптимистическая блокировка и что значит результат «0 строк изменено»?
-- прочитали: id = 1, balance = 100, version = 7
UPDATE accounts
SET balance = 150, version = version + 1
WHERE id = 1 AND version = 7;- Строка заблокирована до COMMIT; 0 строк — значит, запись с id = 1 удалена
- Версия нужна только для аудита; 0 строк — ошибка в синтаксисе
- UPDATE проходит, только если version не изменилась; 0 строк — кто-то успел обновить запись, нужно перечитать и повторить
- Это пессимистическая блокировка; 0 строк — транзакция ждёт освобождения строки
Оптимистический подход не держит блокировок между чтением и записью, а проверяет при UPDATE, что версия осталась прежней. Если строку уже изменили, условие
version = 7 не выполнится, затронуто будет 0 строк, и приложение обрабатывает конфликт. Пессимистический вариант — заранее взять SELECT ... FOR UPDATE.Транзакция A на уровне REPEATABLE READ в PostgreSQL прочитала строку, а транзакция B успела её изменить и закоммитить. Что будет, если A теперь выполнит UPDATE этой строки?
- UPDATE применится к свежей версии строки, как в MySQL
- UPDATE молча перезапишет изменения B старыми данными
- A зависнет навсегда в ожидании блокировки
- Ошибка «could not serialize access due to concurrent update», транзакцию A нужно повторить
В PostgreSQL на REPEATABLE READ и SERIALIZABLE транзакция не может изменить строку, обновлённую другой транзакцией после начала её снимка, — она получает ошибку сериализации (SQLSTATE 40001) и должна быть повторена. В MySQL InnoDB на REPEATABLE READ UPDATE выполняет «текущее чтение» и применяется к последней закоммиченной версии, без ошибки.
Оконные функции13
Какие значения
RANK() и DENSE_RANK() получит строка с name = 'D'?-- данные: A=100, B=90, C=90, D=80
SELECT name,
RANK() OVER (ORDER BY score DESC) AS r,
DENSE_RANK() OVER (ORDER BY score DESC) AS dr
FROM scores;- r = 3, dr = 3
- r = 4, dr = 3
- r = 4, dr = 4
- r = 3, dr = 4
B и C делят 2-е место.
RANK() после равных значений пропускает номера (1, 2, 2, 4), а DENSE_RANK() идёт без пропусков (1, 2, 2, 3). Ответ «3 и 3» — типичная путаница: так работает только DENSE_RANK.В таблице два сотрудника с одинаковой зарплатой. Что верно про
ROW_NUMBER() OVER (ORDER BY salary DESC) для них?- Оба получат одинаковый номер, как в RANK()
- Номера будут разными, но кто из них первый — не гарантировано
- Меньший номер всегда получит строка с меньшим первичным ключом
- Запрос завершится ошибкой из-за неоднозначной сортировки
ROW_NUMBER() всегда выдаёт уникальные последовательные номера, но при равных ключах сортировки порядок недетерминирован и может меняться между запусками. Чтобы результат был стабильным, добавляют уникальный «тай-брейкер»: ORDER BY salary DESC, id.Что вернёт столбец
c для сотрудника a?-- employees: (a, IT), (b, IT), (c, HR), (d, IT)
SELECT name, dept,
COUNT(*) OVER (PARTITION BY dept) AS c
FROM employees;- 1
- 4
- 3
- Ошибка: COUNT(*) требует GROUP BY
PARTITION BY dept делит строки на группы по отделу, и COUNT(*) считается внутри группы: в IT три сотрудника. В отличие от GROUP BY, оконная функция не схлопывает строки — каждая из четырёх строк остаётся в результате со своим значением c.Что будет в столбце
s для строки (d = 2, amt = 20)?-- sales(d, amt): (1,10), (2,20), (2,30), (3,40)
SELECT d, amt,
SUM(amt) OVER (ORDER BY d) AS s
FROM sales;- 30
- 20
- 100
- 60
Если указан
ORDER BY, а рамка не задана, по стандарту используется RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW. RANGE включает всех «пиров» — строки с тем же значением d, поэтому обе строки с d = 2 получают 10 + 20 + 30 = 60. Ожидаемое «нарастающее» 30 даёт только ROWS UNBOUNDED PRECEDING.Чем рамка
ROWS отличается от RANGE в оконной функции?- ROWS считает физические строки, RANGE — строки по значению ключа ORDER BY, включая равные
- ROWS работает только с числами, RANGE — только с датами
- ROWS требует PARTITION BY, а RANGE — нет
- Разницы нет, это синонимы для совместимости
ROWS отсчитывает ровно N физических строк от текущей, а RANGE определяет рамку по значению ключа сортировки, поэтому строки с одинаковым значением (пиры) всегда попадают в рамку вместе. На уникальном ключе результаты совпадают, на дублях — нет, отсюда и сюрпризы с нарастающими суммами.Что вернёт столбец
diff для строки с id = 1?-- t(id, x): (1,5), (2,8), (3,6)
SELECT id,
x - LAG(x, 1, 0) OVER (ORDER BY id) AS diff
FROM t;- NULL
- 5
- 0
- -3
У первой строки нет предыдущей, поэтому
LAG возвращает значение по умолчанию — третий аргумент, 0. Получается 5 - 0 = 5. Без третьего аргумента LAG вернул бы NULL, и вся разность стала бы NULL.Что вернёт столбец
l для строки с id = 1?-- t(id, x): (1,'a'), (2,'b'), (3,'c')
SELECT id,
LAST_VALUE(x) OVER (ORDER BY id) AS l
FROM t;- 'c'
- 'a'
- NULL
- 'b'
Рамка по умолчанию заканчивается на
CURRENT ROW, поэтому «последняя» строка рамки — это текущая строка, и LAST_VALUE просто возвращает её же x. Чтобы получить 'c' для всех строк, нужна рамка ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING. С FIRST_VALUE такой ловушки нет: начало рамки по умолчанию и так первое.Как распределятся 7 строк (значения 1..7) по группам при
NTILE(3) OVER (ORDER BY i)?- 2, 2, 3 строки
- 3, 3, 1 строка
- 3, 2, 2 строки
- Ошибка: 7 не делится на 3
NTILE(n) делит строки на n групп, размеры которых отличаются максимум на 1, причём лишние строки достаются первым группам. 7 = 3 + 2 + 2, поэтому группа 1 получает 1..3, группа 2 — 4..5, группа 3 — 6..7.Нужно выбрать двух самых высокооплачиваемых сотрудников в каждом отделе. Какой запрос корректен (PostgreSQL 16 / MySQL 8)?
- SELECT * FROM emp WHERE ROW_NUMBER() OVER (PARTITION BY dept ORDER BY sal DESC) <= 2
- SELECT * FROM (SELECT e.*, ROW_NUMBER() OVER (PARTITION BY dept ORDER BY sal DESC) rn FROM emp e) x WHERE rn <= 2
- SELECT dept, MAX(sal) FROM emp GROUP BY dept LIMIT 2
- SELECT * FROM emp e GROUP BY dept HAVING ROW_NUMBER() OVER (ORDER BY sal DESC) <= 2
Оконные функции вычисляются после
WHERE, GROUP BY и HAVING, поэтому фильтровать по ним можно только во внешнем запросе — через подзапрос или CTE. Вариант с GROUP BY ... LIMIT 2 возвращает 2 строки на всю таблицу, а не по 2 на отдел.Что произойдёт при выполнении этого запроса?
SELECT id, name
FROM users
WHERE ROW_NUMBER() OVER (ORDER BY created_at) = 1;- Вернётся самый первый зарегистрированный пользователь
- Вернутся все пользователи, условие проигнорируется
- Вернётся пустой результат
- Ошибка: оконные функции нельзя использовать в WHERE
WHERE выполняется до вычисления оконных функций, поэтому ни одна СУБД (PostgreSQL, MySQL 8, SQLite) не разрешит окно в WHERE — будет ошибка. Решение — обернуть запрос с ROW_NUMBER() в подзапрос или CTE и фильтровать снаружи.Что верно про конструкцию
QUALIFY ROW_NUMBER() OVER (...) = 1?- Это стандарт SQL:2016, поддерживается всеми современными СУБД
- Это расширение (Snowflake, BigQuery, DuckDB, Teradata); в PostgreSQL 16 и MySQL 8 его нет
- Это синоним HAVING, работает везде, где есть GROUP BY
- Работает в MySQL 8, но не в PostgreSQL
QUALIFY фильтрует по результатам оконных функций так же, как HAVING по агрегатам, но это не стандарт SQL: он есть в Snowflake, BigQuery, DuckDB, Teradata, а в PostgreSQL 16 и MySQL 8 его нет. Там используют подзапрос или CTE с фильтром во внешнем WHERE.Что вернёт столбец
a для строки с id = 3?-- t(id, x): (1,10), (2,20), (3,30), (4,40)
SELECT id,
AVG(x) OVER (ORDER BY id
ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS a
FROM t;- 20
- 25
- 30
- 35
Рамка «1 предыдущая + текущая» для
id = 3 содержит x = 20 и 30, среднее 25 — это скользящее среднее по двум точкам. 20 получилось бы при нарастающем среднем (AVG по 10, 20, 30), а 35 — если по ошибке взять текущую и следующую строку.Что вернёт этот запрос?
-- t(dept, x): ('A',10), ('A',20), ('B',70)
SELECT dept,
SUM(x) AS s,
SUM(SUM(x)) OVER () AS total
FROM t
GROUP BY dept;- Ошибка: агрегат внутри агрегата запрещён
- A | 30 | 30 и B | 70 | 70
- A | 30 | 100 и B | 70 | 100
- A | 30 | 3 и B | 70 | 3
Оконные функции вычисляются после
GROUP BY, поэтому внутри окна можно использовать результат обычного агрегата: внутренний SUM(x) — сумма по отделу, внешний SUM(...) OVER () — сумма этих сумм по всему результату. Вложенные агрегаты без OVER действительно запрещены, но здесь внешний — оконный.Оптимизация запросов7
В выводе
EXPLAIN для MySQL у таблицы orders указано type: ALL и key: NULL. Что это значит?- Используется покрывающий индекс по всем столбцам
- Запрос вернёт все строки таблицы
- Выполняется полный просмотр таблицы, индекс не используется
- Результат взят из кэша запросов
type: ALL — самый дорогой тип доступа: MySQL читает каждую строку таблицы, а key: NULL подтверждает, что индекс не выбран. Это не про размер результата: даже с селективным WHERE может читаться вся таблица. Хорошие типы доступа — const, eq_ref, ref, range.Есть отдельные индексы на
email и на phone. Что верно про запрос SELECT * FROM users WHERE email = ? OR phone = ??- OR по разным столбцам всегда использует оба индекса так же эффективно, как AND
- Нужен составной индекс (email, phone) — он полностью решит проблему с OR
- Оптимизатор может выбрать полный просмотр; помочь может переписывание в UNION двух запросов по своим индексам
- OR нельзя использовать в WHERE вместе с индексированными столбцами
Одним B-tree индексом условие
a = ? OR b = ? не покрыть. MySQL умеет index_merge (union), PostgreSQL — BitmapOr, но не всегда их выбирает, и тогда получается полный просмотр. Запрос ... WHERE email = ? UNION ... WHERE phone = ? даёт два индексных поиска. Составной индекс (email, phone) не помогает условию по одному phone — работает правило левого префикса.Код получает 100 статей одним запросом, а потом в цикле для каждой делает
SELECT * FROM authors WHERE id = ?. Как называется проблема и как её решить?- Проблема N+1 запросов; загрузить авторов одним запросом через JOIN или WHERE id IN (...)
- Дедлок; обернуть весь цикл в одну транзакцию
- Проблема N+1 запросов; добавить индекс на authors.id
- Декартово произведение; добавить в запрос DISTINCT
101 запрос вместо одного-двух — это N+1: каждый отдельный запрос быстрый, но суммарная задержка сетевых обращений огромна. Индекс на
authors.id (обычно это и так первичный ключ) не поможет — проблема в числе обращений, а не в скорости каждого. Решение — JOIN или пакетная загрузка WHERE id IN (...) (eager loading в ORM).Есть индекс
(user_id, created_at). Почему SELECT created_at FROM orders WHERE user_id = 5 может быть заметно быстрее, чем SELECT * FROM orders WHERE user_id = 5?- SELECT * всегда игнорирует индексы и читает таблицу целиком
- Первый запрос кэшируется сервером, а SELECT * — нет
- Разницы нет: объём читаемых данных одинаковый
- Все нужные столбцы есть в индексе (покрывающий индекс), читать строки таблицы не нужно
Когда индекс содержит все столбцы запроса, СУБД отвечает только по индексу (
Using index в MySQL, Index Only Scan в PostgreSQL). SELECT * тоже использует индекс для поиска, но затем для каждой найденной строки дочитывает её из таблицы и передаёт лишние данные по сети. Поэтому нужные столбцы лучше перечислять явно.Почему
SELECT COUNT(*) FROM big_table без WHERE на таблице в сотни миллионов строк выполняется долго в InnoDB (MySQL 8) и PostgreSQL?- COUNT(*) читает все столбцы каждой строки, быстрее написать COUNT(1)
- Из-за MVCC точное число строк зависит от транзакции, и СУБД приходится сканировать таблицу или индекс
- Обе СУБД хранят точное число строк, медленно только без первичного ключа
- COUNT(*) блокирует таблицу на запись на всё время подсчёта
В MVCC-движках разные транзакции видят разное число строк, поэтому готового точного счётчика нет — приходится сканировать таблицу или самый компактный индекс.
COUNT(1) и COUNT(*) выполняются одинаково — это миф. Если хватает приблизительного значения, берут статистику: pg_class.reltuples в PostgreSQL или TABLE_ROWS из information_schema.TABLES в MySQL.На
created_at есть индекс. Какое условие позволит его использовать (SARGable)?- WHERE YEAR(created_at) = 2024
- WHERE DATE_FORMAT(created_at, '%Y') = '2024'
- WHERE created_at >= '2024-01-01' AND created_at < '2025-01-01'
- WHERE created_at + INTERVAL 0 DAY >= '2024-01-01'
Индекс работает, когда столбец стоит в условии «голым», без функции или вычислений над ним.
YEAR(created_at) нужно вычислить для каждой строки — получается полный просмотр. Условие с функцией переписывают в диапазон по самому столбцу (или создают функциональный индекс).Почему пагинация
LIMIT 20 OFFSET 100000 медленная и что обычно предлагают взамен?SELECT * FROM posts
ORDER BY id
LIMIT 20 OFFSET 100000;- OFFSET не использует индекс вообще; взамен — добавить индекс на id
- Медленно только в MySQL; в PostgreSQL OFFSET выполняется за O(1)
- LIMIT выполняется до ORDER BY; взамен — подзапрос с сортировкой
- СУБД читает и отбрасывает 100 000 строк; взамен — keyset: WHERE id > :last_id ORDER BY id LIMIT 20
Даже по индексу СУБД вынуждена пройти и выбросить все строки до смещения, поэтому чем дальше страница, тем медленнее запрос. Keyset-пагинация («после последнего увиденного id») сразу переходит к нужному месту в индексе и работает одинаково быстро на любой странице; минус — нельзя прыгнуть на произвольный номер страницы.
CTE и рекурсия9
Где можно обращаться к CTE, объявленному через
WITH?- Только в том запросе, к которому относится WITH
- Во всех запросах текущей сессии, как к временной таблице
- До конца текущей транзакции
- Везде, пока его не удалят командой DROP
CTE — это именованный подзапрос, видимый только внутри одного SQL-оператора. После выполнения запроса он перестаёт существовать. Если результат нужен в нескольких запросах, используют временную таблицу (
CREATE TEMPORARY TABLE) или представление.Найдите ошибку в запросе с двумя CTE.
WITH paid AS (
SELECT * FROM orders WHERE status = 'paid'
)
WITH big AS (
SELECT * FROM paid WHERE total > 1000
)
SELECT COUNT(*) FROM big;- Второй CTE не может ссылаться на первый
- Внутри CTE нельзя использовать SELECT *
- Ошибки нет, запрос корректен
- Ключевое слово WITH пишется один раз, CTE перечисляются через запятую
Правильно:
WITH paid AS (...), big AS (...) SELECT .... Повторный WITH перед вторым CTE — синтаксическая ошибка. При этом ссылаться из следующего CTE на предыдущий можно — это обычная практика для пошаговых запросов.Что вернёт запрос?
WITH RECURSIVE n(i) AS (
SELECT 1
UNION ALL
SELECT i + 1 FROM n WHERE i < 5
)
SELECT COUNT(*), SUM(i) FROM n;- 4 | 10
- 5 | 15
- 6 | 21
- Бесконечный цикл
Якорь даёт 1, затем рекурсивная часть добавляет i + 1, пока условие
i < 5 истинно для предыдущей строки: 2, 3, 4, 5. На строке 5 условие ложно, новых строк нет — рекурсия останавливается. Итого числа 1..5: 5 штук, сумма 15.Хотели получить числа от 1 до 5. Какое максимальное значение
i будет в результате?WITH RECURSIVE n(i) AS (
SELECT 1
UNION ALL
SELECT i + 1 FROM n WHERE i <= 5
)
SELECT MAX(i) FROM n;- 6
- 5
- 4
- Бесконечный цикл
Условие в
WHERE проверяется для строки предыдущего шага, а новая строка — это уже i + 1. Для i = 5 условие i <= 5 истинно, и порождается 6; на 6 рекурсия останавливается. Классическая ошибка на единицу: для 1..5 нужно WHERE i < 5.В MySQL 8 рекурсивный CTE забыли ограничить условием остановки. Что произойдёт по умолчанию?
WITH RECURSIVE n(i) AS (
SELECT 1
UNION ALL
SELECT i + 1 FROM n
)
SELECT * FROM n;- Сервер будет выполнять запрос, пока не кончится память
- MySQL вернёт первые 1000 строк без ошибки
- Ошибка после 1000 итераций из-за лимита cte_max_recursion_depth
- Ошибка синтаксиса: рекурсивная часть обязана иметь WHERE
В MySQL 8 системная переменная
cte_max_recursion_depth (по умолчанию 1000) ограничивает число итераций: при превышении запрос падает с ошибкой, а не обрезает результат. WHERE синтаксически не обязателен — остановить рекурсию может и LIMIT (MySQL 8.0.19+). В PostgreSQL такого лимита нет, и запрос действительно будет работать бесконечно.Граф содержит цикл 1 → 2 → 3 → 1. Сколько строк вернёт запрос?
WITH RECURSIVE r(node) AS (
SELECT 1
UNION
SELECT g.b FROM edges g
JOIN r ON g.a = r.node
)
SELECT COUNT(*) FROM r;- Бесконечный цикл
- 4
- 1
- 3
С
UNION (без ALL) строки, которые уже есть в результате, отбрасываются: когда обход возвращается в узел 1, новых строк не появляется, и рекурсия завершается — получаем узлы 1, 2, 3. С UNION ALL дубли не фильтруются, и на цикле запрос ушёл бы в бесконечную рекурсию (или упёрся в лимит глубины).Какой уровень вложенности будет у сотрудника
Jr?-- emp(id, name, boss): (1,CEO,NULL), (2,CTO,1),
-- (3,Dev,2), (4,CFO,1), (5,Jr,3)
WITH RECURSIVE tree AS (
SELECT id, name, 1 AS lvl FROM emp WHERE boss IS NULL
UNION ALL
SELECT e.id, e.name, t.lvl + 1
FROM emp e JOIN tree t ON e.boss = t.id
)
SELECT lvl FROM tree WHERE name = 'Jr';- 3
- 4
- 5
- 2
Цепочка подчинения: CEO (1) → CTO (2) → Dev (3) → Jr (4). Каждый рекурсивный шаг присоединяет подчинённых к уже найденным и увеличивает
lvl на 1. Ответ 3 получится, если забыть, что якорь начинается с уровня 1, а не 0.Почему в MySQL 8 (строгий режим) этот запрос падает с ошибкой «Data too long for column 'path'»?
WITH RECURSIVE t(n, path) AS (
SELECT 1, 'a'
UNION ALL
SELECT n + 1, CONCAT(path, ',a') FROM t WHERE n < 3
)
SELECT * FROM t;- Типы столбцов рекурсивного CTE берутся из якоря, а 'a' — это строка длиной 1
- CONCAT нельзя использовать в рекурсивной части
- Столбцы рекурсивного CTE всегда имеют тип VARCHAR(255)
- MySQL не поддерживает строки в рекурсивных CTE
В MySQL типы столбцов рекурсивного CTE определяются только по нерекурсивной части.
'a' даёт строку длиной 1, и более длинное значение из рекурсивной части не помещается. Решение — расширить тип в якоре: CAST('a' AS CHAR(200)).Как PostgreSQL 12+ выполняет нерекурсивный CTE, на который ссылаются один раз и который не имеет побочных эффектов?
- Всегда материализует его во временную таблицу — это «барьер оптимизации»
- Встраивает его в основной запрос как подзапрос, если не указано AS MATERIALIZED
- Выполняет его отдельно для каждой строки основного запроса
- Кэширует результат между запросами сессии
До PostgreSQL 12 CTE всегда материализовался и мешал планировщику протаскивать условия внутрь. Начиная с 12-й версии такой CTE встраивается (inline) как обычный подзапрос, а прежнее поведение включается явно:
WITH x AS MATERIALIZED (...). Утверждение про «барьер оптимизации» — устаревший миф.CASE и функции8
Что вернёт выражение для строки, где
x IS NULL?SELECT CASE x
WHEN NULL THEN 'null'
WHEN 1 THEN 'one'
ELSE 'other'
END
FROM t;- 'null'
- NULL
- 'other'
- Ошибка синтаксиса
Простой
CASE x WHEN v сравнивает через x = v, а NULL = NULL даёт NULL (не TRUE), поэтому ветка WHEN NULL никогда не срабатывает и выполняется ELSE. Для проверки на NULL нужен поисковый CASE: CASE WHEN x IS NULL THEN ....Что вернёт выражение при
x = 150?SELECT CASE
WHEN x > 10 THEN 'big'
WHEN x > 100 THEN 'huge'
ELSE 'small'
END;- 'huge'
- 'big'
- 'small'
- 'big', 'huge'
Ветки
CASE проверяются сверху вниз, и возвращается результат первой истинной. 150 > 10 — уже TRUE, поэтому до x > 100 дело не доходит. Более узкие условия нужно ставить выше более широких.Что вернёт
CASE, если ни одна ветка WHEN не подошла, а ELSE не указан?- Пустую строку ''
- Ошибку выполнения
- Значение последней ветки THEN
- NULL
Отсутствующий
ELSE эквивалентен ELSE NULL. Это часто используют намеренно, например в COUNT(CASE WHEN ... THEN 1 END), но в отчётах это даёт неожиданные пустые значения, если забыть про ELSE.Что вернёт
COALESCE(NULL, '', 'x')?- 'x'
- '' (пустую строку)
- NULL
- Ошибку: аргументы разных видов
COALESCE возвращает первый аргумент, который не NULL. Пустая строка — это значение, а не NULL (в PostgreSQL, MySQL, SQLite; исключение — Oracle), поэтому она и возвращается. Ответ 'x' — частая ошибка, если путать пустую строку с NULL.Зачем в PostgreSQL пишут
total / NULLIF(cnt, 0)?- Чтобы при cnt = 0 получить NULL вместо ошибки деления на ноль
- Чтобы при cnt = 0 получить 0 вместо ошибки
- Чтобы заменить NULL в cnt на 0
- Чтобы округлить результат деления до целого
NULLIF(a, b) возвращает NULL, если a = b, иначе a. При cnt = 0 делитель становится NULL, и всё выражение — NULL вместо ошибки division by zero. Если нужен именно 0, оборачивают снаружи: COALESCE(total / NULLIF(cnt, 0), 0). Заменой NULL на значение занимается COALESCE, а не NULLIF.Что вернёт
GREATEST(1, NULL, 3) в MySQL и в PostgreSQL?- MySQL: 3, PostgreSQL: 3
- MySQL: 3, PostgreSQL: NULL
- MySQL: NULL, PostgreSQL: 3
- MySQL: NULL, PostgreSQL: NULL
В MySQL
GREATEST/LEAST возвращают NULL, если хотя бы один аргумент NULL. В PostgreSQL эти функции игнорируют NULL и возвращают NULL, только если все аргументы NULL. При переносе запросов между СУБД это частый источник расхождений — в MySQL аргументы оборачивают в COALESCE.В таблице 4 заказа со статусами 'paid', 'new', 'paid', NULL. Что вернут
a и b?SELECT
COUNT(CASE WHEN status = 'paid' THEN 1 END) AS a,
COUNT(CASE WHEN status = 'paid' THEN 1 ELSE 0 END) AS b
FROM orders;- a = 2, b = 2
- a = 2, b = 4
- a = 2, b = 3
- a = 3, b = 4
COUNT(выражение) считает все не-NULL значения, а 0 — не NULL. В a для неоплаченных CASE возвращает NULL, и они не считаются (2). В b они дают 0 и тоже считаются (4). Для варианта с ELSE 0 нужен SUM, а не COUNT.Что вернёт запрос в столбце
grade?SELECT score,
CASE
WHEN score >= 50 THEN 'зачёт'
WHEN score >= 90 THEN 'отлично'
ELSE 'незачёт'
END AS grade
FROM (SELECT 95 AS score) t;отлично— выбирается самое точное условиезачёт— срабатывает первая истинная веткаWHEN- Ошибка: условия
WHENпересекаются незачёт— при нескольких истинных ветках выбираетсяELSE
CASE проверяет ветки WHEN сверху вниз и возвращает результат первой истинной; остальные уже не рассматриваются. 95 ≥ 50, поэтому срабатывает «зачёт», а ветка «отлично» недостижима для любых оценок. Пороговые условия располагают от самого строгого к самому мягкому: сначала >= 90, затем >= 50.Даты и строки10
Что вернут
LENGTH('Привет') и CHAR_LENGTH('Привет') в MySQL при кодировке utf8mb4?- 6 и 6
- 12 и 12
- 12 и 6
- 6 и 12
В MySQL
LENGTH возвращает длину в байтах, а CHAR_LENGTH — в символах. Кириллица в UTF-8 занимает 2 байта на символ, поэтому 12 и 6. Проверка вида LENGTH(name) > 50 для ограничения «по символам» — классический баг на нелатинских текстах. (В PostgreSQL length() считает символы.)GROUP_CONCAT в MySQL вернул обрезанный список id без всякой ошибки. В чём причина?SELECT GROUP_CONCAT(id) FROM orders;- GROUP_CONCAT не умеет работать с числами больше 1000
- Сработал лимит group_concat_max_len (по умолчанию 1024 байта)
- Результат обрезан клиентом, сервер вернул всё
- Включён ONLY_FULL_GROUP_BY, он ограничивает агрегаты
Результат
GROUP_CONCAT обрезается до group_concat_max_len байт (по умолчанию 1024), выдаётся лишь предупреждение. Лимит поднимают через SET SESSION group_concat_max_len = .... В PostgreSQL аналог — string_agg(col::text, ',') — такого ограничения не имеет.Что вернёт
SUBSTRING('abcdef', 2, 3)?- 'cde'
- 'bc'
- 'bcd'
- 'cd'
В SQL позиции в строках нумеруются с 1, а третий аргумент — это длина, а не конечная позиция. Значит, берём 3 символа начиная со 2-го: 'bcd'. Вариант 'cde' — привычка к нумерации с 0 из языков программирования.
Таблица в MySQL с регистронезависимой collation (
utf8mb4_general_ci). Что вернёт запрос?SELECT REPLACE('Abc abc', 'abc', 'X');- 'X X'
- 'Abc X'
- 'X abc'
- 'Abc abc'
В MySQL
REPLACE всегда ищет с учётом регистра, независимо от collation, хотя сравнение 'abc' = 'ABC' в той же collation даёт TRUE. Поэтому заменяется только точное вхождение 'abc'.Что вернёт выражение в MySQL?
SELECT DATE_ADD('2024-01-31', INTERVAL 1 MONTH);- '2024-03-02'
- '2024-02-31'
- NULL, так как 31 февраля не существует
- '2024-02-29'
Если в целевом месяце нет такого дня, MySQL берёт последний день месяца; 2024 год високосный — получаем 29 февраля. «Переполнение» в март (как у
new Date() в JavaScript) не происходит. PostgreSQL ведёт себя так же: date '2024-01-31' + interval '1 month' = 2024-02-29.Что вернёт выражение
date '2024-03-01' - date '2024-02-01' в PostgreSQL?- Целое число 29
- Интервал '1 mon'
- Целое число 1
- Ошибку: даты нельзя вычитать
В PostgreSQL разность двух значений типа
date — целое число дней, а 2024 год високосный, поэтому 29. Интервал получается при вычитании timestamp. В MySQL оператор - для дат работает иначе, там используют DATEDIFF('2024-03-01', '2024-02-01'), который тоже вернёт 29.Столбец
created_at имеет тип DATETIME. Что не так с этим запросом за январь?SELECT * FROM orders
WHERE created_at BETWEEN '2024-01-01' AND '2024-01-31';- BETWEEN не работает с датами, нужен оператор IN
- Ничего, запрос возвращает все заказы за январь
- Не попадут заказы 31 января позже 00:00:00
- Попадут лишние заказы за 1 февраля
'2024-01-31' приводится к
2024-01-31 00:00:00, поэтому, например, заказ в 10:00 31 января не попадёт в выборку. Надёжный шаблон — полуоткрытый интервал: created_at >= '2024-01-01' AND created_at < '2024-02-01'. Он к тому же использует индекс по created_at.Что делает
DATE_TRUNC('month', ts) в PostgreSQL?- Возвращает номер месяца из ts (1..12)
- Возвращает ts, округлённый вниз до начала месяца (1-е число, 00:00:00)
- Отбрасывает месяц и возвращает только год
- Возвращает последний день месяца
DATE_TRUNC обнуляет все поля меньше указанного: '2024-05-17 14:30' → '2024-05-01 00:00:00'. Его удобно использовать для группировки по месяцам. Номер месяца возвращает другая функция — EXTRACT(MONTH FROM ts).Чем в PostgreSQL отличается
timestamptz (timestamp with time zone) от timestamp?- timestamptz хранит часовой пояс вместе со значением и выводит его как есть
- Ничем, это синонимы
- timestamptz хранит время с точностью до наносекунд, а timestamp — до секунд
- timestamptz хранит абсолютный момент (в UTC) и выводит его в часовом поясе сессии
При вставке в
timestamptz значение пересчитывается в UTC, а сам часовой пояс не сохраняется; при выводе момент переводится в TimeZone текущей сессии. timestamp хранит «настенное время» без привязки к поясу. Миф о том, что timestamptz хранит исходный пояс, — одна из самых частых ошибок.Что вернёт запрос в PostgreSQL 16 или MySQL 8?
SELECT LPAD('7', 3, '0') AS a,
LPAD('12345', 3, '0') AS b,
RPAD('ab', 5, 'xy') AS c;- a = '007', b = '12345', c = 'abxyx' — длинная строка не меняется
- a = '700', b = '123', c = 'xyxab'
- a = '007', b = '345', c = 'abxyx'
- a = '007', b = '123', c = 'abxyx'
LPAD(s, n, fill) дополняет строку слева символами fill до длины n, RPAD — справа; многосимвольный заполнитель повторяется и обрезается по нужной длине: 'ab' → 'abxyx'. Если строка уже длиннее n, обе функции её обрезают до n символов, оставляя начало: '12345' → '123'. Поэтому LPAD(code, 3, '0') для «ведущих нулей» молча портит слишком длинные значения — длину стоит проверять отдельно.Представления и процедуры5
Чем хранимая функция отличается от хранимой процедуры (MySQL 8 / PostgreSQL 16)?
- Функция возвращает значение и вызывается внутри выражений, в т.ч. в SELECT; процедура — отдельно через CALL
- Процедура возвращает значение, а функция — нет и вызывается через CALL
- Функции пишутся только на SQL, а процедуры — только на процедурных языках
- Разницы нет, вызовы через CALL и SELECT взаимозаменяемы
Функцию можно использовать прямо в запросе:
SELECT calc_tax(price) FROM items. Процедура вызывается отдельным оператором CALL proc(...), отдаёт данные через OUT-параметры (в MySQL — ещё и наборами строк), а в PostgreSQL 11+ в отличие от функции может управлять транзакциями (COMMIT/ROLLBACK внутри).Что хранит обычное (не материализованное) представление —
CREATE VIEW?- Копию данных на момент создания
- Только текст запроса; данные читаются из базовых таблиц при каждом обращении
- Кэш результатов последнего запроса
- Индекс по столбцам базовых таблиц
Обычное представление — сохранённый запрос: при каждом
SELECT из него выполняется подзапрос к базовым таблицам, поэтому данные всегда актуальны, а производительность такая же, как у исходного запроса. Копию данных хранит материализованное представление.Через какое представление в PostgreSQL / MySQL 8 можно выполнить
UPDATE без триггеров?- CREATE VIEW v AS SELECT dept, SUM(sal) s FROM emp GROUP BY dept
- CREATE VIEW v AS SELECT DISTINCT dept FROM emp
- CREATE VIEW v AS SELECT id, name, sal FROM emp WHERE active
- CREATE VIEW v AS SELECT id, name FROM emp UNION SELECT id, name FROM ex_emp
Обновляемым (автоматически) является представление над одной таблицей, где каждая строка соответствует ровно одной строке базовой таблицы: без
GROUP BY, агрегатов, DISTINCT, UNION. Для остальных случаев СУБД не может однозначно определить, какую строку менять; в PostgreSQL это решают через INSTEAD OF-триггеры.Что верно про
REFRESH MATERIALIZED VIEW CONCURRENTLY mv в PostgreSQL?- Не блокирует чтение из mv, но требует уникальный индекс на представлении
- Обновляет mv автоматически при каждом изменении базовых таблиц
- Работает быстрее обычного REFRESH и не требует дополнительных условий
- Блокирует базовые таблицы на запись до конца обновления
Материализованное представление в PostgreSQL обновляется только явно командой
REFRESH. Обычный REFRESH берёт эксклюзивную блокировку и мешает читателям, а CONCURRENTLY позволяет читать во время обновления, но требует хотя бы один уникальный индекс на mv и обычно работает медленнее, так как вычисляет разницу.Нужно в MySQL автоматически приводить email к нижнему регистру при вставке. Какой триггер подойдёт?
- AFTER INSERT с SET NEW.email = LOWER(NEW.email)
- BEFORE INSERT с SET NEW.email = LOWER(NEW.email)
- AFTER INSERT с UPDATE users SET email = LOWER(email) WHERE id = NEW.id
- BEFORE INSERT с SET OLD.email = LOWER(NEW.email)
Изменять значения
NEW можно только в BEFORE-триггере — до того, как строка записана. В AFTER-триггере NEW только для чтения, а UPDATE той же таблицы внутри её триггера MySQL запрещает (ошибка 1442). OLD при INSERT не существует.PostgreSQL20
Что вернёт запрос в PostgreSQL?
SELECT 'Hello' ILIKE 'h%' AS a,
'Hello' LIKE 'h%' AS b;- a = true, b = true
- a = false, b = false
- a = true, b = false
- Ошибка: оператора ILIKE не существует
ILIKE — расширение PostgreSQL: тот же LIKE, но без учёта регистра, поэтому Hello подходит под h%. Обычный LIKE в PostgreSQL регистрозависим (в отличие от MySQL с _ci-collation), и H ≠ h. Для поиска по ILIKE с ведущим шаблоном %...% обычный B-tree не поможет — нужен триграммный индекс pg_trgm.Между двумя запросами внутри транзакции прошло 5 секунд. Что покажут
a и b во втором SELECT по сравнению с первым (PostgreSQL)?BEGIN;
SELECT now() AS a, clock_timestamp() AS b;
-- ... 5 секунд ...
SELECT now() AS a, clock_timestamp() AS b;
COMMIT;- a не изменится, b увеличится на ~5 секунд
- Оба увеличатся на ~5 секунд
- Оба не изменятся
- a увеличится, b не изменится
now() (и CURRENT_TIMESTAMP) в PostgreSQL возвращает время начала транзакции — оно одинаково во всех запросах транзакции, что удобно для согласованных меток времени. Реальное текущее время даёт clock_timestamp(), а время начала текущего оператора — statement_timestamp(). Поэтому замерять длительность через now() внутри транзакции бессмысленно.Таблицу создали так. Что произойдёт при выполнении SELECT в PostgreSQL?
CREATE TABLE "Users" (id INT);
SELECT * FROM Users;- Запрос выполнится: имена таблиц нечувствительны к регистру
- Запрос выполнится, но вернёт предупреждение
- Ошибка синтаксиса в CREATE TABLE
- Ошибка: relation "users" does not exist
PostgreSQL приводит идентификаторы без кавычек к нижнему регистру:
Users превращается в users. А "Users" в кавычках сохраняет регистр, и таблица называется именно Users — обращаться к ней придётся всегда в кавычках. Поэтому имена в PostgreSQL принято писать в нижнем регистре через _ и не заключать в кавычки.Что вернёт запрос в PostgreSQL?
-- emp(dept, name, salary):
-- ('IT','a',100), ('IT','b',300),
-- ('HR','c',200), ('HR','d',50)
SELECT DISTINCT ON (dept) dept, name, salary
FROM emp
ORDER BY dept, salary DESC;- (HR, d, 50) и (IT, a, 100)
- (HR, c, 200) и (IT, b, 300)
- Все 4 строки: DISTINCT ON сравнивает всю строку
- (IT, b, 300) и (HR, c, 200) — в порядке вставки
DISTINCT ON (dept) оставляет по одной строке на каждое значение dept — первую в порядке ORDER BY. Так как внутри отдела сортировка по salary DESC, первой идёт максимальная зарплата, а отделы выводятся по dept (HR раньше IT). Это компактная PostgreSQL-альтернатива ROW_NUMBER() ... = 1 для «top-1 в группе».Что произойдёт при выполнении запроса в PostgreSQL?
SELECT DISTINCT ON (dept) dept, name, salary
FROM emp
ORDER BY salary DESC;- Вернётся самый высокооплачиваемый сотрудник каждого отдела
- Ошибка: выражения DISTINCT ON должны совпадать с началом ORDER BY
- Вернётся одна строка — максимальная зарплата по всей таблице
- Вернётся произвольный сотрудник каждого отдела
PostgreSQL требует, чтобы выражения
DISTINCT ON были самыми левыми в ORDER BY: правильно ORDER BY dept, salary DESC. Иначе «первая строка группы» не определена, и запрос падает с ошибкой SELECT DISTINCT ON expressions must match initial ORDER BY expressions. Если нужен другой итоговый порядок — оберните запрос в подзапрос и отсортируйте снаружи.Сколько строк вернёт запрос в PostgreSQL?
SELECT n FROM generate_series(1, 10, 3) AS n;- 3
- 10
- 30
- 4
generate_series(start, stop, step) выдаёт 1, 4, 7, 10 — граница stop включается, если на неё попадает шаг. Получается 4 строки. Функция часто используется для генерации последовательностей чисел или дат без отдельной таблицы.Сколько строк вернёт запрос в PostgreSQL?
SELECT d
FROM generate_series(
DATE '2024-01-01',
DATE '2024-01-31',
INTERVAL '1 week'
) AS d;- 5
- 4
- 31
- 7
Ряд идёт с шагом в неделю: 1, 8, 15, 22 и 29 января; следующее значение (5 февраля) уже за границей — итого 5 строк. Типичный приём:
generate_series по датам + LEFT JOIN с фактами, чтобы в отчёте появились и «пустые» дни/недели с нулём.Зачем в этом запросе (PostgreSQL) нужно ключевое слово
LATERAL?SELECT c.name, o.id, o.amount
FROM customers c
CROSS JOIN LATERAL (
SELECT id, amount FROM orders
WHERE orders.customer_id = c.id
ORDER BY amount DESC LIMIT 3
) o;- Чтобы подзапрос выполнился один раз и закэшировался для всех клиентов
- Чтобы в результат попали и клиенты, у которых нет заказов
- Чтобы подзапрос во FROM мог ссылаться на столбцы c
- Чтобы разрешить ORDER BY и LIMIT внутри подзапроса во FROM
Обычный подзапрос во
FROM вычисляется независимо и не видит соседние таблицы, поэтому c.id внутри него вызвал бы ошибку. LATERAL выполняет подзапрос для каждой строки c — получается «топ-3 заказа каждого клиента». Клиенты без заказов при CROSS JOIN LATERAL пропадут; чтобы их сохранить, пишут LEFT JOIN LATERAL (...) o ON true.Приложение должно выбрать пользователей по списку id произвольной длины одним подготовленным запросом с одним параметром. Какой вариант подходит для PostgreSQL?
- WHERE id IN ($1) — передать строку '1,2,3'
- WHERE id IN $1 — передать массив
- WHERE id = ALL($1::int[]) — передать массив
- WHERE id = ANY($1::int[]) — передать массив
= ANY(массив) истинно, если значение совпадает хотя бы с одним элементом, — это аналог IN, но с одним параметром-массивом, поэтому план запроса не зависит от длины списка. IN ($1) со строкой '1,2,3' сравнит id с одной строкой (и упадёт на приведении к int), а = ALL требует совпадения со всеми элементами сразу.Что вернёт запрос в PostgreSQL?
SELECT (ARRAY[10, 20, 30])[1] AS a,
(ARRAY[10, 20, 30])[0] AS b;- a = 20, b = 10
- a = 10, b — ошибка «индекс вне диапазона»
- a = 10, b = NULL
- a = 20, b = NULL
Массивы в PostgreSQL по умолчанию индексируются с 1, поэтому
[1] — первый элемент, 10. Обращение к несуществующему индексу (0 или 4) не вызывает ошибку, а возвращает NULL — это легко пропустить при отладке. (Не путайте с JSON-массивами: в jsonb оператор -> 0 берёт первый элемент.)Что на самом деле создаёт
id SERIAL в PostgreSQL?- Отдельный тип данных, который сам гарантирует уникальность и отсутствие пропусков
- Столбец integer + последовательность + DEFAULT nextval(...) для этого столбца
- Столбец integer с ограничением PRIMARY KEY
- То же, что GENERATED ALWAYS AS IDENTITY
SERIAL — не настоящий тип, а сокращение: создаётся последовательность t_id_seq, столбцу задаётся DEFAULT nextval('t_id_seq') и NOT NULL, а последовательность «принадлежит» столбцу. Уникальность сам по себе SERIAL не гарантирует — нужен PRIMARY KEY/UNIQUE. Современная стандартная замена — GENERATED ... AS IDENTITY, у которой права и владение последовательностью устроены проще.Таблица
t(id SERIAL PRIMARY KEY, name TEXT) пуста, последовательность не использовалась. Какой id получит строка c (PostgreSQL)?INSERT INTO t (name) VALUES ('a');
BEGIN;
INSERT INTO t (name) VALUES ('b');
ROLLBACK;
INSERT INTO t (name) VALUES ('c');- 3
- 2
- 1
- Ошибка: последовательность повреждена откатом
nextval() нетранзакционен: выданное значение не возвращается при ROLLBACK, иначе параллельные транзакции ждали бы друг друга. Строка b «съела» id = 2, поэтому c получит 3. Пропуски в id — нормальное поведение, на непрерывность последовательности полагаться нельзя (то же верно для AUTO_INCREMENT в MySQL).Остаток на складе был
qty = 5. Что вернёт запрос в PostgreSQL 16?UPDATE stock
SET qty = qty - 1
WHERE sku = 'A'
RETURNING qty;- 5 — значение до обновления
- 1 — число изменённых строк
- 4 — значение после обновления
- Ничего: RETURNING работает только с INSERT
RETURNING в PostgreSQL работает с INSERT, UPDATE и DELETE и возвращает строки в состоянии после выполнения команды, то есть новое значение 4. Это позволяет атомарно уменьшить счётчик и сразу узнать результат без отдельного SELECT (и без гонки между ними). Для DELETE RETURNING отдаёт удалённые строки.В
users уже есть строка с email = 'a@x.io' (на email есть UNIQUE). Что вернёт запрос в PostgreSQL?INSERT INTO users (email)
VALUES ('a@x.io')
ON CONFLICT (email) DO NOTHING
RETURNING id;- Ноль строк
- id существующей строки с этим email
- Одна строка с NULL в столбце id
- Ошибка duplicate key value violates unique constraint
При
DO NOTHING строка не вставляется, и RETURNING возвращает только реально вставленные строки — здесь пустой результат. Код вида «вставь или получи id» часто на этом ломается. Обычные решения: отдельный SELECT id ... WHERE email = ... после вставки или трюк ON CONFLICT (email) DO UPDATE SET email = EXCLUDED.email RETURNING id (ценой лишней записи строки).В таблице
stock(sku PRIMARY KEY, qty) строки с sku = 'A' нет. Что произойдёт в PostgreSQL?INSERT INTO stock (sku, qty)
VALUES ('A', 1), ('A', 2)
ON CONFLICT (sku)
DO UPDATE SET qty = stock.qty + EXCLUDED.qty;- Вставится одна строка A = 3 (1 + 2)
- Вставится A = 1, затем вторая строка обновит её до A = 3
- Вставится A = 2: последняя строка из VALUES побеждает
- Ошибка: команда не может изменить одну строку дважды
Одна команда
INSERT ... ON CONFLICT DO UPDATE не может затронуть одну и ту же строку повторно — это ошибка command cannot affect row a second time, даже если строки в таблице до этого не было. Поэтому пакет данных перед upsert нужно дедуплицировать по ключу (например, GROUP BY sku с SUM(qty)). MySQL ON DUPLICATE KEY UPDATE в такой ситуации обработал бы строки по очереди.На столбце
email нет ни UNIQUE-ограничения, ни уникального индекса. Что сделает PostgreSQL?INSERT INTO users (email, name)
VALUES ('a@x.io', 'Ann')
ON CONFLICT (email) DO UPDATE SET name = EXCLUDED.name;- Обычную вставку, ведь конфликтовать не с чем
- Ошибка: нет подходящего уникального ограничения
- Обновит name во всех строках с таким email
- Автоматически создаст уникальный индекс на email и выполнит upsert
ON CONFLICT (email) требует уникального индекса или ограничения (либо exclusion constraint), точно совпадающего со списком столбцов, — иначе запрос не выполняется: there is no unique or exclusion constraint matching the ON CONFLICT specification. «Конфликт» определяется именно через нарушение уникальности, без него upsert невозможен.Схемы
app и public существуют. В какую схему попадёт новая таблица в PostgreSQL?SET search_path = app, public;
CREATE TABLE logs (id INT);- public — таблицы всегда создаются в public
- app — первую существующую схему из search_path
- В обе схемы
- Ошибка: нужно указать схему явно
search_path — список схем, где ищутся объекты без явной схемы; CREATE без схемы создаёт объект в первой существующей схеме списка, то есть в app. При поиске SELECT * FROM logs схемы перебираются по порядку. Чтобы не зависеть от настроек сессии, в миграциях часто пишут имена полностью: app.logs.Что произойдёт после выполнения этого кода в PostgreSQL?
BEGIN;
CREATE TABLE tmp_report (id INT);
INSERT INTO tmp_report VALUES (1);
ROLLBACK;
SELECT * FROM tmp_report;- Вернётся пустая таблица — откатился только INSERT
- Вернётся строка 1 — ROLLBACK не действует на DDL
- Вернётся строка 1 с предупреждением
- Ошибка: таблицы tmp_report не существует
В PostgreSQL DDL транзакционен:
CREATE TABLE, ALTER TABLE и т.п. откатываются вместе с данными, поэтому таблицы нет. Это удобно для миграций: упавшая миграция не оставляет схему в промежуточном состоянии. В MySQL наоборот — DDL вызывает неявный COMMIT и не откатывается.Внутри транзакции в PostgreSQL второй запрос упал с ошибкой. Что произойдёт с третьим?
BEGIN;
INSERT INTO t VALUES (1);
INSERT INTO t VALUES ('abc'); -- ошибка типа
INSERT INTO t VALUES (2);- Ошибка: current transaction is aborted — команды игнорируются до конца транзакции
- Выполнится, и после COMMIT в таблице будут 1 и 2
- Выполнится, а COMMIT сохранит только 2
- Транзакция автоматически откатится и третий INSERT выполнится в автокоммите
После любой ошибки PostgreSQL переводит транзакцию в состояние aborted: все следующие команды отклоняются, а
COMMIT фактически выполнит ROLLBACK. Продолжить можно только с точки сохранения (SAVEPOINT + ROLLBACK TO SAVEPOINT). В MySQL ошибка одного оператора транзакцию не прерывает — отсюда частые сюрпризы при переносе кода.Что вернёт запрос в PostgreSQL?
SELECT '42'::int + 1;- '421'
- Ошибка: нельзя сложить строку и число
- 43
- 42
:: — сокращённая запись приведения типа в PostgreSQL, эквивалент CAST('42' AS int). После приведения складываются числа, результат 43. Если строку привести нельзя ('4x'::int), будет ошибка invalid input syntax for type integer — PostgreSQL, в отличие от MySQL, не «догадывается» о числе в начале строки.JSON в базе15
В PostgreSQL столбец
data имеет тип jsonb. Какой оператор вернёт значение поля name как обычный текст (Ann, без кавычек)?- data -> 'name'
- data @> 'name'
- data ? 'name'
- data ->> 'name'
-> возвращает jsonb (строка будет "Ann" в кавычках, как JSON-значение), а ->> — text. @> проверяет вхождение одного JSON в другой, ? — наличие ключа; оба возвращают boolean. Правило: -> для дальнейшей навигации по вложенному JSON, ->> — когда нужно конечное значение для сравнения или вывода.Что произойдёт при выполнении запроса в PostgreSQL (
data — jsonb)?SELECT * FROM events
WHERE data -> 'status' = 'active';- Вернутся все события со статусом active
- Пустой результат: jsonb никогда не равен строке
- Ошибка: 'active' — невалидный JSON
- Ошибка: оператор = для типа jsonb не определён
data -> 'status' имеет тип jsonb, поэтому литерал 'active' приводится к jsonb, а это невалидный JSON (строка в JSON должна быть в кавычках). Правильно — data ->> 'status' = 'active' (сравнение текста) или data -> 'status' = '"active"'. Ещё лучше для индекса GIN — data @> '{"status":"active"}'.Что вернёт запрос в PostgreSQL?
SELECT '{"a": 1, "tags": ["x", "y"]}'::jsonb
@> '{"tags": ["y"]}'::jsonb;- false: массив tags не совпадает целиком
- true
- false: не хватает ключа a
- Ошибка: @> работает только с массивами
@> («содержит») проверяет, что правый JSON вложен в левый: все указанные ключи есть, а для массивов достаточно, чтобы перечисленные элементы присутствовали (порядок и остальные элементы не важны). Лишние ключи слева (a) не мешают. Этот оператор поддерживается GIN-индексом, поэтому его предпочитают сравнению через ->>.Что вернёт запрос в PostgreSQL?
SELECT '{"a": null}'::jsonb ? 'a' AS has_key,
('{"a": null}'::jsonb ->> 'a') IS NULL AS is_null;- has_key = true, is_null = true
- has_key = false, is_null = true
- has_key = true, is_null = false
- has_key = false, is_null = false
Оператор
? проверяет наличие ключа верхнего уровня, а ключ a есть — его значение JSON null. ->> превращает JSON null в SQL NULL, поэтому IS NULL тоже истинно. Отсюда важное различие: «ключ есть со значением null» и «ключа нет» через ->> неотличимы, а через ? — различимы.Создан индекс
CREATE INDEX ON docs USING GIN (data); (data — jsonb, класс операторов по умолчанию). Какое условие сможет использовать этот индекс?- WHERE data ->> 'status' = 'paid'
- WHERE data::text LIKE '%paid%'
- WHERE data @> '{"status": "paid"}'
- WHERE lower(data ->> 'status') = 'paid'
GIN-индекс по
jsonb (класс jsonb_ops) обслуживает операторы @>, ?, ?|, ?& и jsonpath-операторы @?, @@, но не сравнение результата ->>. Для data ->> 'status' = 'paid' нужен отдельный B-tree индекс по выражению: CREATE INDEX ON docs ((data ->> 'status')). LIKE по тексту всего документа не использует ни тот, ни другой.Чем GIN-индекс с классом
jsonb_path_ops отличается от индекса с классом по умолчанию jsonb_ops в PostgreSQL?- Он компактнее и быстрее для @>, но не поддерживает ?
- Он поддерживает больше операторов, включая сравнение результата ->>
- Он строится на B-tree и поэтому поддерживает сортировку по JSON
- Ничем: это устаревший синоним jsonb_ops, оставленный для совместимости
jsonb_path_ops индексирует хэши путей «ключ → значение», а не отдельные ключи и значения, поэтому индекс компактнее и точнее для запросов на вхождение @> (и jsonpath @?, @@). Цена — нельзя искать просто по наличию ключа (?), так как ключи отдельно не хранятся. Выбор зависит от запросов: только @> — jsonb_path_ops, нужны ? — jsonb_ops.Что вернёт запрос в PostgreSQL?
SELECT '{"a": 1, "a": 2}'::json AS j,
'{"a": 1, "a": 2}'::jsonb AS jb;- j = {"a": 2}, jb = {"a": 2}
- j = {"a": 1, "a": 2}, jb = {"a": 1}
- Ошибка: дублирующийся ключ в JSON
- j = {"a": 1, "a": 2}, jb = {"a": 2}
Тип
json хранит исходный текст как есть — с пробелами, порядком ключей и дубликатами. jsonb при вставке разбирает документ в бинарный формат: дубликаты ключей схлопываются (остаётся последнее значение), порядок ключей и пробелы не сохраняются. Зато jsonb быстрее обрабатывается и индексируется, поэтому почти всегда выбирают его.Что вернёт запрос в SQLite (JSON-функции встроены)?
SELECT json_extract('{"a": {"b": [10, 20]}}', '$.a.b[1]');- 10
- 20
- [10, 20]
- NULL
В JSON-путях (SQLite, MySQL)
$ — корень документа, .a.b — вложенные ключи, а индексы массивов начинаются с 0, поэтому [1] — второй элемент, 20. Тот же путь в MySQL: JSON_EXTRACT(doc, '$.a.b[1]').Что вернёт запрос в SQLite 3.38+?
SELECT '{"s": "x"}' -> '$.s' AS a,
'{"s": "x"}' ->> '$.s' AS b;- a = x, b = x
- a = "x" (JSON с кавычками), b = x
- a = x, b = "x"
- Ошибка: операторы -> и ->> есть только в PostgreSQL
Начиная с SQLite 3.38 операторы ведут себя как в PostgreSQL и MySQL:
-> возвращает JSON-представление значения (строка в кавычках), ->> — «распакованное» SQL-значение (текст, число или NULL). Для сравнения с обычными строками нужен ->>.Что вернёт запрос в MySQL 8?
SELECT JSON_EXTRACT('{"name": "Ann"}', '$.name') AS a;- Ann — без кавычек
- NULL, так как нужен JSON_UNQUOTE
- {"name": "Ann"} — весь документ
- "Ann" — в кавычках
JSON_EXTRACT возвращает значение типа JSON, поэтому строка выводится в кавычках, и сравнение = 'Ann' с ним может вести себя неожиданно. Чтобы получить обычный текст, используют JSON_UNQUOTE(JSON_EXTRACT(...)) или сокращение col->>'$.name' (а col->'$.name' — это просто JSON_EXTRACT).В MySQL 8 часто фильтруют по
attrs->>'$.color' (столбец attrs JSON). Как ускорить такой поиск индексом?- Сгенерированный столбец из выражения + обычный индекс
- CREATE INDEX ix ON t (attrs) — проиндексирует все ключи JSON
- Добавить FULLTEXT-индекс на столбец JSON и искать через MATCH
- Никак: столбцы JSON и выражения над ними в MySQL не индексируются
Столбец
JSON в MySQL нельзя проиндексировать напрямую. Стандартный приём — color VARCHAR(30) AS (attrs->>'$.color') STORED/VIRTUAL + обычный индекс по нему; с 8.0.13 можно функциональный индекс по выражению (CAST(attrs->>'$.color' AS CHAR(30))). Для массивов в 8.0.17+ есть multi-valued индексы. Аналога GIN «на весь документ», как в PostgreSQL, нет.Когда хранение данных в JSON-столбце обычно оправдано?
- Для полей, по которым часто делают JOIN и строят отчёты
- Для связей между таблицами вместо внешних ключей и таблиц связей
- Для редко фильтруемых атрибутов с переменным набором полей
- Для любых данных: JSON всегда быстрее нормализованных таблиц
JSON хорош для «хвоста» слабоструктурированных данных, которые в основном читаются целиком. Поля, по которым соединяют таблицы, фильтруют и агрегируют, лучше держать обычными столбцами: так работают типы, NOT NULL, CHECK, внешние ключи и обычные индексы. Массив id в JSON вместо таблицы связей лишает ссылочной целостности.
Что вернёт запрос в PostgreSQL?
SELECT '{"a": 1, "b": 2}'::jsonb || '{"b": 3, "c": 4}'::jsonb;- {"a": 1, "b": 2, "c": 4}
- {"a": 1, "b": [2, 3], "c": 4}
- Ошибка: || работает только со строками
- {"a": 1, "b": 3, "c": 4}
Для
jsonb оператор || объединяет объекты по ключам верхнего уровня, и при совпадении побеждает значение справа. Слияние неглубокое: вложенные объекты заменяются целиком, а не сливаются. Удалить ключ можно оператором -: data - 'b'.Что вернёт запрос в PostgreSQL?
SELECT '[10, 20, 30]'::jsonb -> 1;- 10
- NULL
- 20
- Ошибка: ключ должен быть строкой
Целое число справа от
-> — индекс элемента JSON-массива, и он начинается с 0, поэтому результат — 20 (отрицательный индекс считается с конца). Не путайте с обычными массивами PostgreSQL (ARRAY[...]), которые индексируются с 1.В
jsonb лежит {"price": 10}. Что вернёт условие в PostgreSQL?SELECT ('{"price": 10}'::jsonb ->> 'price') > '9';- true — 10 больше 9
- false — сравниваются строки '10' и '9'
- NULL
- Ошибка: нельзя сравнить jsonb и text
->> всегда возвращает text, а литерал '9' тоже текст, поэтому сравнение строковое: '1' меньше '9', и '10' > '9' ложно. Для числового сравнения нужно привести тип: (data ->> 'price')::numeric > 9. Если же написать > 9 без кавычек, PostgreSQL выдаст ошибку operator does not exist: text > integer.Индексы: продвинутое15
Создан частичный индекс. Какой запрос сможет его использовать (PostgreSQL / SQLite)?
CREATE INDEX ix_new ON orders (created_at)
WHERE status = 'new';- WHERE status = 'new' AND created_at > '2024-01-01'
- WHERE created_at > '2024-01-01'
- WHERE status = 'paid' AND created_at > '2024-01-01'
- WHERE status <> 'new'
Частичный индекс содержит только строки, удовлетворяющие его
WHERE, поэтому планировщик применит его, лишь когда условие запроса гарантирует это условие индекса. Без status = 'new' в запросе индекс мог бы пропустить нужные строки. Выгода — маленький индекс по «горячему» подмножеству (например, необработанные заказы).Сколько строк окажется в
subs после выполнения (PostgreSQL / SQLite)?CREATE TABLE subs (user_id INT, active BOOLEAN);
CREATE UNIQUE INDEX ux_active ON subs (user_id)
WHERE active;
INSERT INTO subs VALUES (1, false), (1, false);
INSERT INTO subs VALUES (1, true);
INSERT INTO subs VALUES (1, true);- 1 — уже вторая неактивная строка нарушит уникальность
- 4 — частичный индекс не может быть уникальным
- 3 — последний INSERT упадёт с нарушением уникальности
- 2 — неактивные строки отбрасываются
Уникальный частичный индекс проверяет уникальность только среди строк, попавших под его условие: неактивных подписок у пользователя может быть сколько угодно, а активная — только одна. Поэтому первые три строки вставятся, а вторая активная вызовет ошибку. Это стандартный способ выразить правило «не больше одной активной записи». В MySQL частичных индексов нет.
Создан индекс по выражению. Какой запрос его использует?
CREATE INDEX ix_email_lower ON users (lower(email));- WHERE lower(email) = 'ann@x.io'
- WHERE email = 'ann@x.io'
- WHERE email ILIKE 'ann@x.io'
- WHERE upper(email) = 'ANN@X.IO'
Индекс по выражению хранит уже вычисленные
lower(email), и планировщик применяет его, только если в запросе стоит то же самое выражение. Условие на «голый» email или на upper(email) этот индекс не использует. Приём часто применяют для регистронезависимого поиска по email или логину.Какая строка
EXPLAIN QUERY PLAN в SQLite означает, что для поиска используется индекс?- SCAN orders
- SCAN orders USING TEMP B-TREE FOR DISTINCT
- USE TEMP B-TREE FOR ORDER BY
- SEARCH orders USING INDEX ix_user (user_id=?)
В SQLite
SEARCH ... USING INDEX значит, что строки ищутся по индексу, а в скобках видно, по каким столбцам. SCAN orders — полный перебор таблицы (аналог Seq Scan в PostgreSQL и type: ALL в MySQL). USE TEMP B-TREE FOR ORDER BY говорит о сортировке во временной структуре: индекс не покрыл ORDER BY.Для какого случая в PostgreSQL лучше всего подходит индекс BRIN?
- Поиск по точному значению случайного UUID в большой таблице
- Огромная append-only таблица логов с растущим created_at
- Полнотекстовый поиск по описанию товара
- Маленький справочник на сотню строк, который часто обновляется
BRIN (Block Range INdex) хранит лишь min/max для диапазонов страниц, поэтому он крошечный, но эффективен только при сильной корреляции значения с физическим расположением строк — как у времени вставки в логах. Для случайно распределённых значений (UUID) BRIN почти бесполезен, там нужен B-tree; для текста — GIN.
Нужно запретить пересекающиеся бронирования одной комнаты:
EXCLUDE USING ??? (room_id WITH =, during WITH &&), где during — tsrange. Какой тип индекса здесь нужен в PostgreSQL?- B-tree
- GiST
- Hash
- BRIN
Exclusion constraint проверяет, что никакие две строки не удовлетворяют всем операторам сразу; оператор пересечения диапазонов
&& поддерживается GiST (или SP-GiST), а не B-tree. Чтобы в том же GiST-индексе использовать = для обычного integer, подключают расширение btree_gist. UNIQUE-ограничение такую задачу не решает: диапазоны не равны, но пересекаются.Фрагмент
EXPLAIN ANALYZE в PostgreSQL. На какую проблему он указывает в первую очередь?Nested Loop (cost=... rows=1 ...)
(actual time=... rows=184230 loops=1)- Запрос вернул ровно одну строку, как и ожидалось
- Nested Loop всегда означает ошибку в тексте запроса
- Индекс повреждён и требует REINDEX, иначе оценки не сойдутся
- Оценка числа строк сильно ошибается — вероятно, устарела статистика
В скобках
cost=... rows= — оценка планировщика, в actual ... rows= — реальность. Ожидая 1 строку, планировщик выбрал Nested Loop, а получил 184 тыс. — такой план будет медленным. Частые причины — устаревшая статистика (лечится ANALYZE таблицы) или коррелированные условия, которые планировщик считает независимыми (CREATE STATISTICS).Что делает узел
Bitmap Heap Scan (вместе с Bitmap Index Scan) в плане PostgreSQL?- Собирает по индексу карту страниц и читает их по порядку
- Читает только индекс, вообще не обращаясь к страницам таблицы
- Последовательно читает всю таблицу и фильтрует строки по условию
- Строит временный индекс на время выполнения запроса
Bitmap-сканирование — промежуточный вариант между
Index Scan и Seq Scan: адреса строк из индекса складываются в битовую карту, и страницы таблицы читаются по порядку, без многократных случайных обращений к одной странице. Оно выбирается при средней селективности, а также позволяет комбинировать несколько индексов через BitmapAnd/BitmapOr.В таблице
countries 200 строк, на code есть индекс, но EXPLAIN показывает Seq Scan. Почему?EXPLAIN SELECT * FROM countries WHERE code = 'BY';- Индекс сломан и требует REINDEX после обновления
- PostgreSQL не использует B-tree индексы для текстовых столбцов
- Таблица крошечная — прочитать её целиком дешевле
- EXPLAIN всегда показывает Seq Scan, реальный план виден только в EXPLAIN ANALYZE
Планировщик сравнивает стоимость: крошечную таблицу дешевле прочитать последовательно, чем делать лишние обращения к индексу и затем к таблице. Это нормальное поведение, а не проблема. Проверять использование индекса стоит на реалистичном объёме данных, иначе выводы по
EXPLAIN будут неверными.В плане PostgreSQL видно
Index Only Scan ... Heap Fetches: 95000. Что это значит и как это обычно исправить?- Индекс не покрывает запрос; нужно добавить недостающие столбцы в индекс
- Индекс сильно фрагментирован; помогает только полный REINDEX
- Запрос прочитал 95000 строк из кэша без обращения к диску; это оптимально
- Часть страниц не all-visible, строки проверялись в таблице; поможет VACUUM
Из-за MVCC индекс не знает, видима ли строка текущей транзакции. Index Only Scan пропускает обращение к таблице только для страниц, отмеченных в visibility map как all-visible; для остальных идёт проверка в heap — это
Heap Fetches. Visibility map обновляет VACUUM (в том числе autovacuum), поэтому на часто изменяемых таблицах Index Only Scan может деградировать до обычного.Разработчик запустил в PostgreSQL
EXPLAIN ANALYZE DELETE FROM orders WHERE created_at < '2020-01-01';, чтобы посмотреть план. Что произошло с данными?- Ничего: EXPLAIN никогда не изменяет данные
- Строки удалены, но откатятся после завершения EXPLAIN
- Строки действительно удалены: EXPLAIN ANALYZE выполняет запрос
- Запрос завершится ошибкой: ANALYZE нельзя применять к DELETE
EXPLAIN без ANALYZE только строит план, а EXPLAIN ANALYZE реально выполняет запрос, чтобы измерить фактическое время и число строк. Для изменяющих запросов его оборачивают в транзакцию: BEGIN; EXPLAIN ANALYZE DELETE ...; ROLLBACK;.База PostgreSQL создана с локалью
ru_RU.UTF-8. Обычный индекс CREATE INDEX ON users (name) не используется для WHERE name LIKE 'Ив%'. Как это исправить?- Заменить LIKE на ILIKE, чтобы задействовать индекс
- Индекс с классом text_pattern_ops
- Пересоздать индекс как USING HASH
- Ничего: LIKE с префиксом индексы не использует ни при какой настройке
Поиск по префиксу через B-tree возможен, когда порядок в индексе побайтовый. При не-C collation порядок сортировки лингвистический, и PostgreSQL не может превратить
LIKE 'Ив%' в диапазон по такому индексу. Класс text_pattern_ops (или collation "C" у индекса) решает проблему; при этом для ORDER BY name и сравнений </> по-прежнему нужен обычный индекс.Что верно про
CREATE INDEX CONCURRENTLY в PostgreSQL?- Не блокирует запись, но нельзя внутри транзакции, а при сбое остаётся INVALID-индекс
- Строит индекс в несколько потоков и поэтому всегда быстрее обычного CREATE INDEX
- Блокирует таблицу и на чтение, и на запись, зато строит индекс быстрее
- Позволяет создать индекс внутри BEGIN ... COMMIT вместе с другими изменениями схемы
Обычный
CREATE INDEX берёт блокировку, запрещающую INSERT/UPDATE/DELETE на всё время построения — на большой боевой таблице это простой. CONCURRENTLY дважды сканирует таблицу и ждёт завершения старых транзакций, зато не останавливает запись. Ограничения: его нельзя запускать в блоке транзакции, а неудачная попытка оставляет невалидный индекс, который нужно удалить и создать заново.В PostgreSQL объявлен внешний ключ
orders.customer_id REFERENCES customers(id). Что верно про индексы?- PostgreSQL автоматически создаёт индекс на orders.customer_id
- Индекс на customers.id нужно создать вручную, иначе FK не создастся
- На orders.customer_id индекс нужно создать самому
- Индексы для внешних ключей не нужны: проверка идёт по статистике таблицы
PostgreSQL требует уникальный индекс на стороне родителя (
customers.id — это PK, он уже есть), но на ссылающемся столбце индекс не создаёт. Без него каждое удаление/изменение клиента сканирует orders целиком, и медленными становятся JOIN-ы по customer_id. InnoDB в MySQL, наоборот, создаёт индекс на столбце внешнего ключа автоматически, если его нет.Зачем в PostgreSQL 11+ пишут
CREATE INDEX ON orders (user_id) INCLUDE (total)?- Чтобы total отдавался из индекса (Index Only Scan), не входя в ключ
- Чтобы индекс стал уникальным по паре (user_id, total)
- Чтобы индекс хранил строки отсортированными по total внутри user_id
- Чтобы total автоматически пересчитывался при изменении user_id
Столбцы из
INCLUDE хранятся в листьях индекса как «полезная нагрузка»: их можно отдать без обращения к таблице (покрывающий индекс), но по ним нельзя искать и сортировать. Это удобно, например, чтобы оставить уникальность только по user_id и при этом покрыть запрос. В MySQL аналога нет — там столбец просто добавляют в составной индекс.MySQL и InnoDB20
Таблицу InnoDB создали без PRIMARY KEY и без уникальных индексов. Как InnoDB хранит её строки?
CREATE TABLE event_log (
msg TEXT,
created_at DATETIME
) ENGINE=InnoDB;- Хранит строки неупорядоченной кучей (heap), как PostgreSQL
- Отказывается создавать таблицу без первичного ключа
- Кластерный индекс по скрытому 6-байтовому row id
- Делает кластерным индексом первый по порядку столбец таблицы
В InnoDB данные таблицы всегда лежат в B+-дереве кластерного индекса. Если PK нет, им становится первый UNIQUE-индекс, все столбцы которого NOT NULL, а если нет и такого — скрытый
GEN_CLUST_INDEX по внутреннему счётчику DB_ROW_ID. Этот столбец недоступен в запросах, поэтому PK лучше всегда задавать явно.Почему в InnoDB длинный первичный ключ (например,
VARCHAR(255) или UUID строкой CHAR(36)) увеличивает размер ВСЕХ вторичных индексов таблицы?- Вторичный индекс хранит значение PK как ссылку на строку
- Каждый вторичный индекс содержит полную копию строки таблицы
- InnoDB дублирует первичный ключ в заголовке каждой страницы данных
- Не увеличивает: вторичные индексы хранят физический адрес строки на диске
В InnoDB вторичный индекс указывает на строку не физическим адресом, а значением PK, по которому затем ищут в кластерном индексе. Поэтому 36-байтовый ключ повторяется в каждой записи каждого вторичного индекса, увеличивая их размер и нагрузку на память. Отсюда совет: компактный PK (
INT/BIGINT, UUID — в BINARY(16)).В таблице InnoDB с
AUTO_INCREMENT id идут 1, 2, 3, 7, 8 — строки никто не удалял. Что верно?- Таблица повреждена, нужно выполнить REPAIR TABLE
- InnoDB должен был заполнить дыры 4–6 следующими вставками
- Так бывает, только если вручную менялся auto_increment_increment
- Это нормально: значения тратят и откаты, и INSERT IGNORE
Значение AUTO_INCREMENT выделяется до того, как станет известно, будет ли строка сохранена: при
ROLLBACK, при пропущенном дубликате в INSERT IGNORE или при обновлении вместо вставки в ON DUPLICATE KEY UPDATE оно теряется. Повторно InnoDB такие номера не выдаёт. Поэтому id годится как уникальный ключ, но не как счётчик количества строк.В таблице InnoDB максимальный id был 10. Строки 9 и 10 удалили, затем перезапустили сервер. Какой id получит следующая вставка в MySQL 5.7 и в MySQL 8.0?
- 5.7 — 11, 8.0 — 11
- 5.7 — 9, 8.0 — 11
- 5.7 — 11, 8.0 — 9
- 5.7 — 9, 8.0 — 9
До MySQL 8.0 счётчик AUTO_INCREMENT жил только в памяти и после рестарта вычислялся как
MAX(id) + 1, поэтому удалённые «хвостовые» id выдавались повторно — это ломало логику, если старые id где-то сохранились (логи, архив). В 8.0 счётчик сохраняется в redo log и переживает перезапуск, следующий id будет 11.Как поведёт себя запрос с
ONLY_FULL_GROUP_BY в MySQL 8 и в PostgreSQL (users.id — PRIMARY KEY)?SELECT u.id, u.name, COUNT(o.id) AS cnt
FROM users u
LEFT JOIN orders o ON o.user_id = u.id
GROUP BY u.id;- Ошибка в обеих: name нет в GROUP BY
- Выполнится в обеих СУБД
- Ошибка только в MySQL 8 из-за ONLY_FULL_GROUP_BY
- Ошибка только в PostgreSQL, MySQL выполнит запрос
Стандарт SQL:1999 разрешает выбирать столбцы, функционально зависимые от столбцов группировки. Раз
u.id — PK, у каждой группы ровно одно значение u.name, и MySQL (5.7.5+) и PostgreSQL (9.1+) это распознают. Ошибка была бы, если группировать по неуникальному столбцу, например GROUP BY u.city.Какой приём ускоряет «глубокую» страницу в MySQL, если менять UI на keyset-пагинацию нельзя? Есть индекс на
created_at.-- медленно:
SELECT * FROM posts
ORDER BY created_at
LIMIT 100000, 20;- Заменить LIMIT 100000, 20 на LIMIT 20 OFFSET 100000
- Добавить SQL_CALC_FOUND_ROWS, чтобы MySQL закэшировал позиции
- Перенести LIMIT в подзапрос: WHERE id IN (SELECT id ... LIMIT 100000, 20)
- Отложенный JOIN: выбрать 20 id по индексу, затем строки
Медленно потому, что для каждой из 100 020 строк читается вся строка из таблицы. В подзапросе
SELECT id FROM posts ORDER BY created_at LIMIT 100000, 20 хватает покрывающего индекса (вторичный индекс InnoDB содержит PK), а затем JOIN posts USING (id) дочитывает только 20 строк. Вариант с IN (... LIMIT ...) в MySQL не работает: ошибка «doesn't yet support LIMIT & IN subquery». LIMIT a, b и LIMIT b OFFSET a — одно и то же.Столбец
name VARCHAR(50) NOT NULL, DEFAULT не задан, строгий режим включён. Что сделает MySQL?INSERT IGNORE INTO users (id, name)
VALUES (1, NULL);- Вставит name = '' с предупреждением
- Откажется вставлять: нарушен NOT NULL
- Вставит строку с name = NULL
- Пропустит строку молча, без каких-либо предупреждений
IGNORE гасит не только ошибки дубликатов: нарушения NOT NULL, слишком длинные строки, неверные значения превращаются в предупреждения, а данные «подгоняются» — здесь подставится неявное значение по умолчанию ''. Поэтому INSERT IGNORE как «вставь, если нет дубликата» опасен: он молча портит данные. Безопаснее INSERT ... ON DUPLICATE KEY UPDATE id = id или проверка дубликата заранее.В таблице
posts(id PK, title, views INT DEFAULT 0) есть строка (1, 'a', 100). Что окажется в ней после запроса в MySQL?REPLACE INTO posts (id, title) VALUES (1, 'b');- (1, 'b', 100)
- (1, 'a', 100) — REPLACE не трогает существующие строки
- (1, 'b', 0)
- Ошибка duplicate key
REPLACE при конфликте ключа удаляет старую строку и вставляет новую, а не обновляет её: столбцы, которых нет в запросе, получают значения по умолчанию, и views сбросится в 0. MySQL сообщит 2 затронутые строки (удаление + вставка). Чтобы обновить только часть столбцов, используют INSERT ... ON DUPLICATE KEY UPDATE title = VALUES(title).На
posts ссылается comments.post_id ... ON DELETE CASCADE. Что случится с комментариями к посту 1 после REPLACE INTO posts (id, title) VALUES (1, 'new'), если пост 1 существует (InnoDB)?- Ничего: REPLACE обновляет строку на месте
- REPLACE завершится ошибкой нарушения внешнего ключа
- Перепривяжутся к новой строке с тем же id автоматически
- Удалятся каскадом
Семантика
REPLACE — DELETE + INSERT. Когда на таблицу ссылаются внешние ключи, InnoDB выполняет именно удаление, поэтому ON DELETE CASCADE уничтожит дочерние строки, а триггеры на DELETE тоже сработают. Это частая причина «пропавших» данных; для обновления используйте INSERT ... ON DUPLICATE KEY UPDATE или UPDATE.Столбец
size ENUM('small', 'medium', 'large'), в таблице значения large, small, medium. В каком порядке их вернёт ORDER BY size в MySQL?- large, medium, small
- large, small, medium
- small, medium, large
- medium, large, small
Значения ENUM хранятся как номера (1, 2, 3 в порядке объявления), и сортировка идёт по номеру, а не по алфавиту. Иногда это удобно, но при добавлении нового значения в середину списка придётся менять определение столбца (ALTER TABLE). Для алфавитного порядка пишут
ORDER BY CAST(size AS CHAR).Столбец
size ENUM('small', 'medium', 'large'). Какие строки вернёт запрос в MySQL?SELECT * FROM items WHERE size = 2;- Ни одной: в ENUM нет значения 2
- Строки с size = 'medium'
- Ошибка приведения типа
- Строки с size = 'large'
В числовом контексте ENUM превращается в номер значения (с 1), поэтому
size = 2 — это medium. Особенно коварно, если в ENUM хранятся числа-строки, например ENUM('1', '5', '10'): = 2 найдёт '5'. Поэтому для числовых справочников ENUM не используют, а со строковыми ENUM сравнивают только строками.В
orders есть PK id, обычный индекс ix_user (user_id) и индекс ix_created (created_at). Какие значения столбца type покажет EXPLAIN в MySQL для трёх условий (индексы используются): id = 5, user_id = 5, created_at >= '2024-01-01'?- const, ref, range
- ref, ref, range
- const, const, index
- eq_ref, range, ALL
const — не больше одной строки по PK или уникальному индексу, значение читается один раз; ref — поиск по равенству в неуникальном индексе (строк может быть несколько); range — диапазон по индексу (>, BETWEEN, IN). eq_ref встречается в JOIN при соединении по PK/UNIQUE, а index и ALL — полные проходы по индексу или таблице.Что означает
Using filesort в столбце Extra вывода EXPLAIN в MySQL?- Сортировка обязательно идёт через временный файл на диске
- Таблица читается из файла целиком, без использования индексов
- Сортировка идёт отдельным шагом, а не по индексу
- Результат запроса кэшируется в файл для повторных вызовов
filesort — название алгоритма сортировки MySQL, а не признак работы с диском: при небольшом объёме сортировка идёт в памяти (sort_buffer_size). Сигнал в том, что ORDER BY не покрыт индексом. Убрать его можно индексом, совпадающим с условием и порядком, например (status, created_at) для WHERE status = ? ORDER BY created_at.Можно ли в MySQL сохранить 123456 в столбец
INT(3)?CREATE TABLE t (n INT(3));
INSERT INTO t VALUES (123456);- Да: (3) — лишь ширина отображения
- Нет: будет ошибка Out of range value
- Сохранится обрезанное значение 123
- Сохранится 999 — максимум для трёх цифр
В
INT(n)/TINYINT(n) число — устаревшая «ширина отображения» (используется с ZEROFILL), она не ограничивает диапазон: INT всегда 4 байта. С MySQL 8.0.17 этот атрибут объявлен устаревшим. Не путайте с VARCHAR(n) и DECIMAL(p, s), где число в скобках действительно ограничивает значения.Что вернёт запрос в MySQL?
SELECT '1abc' = 1 AS a, 'abc' = 0 AS b;- a = 0, b = 0
- a = 1, b = 0
- Ошибка приведения типов
- a = 1, b = 1
При сравнении строки с числом MySQL приводит строку к числу, беря цифры из её начала:
'1abc' → 1, а 'abc' → 0 (с предупреждением «Truncated incorrect DOUBLE value»). Поэтому WHERE code = 0 по строковому столбцу может вернуть почти все строки. PostgreSQL в такой ситуации выдал бы ошибку приведения.Что вернёт запрос в MySQL (режим
sql_mode без NO_UNSIGNED_SUBTRACTION)?SELECT CAST(1 AS UNSIGNED) - 2;- -1
- Ошибку out of range
- 18446744073709551615
- 0 (отрицательное значение обрезается)
Если один из операндов беззнаковый, MySQL вычисляет результат как
BIGINT UNSIGNED, а −1 в этот диапазон не помещается — ошибка 1690. Типичный случай: qty - reserved для столбцов INT UNSIGNED, когда резерв больше остатка. Решения — приводить к SIGNED, перестраивать выражение или включать режим NO_UNSIGNED_SUBTRACTION.Чем движок MyISAM принципиально отличается от InnoDB в MySQL?
- Поддерживает транзакции, но не поддерживает индексы
- Нет транзакций и FK, блокировка всей таблицы
- Хранит данные только в памяти и теряет их при перезапуске
- Ничем, кроме формата файлов, в которых лежат данные на диске
MyISAM — устаревший движок:
ROLLBACK на нём ничего не откатывает, FK игнорируются, любая запись блокирует всю таблицу, после аварии таблицу приходится чинить REPAIR TABLE. InnoDB — движок по умолчанию с MySQL 5.5: транзакции, строковые блокировки, MVCC, внешние ключи. Хранение только в памяти — это движок MEMORY.В таблице есть столбец
order. Как правильно обратиться к нему в MySQL?- SELECT order FROM items;
- SELECT 'order' FROM items;
- SELECT [order] FROM items;
- SELECT
orderFROM items;
ORDER — зарезервированное слово, поэтому без кавычек получится синтаксическая ошибка. Идентификаторы в MySQL экранируют обратными кавычками (а с режимом ANSI_QUOTES — двойными, как в стандарте и PostgreSQL). Одинарные кавычки дадут строковый литерал 'order' в каждой строке, а квадратные скобки — синтаксис SQL Server.Что верно про типы
DATETIME и TIMESTAMP в MySQL?- TIMESTAMP хранится в UTC и ограничен 2038 годом
- DATETIME хранит время в UTC и учитывает time_zone сессии
- Оба типа имеют одинаковый диапазон 1000–9999 годов
- TIMESTAMP хранит только дату, без времени суток
TIMESTAMP — это секунды от эпохи UTC: при смене
time_zone сессии одно и то же значение покажется по-разному, а диапазон ограничен 1970–2038. DATETIME хранит «как написано», без учёта часовых поясов, в диапазоне 1000–9999. Для дат далеко в будущем (сроки договоров, даты рождения в прошлом) TIMESTAMP не подходит.Что произойдёт при выполнении запроса в MySQL 8?
SELECT * FROM users
WHERE id IN (
SELECT user_id FROM orders
ORDER BY created_at DESC LIMIT 10
);- Вернутся пользователи — авторы 10 последних заказов
- LIMIT внутри подзапроса будет молча проигнорирован
- Ошибка 1235: LIMIT в подзапросе с IN не поддерживается
- Вернутся первые 10 пользователей таблицы users
MySQL (включая 8.x) не поддерживает
LIMIT в подзапросах с IN, ALL, ANY, SOME — ошибка 1235. Обходной путь — обернуть подзапрос в производную таблицу: JOIN (SELECT DISTINCT user_id FROM (SELECT user_id FROM orders ORDER BY created_at DESC LIMIT 10) x) t ON t.user_id = users.id. В PostgreSQL исходный запрос работает.MVCC и обслуживание15
Транзакция A обновила строку, но ещё не закоммитила. Транзакция B выполняет обычный
SELECT этой строки (PostgreSQL или InnoDB, READ COMMITTED). Что произойдёт?- B будет ждать, пока A завершит транзакцию
- B увидит незакоммиченное изменение транзакции A
- B получит ошибку lock wait timeout
- B сразу прочитает последнюю закоммиченную версию
Это главная идея MVCC: каждая транзакция видит согласованный снимок, а старые версии строк хранятся (в PostgreSQL — в самой таблице, в InnoDB — в undo log), поэтому читатели не блокируют писателей и наоборот. Ждать придётся только при блокирующем чтении (
SELECT ... FOR UPDATE) или при попытке тоже изменить строку.Что физически происходит в PostgreSQL при
UPDATE одной строки?- Строка перезаписывается на том же месте в странице
- Старая версия строки сразу физически удаляется с диска
- Создаётся новая версия строки, старая остаётся до VACUUM
- Изменение пишется только в журнал, а таблица меняется при CHECKPOINT
В PostgreSQL
UPDATE — это по сути вставка новой версии строки (tuple) и пометка старой как удалённой (xmax). Старая версия нужна транзакциям, которые ещё могут её видеть; когда таких не останется, она становится «мёртвой» и её место освобождает VACUUM. Поэтому частые обновления раздувают таблицы и индексы (bloat).Из таблицы PostgreSQL на 50 ГБ выполнили
DELETE FROM logs; (без WHERE) и закоммитили. Что с размером файлов таблицы?- Сразу уменьшится почти до нуля
- Почти не изменится до VACUUM; TRUNCATE освободил бы сразу
- Уменьшится после ближайшего CHECKPOINT
- Увеличится вдвое из-за копии удалённых данных в журнале
DELETE лишь помечает версии строк удалёнными, место в файле освобождается для повторного использования только после VACUUM, а вернуть его ОС может VACUUM FULL. TRUNCATE же создаёт новый пустой файл таблицы и освобождает место мгновенно (он тоже транзакционен в PostgreSQL, но берёт эксклюзивную блокировку).Чем
VACUUM отличается от VACUUM FULL в PostgreSQL?- FULL переписывает таблицу под эксклюзивной блокировкой, обычный — нет
- VACUUM FULL проходит по всем таблицам базы, а VACUUM — по одной
- VACUUM чистит мёртвые строки только в индексах, FULL — ещё и в таблице
- Ничем: FULL — устаревший синоним, оставленный для совместимости
Обычный
VACUUM (его же запускает autovacuum) работает параллельно с чтением и записью, но файл таблицы обычно не сжимает — освобождённое место переиспользуется новыми строками. VACUUM FULL создаёт новую компактную копию таблицы и на всё время работы берёт ACCESS EXCLUSIVE, блокируя даже SELECT. На проде для борьбы с bloat чаще используют pg_repack.Почему в PostgreSQL нельзя надолго отключать autovacuum, даже если bloat не беспокоит?
- Без autovacuum перестанут проверяться внешние ключи
- Autovacuum отвечает за создание резервных копий базы
- Иначе грозит wraparound 32-битных xid
- Без autovacuum индексы перестанут обновляться при INSERT
Видимость строк определяется сравнением 32-битных xid. Чтобы счётчик мог «провернуться», старые строки нужно заморозить (freeze) — это делает VACUUM. Если не делать, по мере приближения к wraparound база начнёт предупреждать и в итоге откажется выполнять новые транзакции, пока не будет выполнен VACUUM. Кроме того, autovacuum обновляет статистику для планировщика (autoanalyze).
Autovacuum работает, но таблица в PostgreSQL продолжает пухнуть, а
VACUUM VERBOSE пишет, что мёртвые строки «not yet removable». Какая причина наиболее вероятна?- Висит давно открытая транзакция (idle in transaction)
- На таблице слишком много индексов, и VACUUM не успевает
- Таблица слишком маленькая, autovacuum её пропускает
- В таблице нет первичного ключа, и VACUUM не может найти строки
VACUUM может удалить версию строки, только если её не может увидеть ни одна активная транзакция. Транзакция, открытая часами (забытый
BEGIN в приложении или консоли, долгий отчёт, слот репликации), сдерживает горизонт удаления для всей базы. Найти её помогает pg_stat_activity (state, xact_start), а защитой служит idle_in_transaction_session_timeout.Несколько воркеров параллельно берут задачи из таблицы-очереди этим запросом (PostgreSQL 9.5+ / MySQL 8). Что происходит?
BEGIN;
SELECT id FROM jobs
WHERE status = 'pending'
ORDER BY id
LIMIT 1
FOR UPDATE SKIP LOCKED;
-- обработка, UPDATE jobs SET status = 'done' ...
COMMIT;- Все воркеры получают одну и ту же задачу
- Второй воркер ждёт, пока первый закоммитит транзакцию
- Второй воркер получает ошибку could not obtain lock on row
- Каждый берёт свою задачу, занятые строки пропускаются
FOR UPDATE блокирует выбранную строку до конца транзакции, а SKIP LOCKED велит не ждать чужие блокировки, а пропускать такие строки. Без SKIP LOCKED все воркеры выстроились бы в очередь за первой же строкой. Если воркер упадёт, транзакция откатится и задача снова станет доступна. Цена — результат может быть «неполным», для очередей это как раз нужно.Что сделает этот запрос, если строка уже заблокирована другой транзакцией (PostgreSQL / MySQL 8)?
SELECT * FROM accounts
WHERE id = 1
FOR UPDATE NOWAIT;- Подождёт lock_timeout и вернёт пустой результат
- Сразу завершится ошибкой, не дожидаясь снятия блокировки
- Пропустит заблокированную строку и вернёт остальные
- Прочитает строку без блокировки
NOWAIT превращает ожидание блокировки в немедленную ошибку (в PostgreSQL — could not obtain lock on row), чтобы приложение могло сразу ответить «запись редактируется» или повторить позже. Пропускать заблокированные строки умеет другой модификатор — SKIP LOCKED.Две копии крон-задачи вызывают в PostgreSQL
SELECT pg_try_advisory_lock(42);. Что получит вторая, пока первая держит блокировку?- Будет ждать освобождения блокировки
- false — сразу, без ожидания
- Ошибку deadlock detected
- true — advisory-блокировки не конфликтуют между сессиями
Advisory-блокировки — блокировки на произвольный ключ, смысл которого определяет приложение; они не связаны со строками таблиц.
pg_advisory_lock ждёт освобождения, а pg_try_advisory_lock сразу возвращает true/false — удобно для «запускать только один экземпляр задачи». Аналог в MySQL — GET_LOCK('name', 0).Свободна ли advisory-блокировка 42 после COMMIT (PostgreSQL)?
BEGIN;
SELECT pg_advisory_lock(42);
-- ... работа ...
COMMIT;- Да: все блокировки снимаются при COMMIT
- Да, но только если транзакция что-то изменила
- Нет: она снимется автоматически при следующем VACUUM
- Нет: она держится до unlock или конца сессии
pg_advisory_lock берёт блокировку уровня сессии, и границы транзакций на неё не влияют. Если забыть pg_advisory_unlock, с пулом соединений блокировка «утечёт» вместе с соединением. Для автоматического снятия в конце транзакции есть pg_advisory_xact_lock / pg_try_advisory_xact_lock.MySQL InnoDB, REPEATABLE READ. Транзакция A выполнила
START TRANSACTION; и пока ничего не читала. B вставила строку и закоммитила. Затем A делает SELECT COUNT(*) FROM t. Увидит ли A строку B?- Да: снимок создаётся при первом чтении
- Нет: снимок создаётся в момент START TRANSACTION
- Нет: в REPEATABLE READ новые строки не видны никогда
- Да, но только если B работала на уровне READ COMMITTED
В InnoDB снимок для согласованного чтения в REPEATABLE READ фиксируется первым неблокирующим SELECT транзакции. Поэтому изменения, закоммиченные между
START TRANSACTION и первым чтением, будут видны. Чтобы снимок создавался сразу, используют START TRANSACTION WITH CONSISTENT SNAPSHOT (так делает, например, mysqldump --single-transaction).MySQL InnoDB, REPEATABLE READ. Другая транзакция уже закоммитила новые строки с
c1 = 'xyz'. Что произойдёт в текущей транзакции?-- снимок текущей транзакции создан раньше
SELECT COUNT(*) FROM t1 WHERE c1 = 'xyz'; -- 0
DELETE FROM t1 WHERE c1 = 'xyz';- DELETE ничего не удалит, так как работает по тому же снимку
- DELETE завершится ошибкой сериализации транзакции
- DELETE удалит строки, которых SELECT не видел
- DELETE будет ждать завершения другой (уже закоммиченной) транзакции
В InnoDB обычный SELECT читает снимок, а
UPDATE/DELETE/SELECT ... FOR UPDATE выполняют «текущее чтение» последних закоммиченных версий. Отсюда этот документированный эффект: SELECT вернул 0, а DELETE удалил несколько строк (после UPDATE такие строки станут видны и обычному SELECT). PostgreSQL в REPEATABLE READ поступил бы иначе: новые строки, которых нет в снимке, он не увидел бы и не удалил.В PostgreSQL в пустую таблицу загрузили 10 млн строк, и сразу после этого запросы выбирают странные планы. Что стоит сделать в первую очередь?
- Выполнить VACUUM FULL
- Пересоздать все индексы через REINDEX
- Перезапустить сервер, чтобы сбросить кэш планов
- Выполнить ANALYZE
Планировщик выбирает план по статистике (число строк, распределение значений), а она всё ещё описывает пустую таблицу. Autovacuum со временем выполнит autoanalyze сам, но после массовой загрузки разумно запустить
ANALYZE вручную. VACUUM FULL и REINDEX здесь ничего не исправят — мёртвых строк после чистой загрузки нет.Что такое HOT-обновление (Heap-Only Tuple) в PostgreSQL и когда оно возможно?
- Обновление, которое пишется только в WAL, минуя страницы таблицы
- Обновление строки прямо на месте, без создания новой версии
- Версия строки на той же странице без новых записей в индексах
- Обновление, выполняемое только в оперативной памяти без записи на диск
Обычно каждая новая версия строки требует новых записей во всех индексах. HOT позволяет этого избежать: если изменены только неиндексированные столбцы и новая версия помещается на ту же страницу, индексы не трогаются. Поэтому лишний индекс на часто обновляемом столбце вредит, а таблицам с частыми UPDATE иногда снижают
fillfactor, оставляя место на страницах.MySQL InnoDB, REPEATABLE READ. В
t (id — PK) есть только строки с id 10 и 20. Транзакция A выполнила SELECT * FROM t WHERE id BETWEEN 10 AND 20 FOR UPDATE;. Что будет с INSERT INTO t (id) VALUES (15) из транзакции B?- Вставка выполнится сразу: строки 15 не было, блокировать нечего
- B будет ждать: A держит gap-блокировку
- B получит ошибку duplicate key
- Вставка выполнится, но A её не увидит до своего COMMIT
В REPEATABLE READ InnoDB при блокирующем чтении диапазона блокирует не только найденные строки, но и промежутки между ними (gap locks / next-key locks), чтобы не возникали фантомы. Поэтому вставка в «дырку» ждёт завершения A. На уровне READ COMMITTED gap-блокировки для таких поисков не ставятся, и вставка прошла бы — и это частая причина неожиданных ожиданий и дедлоков.
Кодировки и сортировка15
Что такое collation (правило сравнения) у строкового столбца?
- Правила сравнения и сортировки строк
- Кодировка, в которой хранятся байты строки
- Максимальная длина строки в символах для столбца
- Способ сжатия текстовых данных на диске
Кодировка (charset) определяет, какими байтами записан символ, а collation — как такие строки сравнивать и сортировать в рамках этой кодировки. От collation зависят
=, ORDER BY, GROUP BY, DISTINCT и уникальные индексы. Например, в MySQL у utf8mb4 есть utf8mb4_bin, utf8mb4_general_ci, utf8mb4_0900_ai_ci и др.Сколько байт занимают в UTF-8 символы
A, Я, € и 😀?- 1, 1, 2 и 2
- 2, 2, 2 и 4
- 1, 2, 3 и 4
- 1, 2, 2 и 3
UTF-8 — кодировка переменной длины: ASCII занимает 1 байт, кириллица и большинство европейских алфавитов — 2, остальные символы базовой плоскости (в т.ч.
€, иероглифы) — 3, а символы за её пределами, включая эмодзи, — 4. Именно 4-байтовые символы не помещаются в устаревший utf8 (utf8mb3) в MySQL.Что произойдёт при вставке в MySQL 8 (строгий режим включён)?
CREATE TABLE msg (
body VARCHAR(100) CHARACTER SET utf8
);
INSERT INTO msg VALUES ('Привет 😀');- Ошибка Incorrect string value
- Строка сохранится полностью
- Эмодзи молча заменится на «?», без ошибки и предупреждения
- Кириллица превратится в «кракозябры», а эмодзи сохранится
Исторически
utf8 в MySQL — это utf8mb3, в котором символ занимает не более 3 байт, поэтому 4-байтовые эмодзи в него не помещаются: в строгом режиме — ошибка 1366, в нестрогом — обрезанная строка с предупреждением. Для новых таблиц всегда используйте utf8mb4 (в MySQL 8 он и так по умолчанию).В MySQL 5.6 (формат строк COMPACT,
innodb_large_prefix выключен) не создаётся таблица. В чём причина?CREATE TABLE users (
email VARCHAR(255) CHARACTER SET utf8mb4,
UNIQUE KEY (email)
) ENGINE=InnoDB;- UNIQUE нельзя создать на столбце VARCHAR
- Кодировка utf8mb4 не поддерживается движком InnoDB
- VARCHAR(255) превышает максимальную длину строки таблицы
- 255 × 4 = 1020 байт больше лимита 767 байт
InnoDB резервирует под ключ максимум байт на символ: 4 для utf8mb4. При старом лимите 767 байт поэтому появился известный
VARCHAR(191) (191 × 4 = 764). С MySQL 5.7.7 формат DYNAMIC и large prefix включены по умолчанию, и лимит равен 3072 байтам, так что в MySQL 8 этот пример работает.Что вернёт запрос в MySQL 5.7 с collation
utf8mb4_general_ci?SELECT 'a' = 'a ' AS eq,
'a' LIKE 'a ' AS lk;- eq = 0, lk = 0
- eq = 1, lk = 0
- eq = 1, lk = 1
- eq = 0, lk = 1
Collation с атрибутом PAD SPACE (все до появления
_0900_ в MySQL 8) при сравнении через = игнорирует хвостовые пробелы, поэтому 'a' = 'a ' истинно — и уникальный индекс сочтёт такие значения дубликатами. LIKE сравнивает посимвольно и пробелы учитывает. В MySQL 8 у utf8mb4_0900_ai_ci атрибут NO PAD, и eq вернёт 0.Что произойдёт при втором INSERT в MySQL 8 (collation по умолчанию
utf8mb4_0900_ai_ci)?CREATE TABLE users (
email VARCHAR(100) UNIQUE
);
INSERT INTO users VALUES ('Ann@x.io');
INSERT INTO users VALUES ('ann@x.io');- Строка вставится: регистр отличается
- Ошибка Duplicate entry
- Строка вставится, а старая будет заменена новой
- Строка вставится, но с предупреждением о дубликате
Уникальность проверяется по правилам collation столбца, а
_ci означает case-insensitive: Ann@x.io и ann@x.io равны. Для email это обычно и нужно. Если же требуется различать регистр (например, токены или коды), используют _bin- или _cs-collation для столбца.Что вернёт запрос в MySQL при collation соединения
utf8mb4_general_ci?SELECT 'Ёж' = 'еж' AS r;- 0 — это разные буквы
- 0 — регистр отличается
- NULL
- 1
В
utf8mb4_general_ci (и в utf8mb4_0900_ai_ci) «Ё» сравнивается как «Е»: _ci игнорирует регистр, а «ё» сводится к «е» как буква с диакритикой. Поэтому поиск «еж» найдёт «Ёж», а уникальный индекс сочтёт их дубликатами. Чтобы различать, нужна _bin- или accent-sensitive collation, например utf8mb4_0900_as_ci.Столбец
code имеет collation utf8mb4_general_ci. Как в MySQL найти строки, где code равно abc с учётом регистра?- WHERE code = 'abc' COLLATE utf8mb4_bin
- WHERE code LIKE 'abc'
- WHERE UPPER(code) = UPPER('abc')
- WHERE code = 'abc' COLLATE utf8mb4_general_ci
COLLATE utf8mb4_bin переключает сравнение на побайтовое (по кодам символов), и ABC перестаёт быть равным abc. LIKE использует ту же регистронезависимую collation, а UPPER с обеих сторон наоборот гарантирует нечувствительность к регистру. Учтите: смена collation в условии мешает использовать обычный индекс на столбце.В каком порядке вернёт строки запрос в PostgreSQL?
SELECT x
FROM (VALUES ('b'), ('B'), ('a'), ('A')) AS v(x)
ORDER BY x COLLATE "C";- a, A, b, B
- A, a, B, b
- A, B, a, b
- a, b, A, B
Collation
"C" сравнивает строки побайтово, по кодам символов: все заглавные латинские буквы (65–90) идут раньше строчных (97–122). Лингвистические collation (en_US.UTF-8, ICU) упорядочили бы буквы «по-человечески», рядом a и A. Тот же порядок даёт utf8mb4_bin в MySQL и BINARY в SQLite.Что вернёт запрос в SQLite?
SELECT 'abc' = 'ABC' COLLATE NOCASE AS en,
'привет' = 'ПРИВЕТ' COLLATE NOCASE AS ru;- en = 1, ru = 1
- en = 0, ru = 0
- en = 0, ru = 1
- en = 1, ru = 0
Встроенная collation
NOCASE в SQLite приводит к одному регистру только 26 латинских букв ASCII, кириллица сравнивается как есть. То же ограничение у LIKE и lower()/upper() без расширения ICU. Для регистронезависимого поиска по кириллице в SQLite хранят нормализованную копию строки или подключают ICU.Что означают части названия collation
utf8mb4_0900_as_cs в MySQL 8?- Кодировка utf8mb4, 900 символов максимум, ASCII-only, case-sensitive
- Версия MySQL 9.0, alphabetical sort, case-sensitive
- Кодировка utf8mb4, правила Unicode 9.0, учитывает акценты и регистр
- Кодировка utf8mb4, сравнение побайтовое
0900 — алгоритм сортировки Unicode (UCA) версии 9.0.0; ai/as — accent-insensitive / accent-sensitive, ci/cs — case-insensitive / case-sensitive. Значит, e, é и E здесь три разные строки. Побайтовое сравнение — это utf8mb4_bin, а по умолчанию в MySQL 8 используется utf8mb4_0900_ai_ci.Сайт показывает вместо «Привет» текст «ÐŸÑ€Ð¸Ð²ÐµÑ‚». Какая причина наиболее вероятна?
- В столбце не хватает длины VARCHAR для кириллицы
- Кодировка соединения не совпадает с кодировкой данных
- Collation столбца регистрозависимая
- Сервер БД не поддерживает кириллицу
Каждая кириллическая буква в UTF-8 — 2 байта, а при чтении в однобайтовой кодировке они превращаются в пары символов вроде
Ð + Ÿ. Обычно причина — не задан charset соединения (SET NAMES utf8mb4 / charset=utf8mb4 в DSN), из-за чего данные двойным образом перекодируются при записи или чтении. Collation и длина столбца на это не влияют.После обновления до MySQL 8 запрос стал падать с ошибкой. Старые таблицы созданы с
utf8mb4_unicode_ci, новые — с collation по умолчанию. В чём причина?SELECT * FROM old_users u
JOIN new_orders o ON o.user_code = u.code;
-- ERROR 1267: Illegal mix of collations- Сравниваются столбцы с разными collation
- В MySQL 8 нельзя соединять таблицы, созданные в разных версиях
- У соединяемых столбцов должна быть одинаковая длина VARCHAR
- В MySQL 8 кодировка utf8mb4 заменена на utf8mb3
Для сравнения двух строк MySQL должен выбрать одну collation; если у обеих сторон одинаковый «вес» (столбцы, IMPLICIT) и collation разные, возникает ошибка 1267. Правильное решение — привести таблицы к одной collation (
ALTER TABLE ... CONVERT TO CHARACTER SET utf8mb4 COLLATE ...). COLLATE прямо в условии тоже сработает, но может отключить использование индекса.Что вернёт запрос в MySQL (соединение в utf8mb4)?
SELECT 'ß' = 's' COLLATE utf8mb4_general_ci AS g1,
'ß' = 'ss' COLLATE utf8mb4_general_ci AS g2,
'ß' = 'ss' COLLATE utf8mb4_unicode_ci AS u;- g1 = 0, g2 = 1, u = 1
- g1 = 0, g2 = 0, u = 0
- g1 = 1, g2 = 0, u = 1
- g1 = 1, g2 = 1, u = 0
_general_ci — упрощённая collation: каждый символ сравнивается с одним символом, поэтому ß приравнивается к s. _unicode_ci реализует алгоритм Unicode (UCA), где ß раскрывается в ss. Отсюда разница в поиске и уникальности; в MySQL 8 по умолчанию используется ещё более точная utf8mb4_0900_ai_ci (UCA 9.0).Зачем в PostgreSQL используют тип
citext (расширение citext)?- Для текста, сравниваемого без учёта регистра
- Для текста с автоматическим полнотекстовым индексом
- Для текста, который хранится на диске в сжатом виде
- Для текста, ограниченного только ASCII-символами
В PostgreSQL обычное сравнение
text регистрозависимо. citext при сравнении фактически применяет lower() к обеим сторонам, поэтому UNIQUE на citext-столбце не пустит Ann@x.io и ann@x.io, а запросы не нужно переписывать через lower(). Альтернативы — уникальный индекс по lower(email) или недетерминированная ICU-collation.Практические задачи23
Нужна вторая по величине зарплата среди *различных* значений. Какой запрос вернёт
200?-- emp(id, name, salary):
-- (1,'Ann',100), (2,'Bob',200),
-- (3,'Cid',300), (4,'Dan',300)SELECT MAX(salary) FROM emp WHERE salary <> MAX(salary)SELECT salary FROM emp ORDER BY salary DESC LIMIT 1 OFFSET 1SELECT MAX(salary) FROM emp WHERE salary < (SELECT MAX(salary) FROM emp)SELECT salary FROM (SELECT salary, ROW_NUMBER() OVER (ORDER BY salary DESC) AS rn FROM emp) t WHERE rn = 2
Подзапрос находит максимум (300), а внешний
MAX берёт наибольшее из меньших значений — 200; дубликаты на это не влияют. LIMIT 1 OFFSET 1 и ROW_NUMBER() = 2 берут вторую *строку*, а это вторая зарплата 300 (у Dan). Агрегат в WHERE недопустим вовсе. Рабочие альтернативы — DENSE_RANK() = 2 или SELECT DISTINCT salary ... OFFSET 1.В
emp всего один сотрудник. Запрос «вторая по величине зарплата» должен вернуть ровно одну строку со значением NULL, а не пустой результат. Какой вариант это делает?-- emp(id, name, salary):
-- (1,'Ann',100)SELECT COALESCE(salary, NULL) AS second FROM emp ORDER BY salary DESC LIMIT 1 OFFSET 1SELECT (SELECT DISTINCT salary FROM emp ORDER BY salary DESC LIMIT 1 OFFSET 1) AS secondSELECT salary AS second FROM emp WHERE salary < (SELECT MAX(salary) FROM emp)SELECT DISTINCT salary AS second FROM emp ORDER BY salary DESC LIMIT 1 OFFSET 1
Скалярный подзапрос, не нашедший строк, возвращает NULL, а внешний
SELECT без FROM всегда даёт ровно одну строку. Остальные варианты — обычные выборки: если подходящих строк нет, результат пустой, и COALESCE тут не поможет — ему просто не к чему применяться.Какой запрос вернёт email, которые встречаются в
users больше одного раза (a@x и b@x)?-- users(id, email):
-- (1,'a@x'), (2,'b@x'), (3,'a@x'),
-- (4,'c@x'), (5,'b@x'), (6,'a@x')SELECT email FROM users GROUP BY email HAVING COUNT(*) > 1SELECT email FROM users GROUP BY email HAVING COUNT(*) >= 1SELECT DISTINCT email FROM usersSELECT email FROM users GROUP BY email, id HAVING COUNT(*) > 1
Группируем по email и оставляем группы, где больше одной строки.
DISTINCT и HAVING COUNT(*) >= 1 вернут все три адреса, а группировка по (email, id) делает каждую группу уникальной (id не повторяется), и COUNT(*) > 1 не выполнится ни разу.Нужно удалить дубликаты email, оставив у каждого адреса строку с минимальным
id (должны остаться id 1, 2, 4). Какой запрос это делает (PostgreSQL / SQLite)?-- users(id, email):
-- (1,'a@x'), (2,'b@x'), (3,'a@x'),
-- (4,'c@x'), (5,'b@x'), (6,'a@x')DELETE FROM users WHERE id IN (SELECT MIN(id) FROM users GROUP BY email)DELETE FROM users WHERE id NOT IN (SELECT MAX(id) FROM users GROUP BY email)DELETE FROM users WHERE id > (SELECT MIN(id) FROM users)DELETE FROM users WHERE id NOT IN (SELECT MIN(id) FROM users GROUP BY email)
Подзапрос даёт «оригиналы» — минимальный id каждой группы (1, 2, 4), удаляем всё остальное. Вариант с
IN удалит как раз оригиналы, с MAX оставит самые новые строки (4, 5, 6), а сравнение с общим минимумом оставит одну строку на всю таблицу. В MySQL такой DELETE упадёт с ошибкой 1093 — там пишут DELETE u FROM users u JOIN users d ON d.email = u.email AND d.id < u.id.Задача gaps-and-islands: какой запрос вернёт серии подряд идущих дней —
(1, 3), (5, 6), (9, 9)?-- logins(day) — номера дней, когда пользователь заходил:
-- 1, 2, 3, 5, 6, 9
SELECT MIN(day), MAX(day)
FROM (SELECT day, /* g = ? */ FROM logins) t
GROUP BY g
ORDER BY 1;day / 3 AS gday - LAG(day) OVER (ORDER BY day) AS gday - ROW_NUMBER() OVER (ORDER BY day) AS gday + ROW_NUMBER() OVER (ORDER BY day) AS g
Внутри серии день и номер строки растут синхронно, поэтому их разность постоянна (1-1 = 2-2 = 3-3 = 0, 5-4 = 6-5 = 1, 9-6 = 3) и меняется только на разрыве — это и есть ключ группы. Разность с
LAG равна 1 для любых соседних дней и склеивает дни из разных серий, сумма с номером строки уникальна для каждой строки, а деление на 3 режет по фиксированным «корзинам». Для дат в PostgreSQL то же: d - ROW_NUMBER() OVER (ORDER BY d)::int.Какой запрос вернёт начало каждого пропуска в последовательности
id — значения 4 и 7?-- t(id): 1, 2, 3, 5, 6, 9SELECT id FROM (SELECT id, LEAD(id) OVER (ORDER BY id) AS nx FROM t) x WHERE nx - id > 1 ORDER BY 1SELECT id + 1 FROM t WHERE id + 1 NOT IN (SELECT id FROM t) AND id < (SELECT MAX(id) FROM t) ORDER BY 1SELECT id + 1 FROM t WHERE id + 1 NOT IN (SELECT id FROM t) ORDER BY 1SELECT id - 1 FROM t WHERE id - 1 NOT IN (SELECT id FROM t) ORDER BY 1
Пропуск начинается там, где за
id не следует id + 1; условие id < MAX(id) отсекает «пропуск» после последнего значения. Без него появится лишнее 10, вариант с id - 1 найдёт концы пропусков со смещением (0, 4, 8), а вариант с LEAD вернёт последний id *перед* пропуском (3, 6) — чтобы получить начало, нужно id + 1.Какой запрос вернёт нарастающий итог продаж:
10, 30, 60?-- sales(d, amt): (1, 10), (2, 20), (3, 30)SELECT d, SUM(amt) OVER (ORDER BY d) FROM sales ORDER BY dSELECT d, SUM(amt) OVER () FROM sales ORDER BY dSELECT d, SUM(amt) FROM sales GROUP BY d ORDER BY dSELECT d, (SELECT SUM(amt) FROM sales s2 WHERE s2.d < s.d) FROM sales s ORDER BY d
Окно с
ORDER BY по умолчанию берёт рамку «от начала до текущей строки», что и даёт нарастающий итог. Пустое окно OVER () даёт общую сумму 60 в каждой строке, GROUP BY d — просто суммы по дням, а коррелированный подзапрос со строгим < не включает текущую строку (NULL, 10, 30) — нужно <=.Нужен нарастающий итог отдельно по каждому счёту: A → 10, 15; B → 7, 10. Какое выражение подставить в запрос?
-- tx(acc, d, amt):
-- ('A',1,10), ('A',2,5), ('B',1,7), ('B',2,3)
SELECT acc, d, /* ? */ AS running
FROM tx
ORDER BY acc, d;SUM(amt) OVER (PARTITION BY d ORDER BY acc)SUM(amt) OVER (ORDER BY acc, d)SUM(amt) OVER (PARTITION BY acc)SUM(amt) OVER (PARTITION BY acc ORDER BY d)
PARTITION BY acc начинает отсчёт заново для каждого счёта, а ORDER BY d делает сумму нарастающей. Без PARTITION BY итог тянется через границу счетов (10, 15, 22, 25), без ORDER BY получается общая сумма счёта в каждой строке (15, 15, 10, 10), а разбиение по дню суммирует разные счета за один день.Нужно изменение выручки к предыдущему месяцу:
NULL, 50, -30. Какое выражение подходит?-- rev(month, total):
-- ('2024-01',100), ('2024-02',150), ('2024-03',120)
SELECT month, /* ? */ AS diff
FROM rev
ORDER BY month;LEAD(total) OVER (ORDER BY month) - totaltotal - LAG(total, 1, 0) OVER (ORDER BY month)total - LAG(total) OVER (ORDER BY month)total - FIRST_VALUE(total) OVER (ORDER BY month)
LAG берёт значение из предыдущей строки окна; у первого месяца предыдущего нет, поэтому разность NULL. LEAD смотрит вперёд и сдвигает результат на строку (50, -30, NULL), значение по умолчанию 0 в LAG(total, 1, 0) превращает первый месяц в «рост на 100», а FIRST_VALUE сравнивает каждый месяц с январём.Нужен прирост к прошлому месяцу в процентах с одним знаком:
NULL, 33.3, 25.0. Столбец total — INTEGER (SQLite / PostgreSQL). Какое выражение даёт такой результат?-- rev(month, total):
-- ('2024-01',30), ('2024-02',40), ('2024-03',50)
-- w = OVER (ORDER BY month)100 * (total - LAG(total) OVER (ORDER BY month)) / LAG(total) OVER (ORDER BY month)ROUND(100.0 * (total - LAG(total) OVER (ORDER BY month)) / LAG(total) OVER (ORDER BY month), 1)(total - LAG(total) OVER (ORDER BY month)) / LAG(total) OVER (ORDER BY month) * 100ROUND(100.0 * (LAG(total) OVER (ORDER BY month) - total) / total, 1)
Множитель
100.0 переводит вычисление в дробную арифметику до деления, а ROUND(..., 1) оставляет один знак. С целым 100 деление целочисленное (33 и 25), а если сначала делить и потом умножать — 10 / 30 уже даёт 0. Последний вариант считает изменение «наоборот» и относительно текущего месяца (-25.0, -20.0).Нужна сводная таблица (pivot): одна строка на год, столбцы
q1 и q2 с суммами — 2023 | 15 | 20 и 2024 | 7 | 8. Какой запрос это делает?-- s(year, q, amt):
-- (2023,1,10), (2023,2,20), (2023,1,5),
-- (2024,1,7), (2024,2,8)SELECT year, SUM(CASE WHEN q = 1 THEN amt ELSE 0 END) AS q1, SUM(CASE WHEN q = 2 THEN amt ELSE 0 END) AS q2 FROM s GROUP BY yearSELECT year, SUM(CASE WHEN q = 1 THEN amt ELSE 0 END) AS q1, SUM(CASE WHEN q = 2 THEN amt ELSE 0 END) AS q2 FROM s GROUP BY year, qSELECT year, CASE WHEN q = 1 THEN SUM(amt) END AS q1, CASE WHEN q = 2 THEN SUM(amt) END AS q2 FROM s GROUP BY yearSELECT year, COUNT(CASE WHEN q = 1 THEN amt END) AS q1, COUNT(CASE WHEN q = 2 THEN amt END) AS q2 FROM s GROUP BY year
Условная агрегация:
CASE внутри SUM отбирает слагаемые для каждого столбца, а группировка только по году даёт одну строку на год. С GROUP BY year, q строк станет по одной на квартал (с нулями в «чужом» столбце); CASE *снаружи* агрегата обращается к несгруппированному q — в PostgreSQL это ошибка, а SQLite берёт q из произвольной строки; COUNT считает строки, а не суммы.Какой запрос вернёт клиентов, у которых нет ни одного оплаченного заказа (
status = 'paid'), — Бориса и Веру?-- customers(id, name): (1,'Анна'), (2,'Борис'), (3,'Вера')
-- orders(id, customer_id, status):
-- (10,1,'paid'), (11,1,'new'), (12,2,'new')SELECT name FROM customers WHERE id NOT IN (SELECT customer_id FROM orders)SELECT c.name FROM customers c LEFT JOIN orders o ON o.customer_id = c.id WHERE o.status = 'paid' AND o.id IS NULLSELECT DISTINCT c.name FROM customers c JOIN orders o ON o.customer_id = c.id WHERE o.status <> 'paid'SELECT c.name FROM customers c LEFT JOIN orders o ON o.customer_id = c.id AND o.status = 'paid' WHERE o.id IS NULL
Фильтр по статусу должен стоять в
ON: тогда присоединяются только оплаченные заказы, и o.id IS NULL остаётся у тех, у кого их нет. Тот же фильтр в WHERE противоречит o.id IS NULL и даёт пустой результат; «есть неоплаченный заказ» — не то же, что «нет оплаченного» (Анна попадёт, Вера — нет); NOT IN без фильтра ищет клиентов вообще без заказов.Нужен последний по дате (
created) заказ каждого клиента — это заказы 2 и 3. Какой запрос вернёт их id?-- orders(id, customer_id, created):
-- (1,1,'2024-01-05'), (2,1,'2024-02-01'),
-- (3,2,'2024-01-10'), (4,2,'2024-01-03'),
-- (5,1,'2024-01-20')SELECT id FROM (SELECT id, ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY created) AS rn FROM orders) t WHERE rn = 1SELECT MAX(id) FROM orders GROUP BY customer_idSELECT id FROM orders o WHERE created = (SELECT MAX(created) FROM orders o2 WHERE o2.customer_id = o.customer_id)SELECT id FROM orders ORDER BY created DESC LIMIT 2
Коррелированный подзапрос находит максимальную дату *своего* клиента, и остаётся строка с этой датой (при равных датах вернутся обе).
MAX(id) — не последний по дате заказ (5 и 4), LIMIT 2 берёт два самых свежих заказа всей таблицы (оба у клиента 1), а ROW_NUMBER с сортировкой по возрастанию выбирает *первый* заказ — нужно ORDER BY created DESC.Нужны все сотрудники, чья зарплата входит в две наибольшие *различные* зарплаты своего отдела: a, b, c из IT и e, f из HR. Что подставить вместо
/* ? */?-- emp(name, dept, salary):
-- ('a','IT',500), ('b','IT',500), ('c','IT',400),
-- ('d','IT',300), ('e','HR',300), ('f','HR',200)
SELECT name FROM (
SELECT name, /* ? */ AS r FROM emp
) t
WHERE r <= 2;DENSE_RANK() OVER (ORDER BY salary DESC)DENSE_RANK() OVER (PARTITION BY dept ORDER BY salary DESC)RANK() OVER (PARTITION BY dept ORDER BY salary DESC)ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC)
DENSE_RANK нумерует различные значения без пропусков: в IT 500 → 1, 500 → 1, 400 → 2, поэтому c попадает в выборку. RANK после двух равных первых мест выдаёт 3, а ROW_NUMBER вообще не учитывает равенство — оба теряют c. Без PARTITION BY ранжирование идёт по всей таблице, и отдел HR пропадает целиком.Какой запрос вернёт медиану
x (для 1, 3, 5, 100 это 4) при любом, чётном или нечётном, числе строк — без PERCENTILE_CONT?-- t(x): 1, 3, 5, 100SELECT AVG(x) FROM (SELECT x, ROW_NUMBER() OVER (ORDER BY x) AS rn, COUNT(*) OVER () AS c FROM t) s WHERE rn IN ((c + 1) / 2, (c + 2) / 2)SELECT (MIN(x) + MAX(x)) / 2.0 FROM tSELECT AVG(x) FROM tSELECT x FROM t ORDER BY x LIMIT 1 OFFSET (SELECT COUNT(*) FROM t) / 2
При целочисленном делении
(c + 1) / 2 и (c + 2) / 2 дают два средних номера для чётного c (2 и 3) и один и тот же номер для нечётного, а AVG по ним и есть медиана. AVG(x) — среднее (27.25), а не медиана; OFFSET c / 2 при чётном числе строк берёт только верхний из двух средних элементов (5); полусумма min и max — середина диапазона. В PostgreSQL есть готовое PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY x).Брони хранятся как полуоткрытые интервалы
[start_d, end_d) — день выезда свободен. Какое условие найдёт брони, пересекающиеся с новой бронью [5, 8) (это 2, 3 и 5)?-- b(id, start_d, end_d):
-- (1,1,5), (2,4,6), (3,7,10), (4,8,9), (5,2,12)
SELECT id FROM b WHERE /* ? */;start_d >= 5 AND end_d <= 8start_d <= 8 AND end_d >= 5start_d BETWEEN 5 AND 8 OR end_d BETWEEN 5 AND 8start_d < 8 AND end_d > 5
Два интервала пересекаются тогда и только тогда, когда каждый начинается раньше, чем заканчивается другой:
start < new_end AND end > new_start. Вариант с BETWEEN пропускает бронь 5, целиком накрывающую новую, и цепляет брони 1 и 4, которые лишь касаются границ; нестрогие <=/>= тоже считают касание пересечением; условие «внутри» ищет только вложенные интервалы.Keyset-пагинация: лента отсортирована по
created DESC, id DESC, последний показанный пост — created = '2024-03-01', id = 7. Какое условие вернёт следующую страницу — посты 2 и 9?-- posts(id, created), порядок в ленте: 3, 8, 7, 2, 9, 1
-- (3,'2024-03-02'), (8,'2024-03-01'), (7,'2024-03-01'),
-- (2,'2024-03-01'), (9,'2024-02-28'), (1,'2024-02-27')
SELECT id FROM posts
WHERE /* ? */
ORDER BY created DESC, id DESC
LIMIT 2;created < '2024-03-01'created <= '2024-03-01' AND id < 7created < '2024-03-01' OR (created = '2024-03-01' AND id < 7)created <= '2024-03-01' AND id <> 7
Курсор состоит из двух полей, и сравнивать его надо лексикографически: либо дата строго раньше, либо та же дата и меньший
id. Сравнение только по дате теряет пост 2 с той же датой, id < 7 на всех датах выбрасывает пост 9 (его id больше), а id <> 7 повторно покажет пост 8. В PostgreSQL, MySQL и SQLite то же условие пишут короче: (created, id) < ('2024-03-01', 7).Какой запрос вернёт сотрудников, которые получают больше своего руководителя (Пётр и Анна)?
-- emp(id, name, salary, manager_id):
-- (1,'Ольга',500,NULL), (2,'Пётр',600,1),
-- (3,'Иван',400,1), (4,'Анна',450,3)SELECT e.name FROM emp e LEFT JOIN emp m ON m.id = e.manager_id WHERE e.salary > m.salary OR m.id IS NULLSELECT e.name FROM emp e JOIN emp m ON m.id = e.manager_id WHERE e.salary > m.salarySELECT e.name FROM emp e JOIN emp m ON m.manager_id = e.id WHERE e.salary > m.salarySELECT name FROM emp WHERE salary > (SELECT AVG(salary) FROM emp)
Self join: для сотрудника
e его руководитель — строка m, у которой m.id = e.manager_id. Условие m.manager_id = e.id переворачивает роли (сравниваем руководителя с подчинёнными — получится Ольга), среднее по компании к задаче не относится, а OR m.id IS NULL добавляет сотрудников без руководителя.Нужны все отделы с наибольшим числом сотрудников, с учётом ничьих (здесь IT и HR — по 2 человека). Какой запрос это делает?
-- emp(name, dept):
-- ('a','IT'), ('b','IT'), ('c','HR'), ('d','HR'), ('e','Ops')SELECT dept FROM emp GROUP BY dept HAVING COUNT(*) = (SELECT MAX(c) FROM (SELECT COUNT(*) AS c FROM emp GROUP BY dept) t)SELECT dept, MAX(COUNT(*)) FROM emp GROUP BY deptSELECT MAX(c) FROM (SELECT dept, COUNT(*) AS c FROM emp GROUP BY dept) tSELECT dept FROM emp GROUP BY dept ORDER BY COUNT(*) DESC LIMIT 1
Сначала находим максимальный размер отдела во вложенном запросе, затем оставляем все отделы с таким размером — ничьи сохраняются.
LIMIT 1 вернёт только один из равных отделов (какой — не определено), вложенные агрегаты MAX(COUNT(*)) в одном уровне запроса запрещены, а последний запрос возвращает само число 2, а не отделы. Альтернатива — RANK() OVER (ORDER BY COUNT(*) DESC) = 1 во внешнем запросе.Какой запрос вернёт без повторов пользователей, у которых есть и заказ, и отзыв (1 и 3)?
-- orders(user_id): 1, 1, 2, 3
-- reviews(user_id): 1, 3, 4SELECT user_id FROM orders UNION SELECT user_id FROM reviewsSELECT user_id FROM orders EXCEPT SELECT user_id FROM reviewsSELECT o.user_id FROM orders o JOIN reviews r ON r.user_id = o.user_idSELECT user_id FROM orders INTERSECT SELECT user_id FROM reviews
INTERSECT возвращает строки, которые есть в обоих наборах, и убирает дубликаты. UNION объединяет (1, 2, 3, 4), EXCEPT вычитает (2), а JOIN даёт пользователя 1 дважды — у него два заказа. В MySQL INTERSECT появился в 8.0.31; раньше писали EXISTS или JOIN с DISTINCT.Нужна сумма продаж за каждый день с 1-го по 4-й, включая дни без продаж (день 3 → 0). Какой основной запрос дописать после CTE?
-- sales(day, amt): (1,10), (2,5), (2,7), (4,3)
WITH RECURSIVE d(n) AS (
SELECT 1 UNION ALL SELECT n + 1 FROM d WHERE n < 4
)
-- основной запрос: ?SELECT d.n, COALESCE(SUM(s.amt), 0) FROM d LEFT JOIN sales s ON s.day = d.n WHERE s.amt > 0 GROUP BY d.nSELECT d.n, COUNT(s.amt) FROM d LEFT JOIN sales s ON s.day = d.n GROUP BY d.nSELECT d.n, COALESCE(SUM(s.amt), 0) FROM d LEFT JOIN sales s ON s.day = d.n GROUP BY d.nSELECT s.day, COALESCE(SUM(s.amt), 0) FROM sales s LEFT JOIN d ON d.n = s.day GROUP BY s.day
Ведущей должна быть таблица-календарь:
LEFT JOIN сохраняет все дни, а COALESCE превращает NULL-сумму пустого дня в 0. Если ведущая — sales, дня 3 просто нет; условие WHERE s.amt > 0 отбрасывает строки с NULL и превращает LEFT JOIN во внутренний; COUNT считает число продаж, а не сумму.Какой запрос вернёт сотрудников с зарплатой выше средней по *их* отделу (c и e)?
-- emp(name, dept, salary):
-- ('a','IT',100), ('b','IT',200), ('c','IT',300),
-- ('d','HR',50), ('e','HR',150)SELECT name FROM emp WHERE salary > (SELECT AVG(salary) FROM emp)SELECT name FROM emp e WHERE salary > (SELECT AVG(salary) FROM emp WHERE dept = e.dept)SELECT name FROM (SELECT name, salary, AVG(salary) OVER (PARTITION BY dept ORDER BY salary) AS a FROM emp) t WHERE salary > aSELECT name FROM emp WHERE salary > (SELECT MAX(a) FROM (SELECT AVG(salary) AS a FROM emp GROUP BY dept) t)
Коррелированный подзапрос считает среднее для отдела текущей строки (IT — 200, HR — 100). Общее среднее (160) отберёт b и c; окно с
ORDER BY считает *нарастающее* среднее, а не среднее по отделу (лишним окажется b); сравнение с максимальным из средних — это «выше среднего в любом отделе». Корректная оконная версия — AVG(salary) OVER (PARTITION BY dept) без ORDER BY.Как в PostgreSQL получить для каждого отдела список имён сотрудников через запятую в одной строке?
SELECT dept, STRING_AGG(name, ', ' ORDER BY name) FROM emp GROUP BY deptSELECT dept, CONCAT(name, ', ') FROM emp GROUP BY deptSELECT dept, ARRAY_TO_STRING(name, ', ') FROM emp GROUP BY deptSELECT dept, GROUP_CONCAT(name SEPARATOR ', ') FROM emp GROUP BY dept
В PostgreSQL строковая агрегатная функция —
STRING_AGG(выражение, разделитель), порядок задаётся прямо внутри через ORDER BY. GROUP_CONCAT ... SEPARATOR — синтаксис MySQL, а CONCAT и ARRAY_TO_STRING не агрегатные: они работают с одной строкой, и name вне агрегата при GROUP BY dept вызовет ошибку. Через массив было бы ARRAY_TO_STRING(ARRAY_AGG(name), ', ').Аналитические запросы12
Какое выражение вернёт долю каждого товара в общей сумме продаж в процентах:
50.0, 30.0, 20.0?-- sales(item, amt): ('A',50), ('B',30), ('C',20)
SELECT item, /* ? */ AS pct
FROM sales
ORDER BY item;amt / SUM(amt) OVER () * 100amt * 100.0 / SUM(amt) OVER (ORDER BY amt)amt * 100.0 / SUM(amt)amt * 100.0 / SUM(amt) OVER ()
SUM(amt) OVER () — сумма по всей выборке в каждой строке, без схлопывания строк, а 100.0 делает деление дробным. С целыми числами 50 / 100 даёт 0 ещё до умножения; окно с ORDER BY даёт нарастающую сумму (доли 50, 60, 100); обычный SUM без окна превращает запрос в агрегатный (в PostgreSQL — ошибка из-за item).Retention первого месяца: доля пользователей когорты (месяц регистрации), активных в *следующем* месяце. Ожидается: когорта 1 → 0.5, когорта 2 → 0.33. Что подставить вместо
/* ? */?-- users(id, signup_month): 1..4 → 1; 5, 6, 7 → 2
-- activity(user_id, month): (1,1),(1,2),(2,1),(3,1),(3,2),
-- (4,1),(5,2),(5,3),(6,2),(7,2)
SELECT u.signup_month AS cohort,
ROUND(COUNT(DISTINCT a.user_id) * 1.0
/ COUNT(DISTINCT u.id), 2) AS m1
FROM users u
/* ? */
GROUP BY u.signup_month;JOIN activity a ON a.user_id = u.id AND a.month = u.signup_month + 1LEFT JOIN activity a ON a.month = u.signup_month + 1LEFT JOIN activity a ON a.user_id = u.id AND a.month = u.signup_month + 1LEFT JOIN activity a ON a.user_id = u.id WHERE a.month = u.signup_month + 1
Знаменатель — все пользователи когорты, поэтому их нельзя терять: условие на месяц должно стоять в
ON у LEFT JOIN, тогда неактивные остаются со значением NULL и не попадают в COUNT(DISTINCT a.user_id). Условие в WHERE и INNER JOIN выбрасывают неактивных, и доля превращается в 1.0; без a.user_id = u.id считаются все активные пользователи месяца, а не участники когорты (1.25).Воронка: сколько *уникальных* пользователей дошло до каждого шага. Ожидается
3 | 2 | 1 (view | cart | buy). Какое выражение для шага 'view' верно (для 'cart' и 'buy' — по аналогии)?-- events(user_id, step):
-- (1,'view'), (1,'view'), (1,'cart'),
-- (2,'view'), (2,'cart'), (2,'buy'),
-- (3,'view')
SELECT /* view */, /* cart */, /* buy */ FROM events;COUNT(CASE WHEN step = 'view' THEN user_id END)COUNT(DISTINCT CASE WHEN step = 'view' THEN user_id END)COUNT(DISTINCT CASE WHEN step = 'view' THEN user_id ELSE 0 END)MAX(CASE WHEN step = 'view' THEN user_id END)
CASE без ELSE возвращает NULL для чужих шагов, COUNT(DISTINCT ...) их пропускает и считает каждого пользователя один раз. Без DISTINCT двойной просмотр пользователя 1 даст 4 вместо 3; ELSE 0 добавляет «пользователя 0» в каждый подсчёт (4, 3, 2); MAX вернёт наибольший id (3, 2, 2), а не количество.Что вернёт запрос в PostgreSQL для значений
x = 1, 2, 3, 4?SELECT
PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY x) AS c,
PERCENTILE_DISC(0.5) WITHIN GROUP (ORDER BY x) AS d
FROM t;- c = 2.5, d = 2
- c = 2.5, d = 3
- c = 2.5, d = 2.5
- c = 2, d = 3
PERCENTILE_CONT интерполирует между соседними значениями: медиана 1, 2, 3, 4 — это 2.5. PERCENTILE_DISC всегда возвращает одно из реальных значений — первое, чья накопленная доля достигает 0.5, то есть 2. Поэтому для дискретных величин (например, «типичное количество товаров») берут DISC, а для непрерывных метрик — CONT.Что вернут
pr и cd для строки со значением x = 20?-- t(x): 10, 20, 20, 40
SELECT x,
PERCENT_RANK() OVER (ORDER BY x) AS pr,
CUME_DIST() OVER (ORDER BY x) AS cd
FROM t;- pr = 0.5, cd = 0.75
- pr ≈ 0.333, cd = 0.5
- pr = 0.25, cd = 0.5
- pr ≈ 0.333, cd = 0.75
PERCENT_RANK = (rank − 1) / (n − 1): у 20 ранг 2, значит (2 − 1) / 3 ≈ 0.333. CUME_DIST — доля строк со значением не больше текущего, включая всех «соседей» с тем же значением: 3 из 4 = 0.75. Типичная ошибка — считать, что CUME_DIST учитывает только строки до текущей (0.5).Хотели сумму за последние 3 дня (текущий и два предыдущих), но в данных есть пропуски дней. Что вернут
r и g для d = 6?-- daily(d, x): (1,10), (2,20), (5,30), (6,40)
SELECT d,
SUM(x) OVER (ORDER BY d
ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS r,
SUM(x) OVER (ORDER BY d
RANGE BETWEEN 2 PRECEDING AND CURRENT ROW) AS g
FROM daily;- r = 90, g = 90
- r = 70, g = 90
- r = 90, g = 70
- r = 70, g = 70
ROWS отсчитывает физические строки: две предыдущие строки — это дни 2 и 5, поэтому r = 20 + 30 + 40 = 90, хотя день 2 давно вне трёхдневного окна. RANGE с числовым смещением отсчитывает по значению d: в окно попадают d от 4 до 6, то есть 30 + 40 = 70. Для скользящих окон по датам с пропусками нужен RANGE (PostgreSQL 11+, MySQL 8, SQLite) или заранее дополненный календарём ряд.Каждой строке заказа нужно присвоить когорту пользователя — месяц его *первой* покупки (пользователь 1 → 1, 2 → 2, 3 → 4). Какое выражение подходит?
-- orders(user_id, month): (1,3), (1,1), (2,2), (2,4), (3,4)
SELECT user_id, month, /* ? */ AS cohort
FROM orders;LAG(month) OVER (PARTITION BY user_id ORDER BY month)MIN(month) OVER (PARTITION BY user_id)FIRST_VALUE(month) OVER (ORDER BY month)MIN(month) OVER (PARTITION BY month)
Агрегат в окне
PARTITION BY user_id считает минимум по всем заказам пользователя и проставляет его в каждую строку, не схлопывая их. FIRST_VALUE без разбиения даёт первый месяц всей таблицы (1 у всех), разбиение по month возвращает сам месяц, а LAG — предыдущий заказ пользователя, а не первый.Какие уровни группировки даст
GROUP BY ROLLUP (region, city) (PostgreSQL; в MySQL — GROUP BY region, city WITH ROLLUP)?- (region, city), (region) и общий итог ()
- (region, city), (city) и общий итог ()
- (region, city), (region), (city) и общий итог ()
- Только (region, city) и общий итог ()
ROLLUP строит иерархию подытогов, отбрасывая столбцы справа налево: город внутри региона, итог по региону и общий итог. Все комбинации, включая итог по городу без региона, даёт CUBE. В строках подытогов «свёрнутые» столбцы равны NULL; отличить их от настоящих NULL помогает функция GROUPING().Для сравнения «год к году» используют
revenue - LAG(revenue, 12) OVER (ORDER BY month) по помесячной таблице. Когда результат окажется неверным?- Для первых 12 месяцев — LAG вернёт там 0 и разность будет равна выручке
- Если
monthхранится как DATE — LAG работает только с числами - Если в таблице больше 12 строк — LAG поддерживает смещение не больше числа строк окна
- Если каких-то месяцев в таблице нет — LAG отсчитывает 12 строк, а не 12 месяцев
LAG смещается на заданное число *строк*. Если месяц без продаж в таблице отсутствует, всё после него сравнивается не с тем месяцем. Надёжнее либо дополнить ряд календарём (LEFT JOIN к списку месяцев), либо соединить таблицу саму с собой по month = prev.month + 1 год. Для первых 12 строк LAG возвращает NULL, а не 0, и с датами работает без ограничений.Что вернёт запрос?
-- orders(customer_id, amount):
-- (1,100), (1,100), (1,100), (1,100), (2,500)
SELECT AVG(avg_amt)
FROM (
SELECT customer_id, AVG(amount) AS avg_amt
FROM orders
GROUP BY customer_id
) t;- 600
- 180
- 300
- 250
Внутренний запрос даёт средний чек клиента (100 и 500), внешний усредняет их: (100 + 500) / 2 = 300. Это не средний чек по всем заказам — он равен 900 / 5 = 180. «Среднее средних» придаёт каждому клиенту одинаковый вес независимо от числа заказов; какую метрику считать, зависит от вопроса бизнеса, но путать их нельзя.
События пользователя происходили на минутах 0, 10, 50, 60, 100. Новая сессия начинается после паузы больше 30 минут. Какие
session_id получат события?SELECT ts,
SUM(new_s) OVER (ORDER BY ts) AS session_id
FROM (
SELECT ts,
CASE WHEN ts - LAG(ts) OVER (ORDER BY ts) > 30
THEN 1 ELSE 0 END AS new_s
FROM ev
) t;- 0, 0, 1, 2, 3
- 0, 0, 1, 1, 2
- 1, 1, 2, 2, 3
- NULL, 0, 1, 1, 2
Флаги начала сессии: у первой строки
LAG = NULL, сравнение даёт UNKNOWN и CASE уходит в ELSE 0; дальше паузы 10, 40, 10, 40 дают флаги 0, 1, 0, 1. Нарастающая сумма флагов (0, 0, 1, 1, 2) — номер сессии. Вложенный запрос обязателен: оконную функцию нельзя положить внутрь другой оконной функции.Что вернёт запрос для гистограммы сумм заказов (столбец
amount — INTEGER)?-- orders(amount): 50, 120, 180, 199, 250
SELECT (amount / 100) * 100 AS bucket, COUNT(*)
FROM orders
GROUP BY bucket
ORDER BY bucket;- 0 → 1, 100 → 3, 200 → 1
- 50 → 1, 100 → 1, 200 → 3
- 0 → 1, 100 → 2, 200 → 2
- 100 → 4, 200 → 1
Целочисленное деление отбрасывает дробную часть (а не округляет): 180 / 100 = 1 и 199 / 100 = 1, поэтому корзина 100 содержит 120, 180 и 199. Вариант «100 → 2, 200 → 2» получился бы при округлении до ближайшей сотни. В MySQL
/ всегда даёт дробный результат — там пишут amount DIV 100 или FLOOR(amount / 100).Найдите ошибку в запросе16
Ожидали
paid = 30 и tickets = 3. Что вернёт запрос на самом деле?-- payments(customer_id, amount): (1,10), (1,20)
-- tickets(id, customer_id): (1,1), (2,1), (3,1)
SELECT c.id,
SUM(p.amount) AS paid,
COUNT(t.id) AS tickets
FROM customers c
JOIN payments p ON p.customer_id = c.id
JOIN tickets t ON t.customer_id = c.id
WHERE c.id = 1
GROUP BY c.id;- paid = 30, tickets = 3
- paid = 30, tickets = 6
- paid = 90, tickets = 3
- paid = 90, tickets = 6
Две независимые дочерние таблицы, присоединённые к одному родителю, дают декартово произведение: 2 платежа × 3 тикета = 6 строк. Каждый платёж повторяется трижды (сумма 90), каждый тикет — дважды (6). Исправление — агрегировать каждую дочернюю таблицу в своём подзапросе и только потом соединять;
COUNT(DISTINCT t.id) спасёт счётчик, но не сумму.Какой из запросов выдаст ошибку в PostgreSQL 16?
-- emp(name, dept, salary)SELECT dept, COUNT(*) FROM emp GROUP BY dept HAVING dept <> 'HR'SELECT dept, COUNT(*) FROM emp WHERE salary > 1000 GROUP BY deptSELECT dept, COUNT(*) FROM emp GROUP BY dept HAVING salary > 1000SELECT dept FROM emp GROUP BY dept HAVING MAX(salary) > 1000
HAVING выполняется после группировки и видит только столбцы из GROUP BY и агрегаты; salary к ним не относится — ошибка «column must appear in the GROUP BY clause or be used in an aggregate function». Нужно либо WHERE salary > 1000 (фильтр строк до группировки), либо агрегат вроде MAX(salary). HAVING dept <> 'HR' корректен, но такой фильтр правильнее писать в WHERE: строки отбрасываются раньше.Нужны все заказы, кроме отменённых — ожидали 3 строки. Сколько строк вернёт запрос?
-- orders(id, status):
-- (1,'paid'), (2,'cancelled'), (3,NULL), (4,'new')
SELECT id FROM orders
WHERE status <> 'cancelled';- 4
- 2
- 1
- 3
Для заказа 3 сравнение
NULL <> 'cancelled' даёт UNKNOWN, а WHERE пропускает только TRUE — поэтому вернутся лишь 1 и 4. Исправления: WHERE status <> 'cancelled' OR status IS NULL или status IS DISTINCT FROM 'cancelled' (PostgreSQL; в SQLite — status IS NOT 'cancelled', в MySQL — NOT (status <=> 'cancelled')).Баланс пересчитывают по транзакциям. Что окажется в
balance у счёта 2, у которого нет транзакций?-- accounts(id, balance): (1,0), (2,0)
-- tx(acc, amount): (1,50), (1,25)
UPDATE accounts
SET balance = (SELECT SUM(amount)
FROM tx
WHERE tx.acc = accounts.id);- NULL — подзапрос вернул NULL, и он записался в balance
- Прежнее значение — строки без транзакций не обновляются
- Ошибка — подзапрос для счёта 2 не вернул ни одной строки
- 0 — SUM пустого набора равна нулю
UPDATE без WHERE обновляет все строки, а SUM по пустому набору возвращает NULL (не 0) — его и запишут в balance. Если столбец NOT NULL, получится ошибка нарушения ограничения. Правильно: COALESCE((SELECT SUM(amount) ...), 0).Запрос
SELECT dept, name, MAX(salary) FROM emp GROUP BY dept падает в PostgreSQL. Какое исправление вернёт по каждому отделу имя сотрудника с максимальной зарплатой (Bob и Kim)?-- emp(name, dept, salary):
-- ('Ann','IT',300), ('Bob','IT',500),
-- ('Zoe','IT',200), ('Kim','HR',400)SELECT dept, MAX(name), MAX(salary) FROM emp GROUP BY deptSELECT dept, name, MAX(salary) FROM emp GROUP BY dept, nameSELECT dept, MIN(name), MAX(salary) FROM emp GROUP BY deptSELECT dept, name, salary FROM (SELECT e.*, ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC) AS rn FROM emp e) t WHERE rn = 1
Агрегаты считаются независимо друг от друга:
MAX(name) — это максимальное имя по алфавиту (Zoe), а не имя владельца максимальной зарплаты. Добавление name в GROUP BY делает группой каждого сотрудника. Нужно выбрать *строку* с максимумом — через ROW_NUMBER() (или DISTINCT ON в PostgreSQL, или коррелированный подзапрос).Столбец
created — DATETIME (MySQL) / timestamp (PostgreSQL). Отчёты за январь и февраль построены так. Что они покажут?-- orders(id, created):
-- (1,'2024-01-15 10:00:00'), (2,'2024-02-01 00:00:00'),
-- (3,'2024-02-10 12:00:00')
-- январь:
SELECT COUNT(*) FROM orders
WHERE created BETWEEN '2024-01-01' AND '2024-02-01';
-- февраль:
SELECT COUNT(*) FROM orders
WHERE created BETWEEN '2024-02-01' AND '2024-03-01';- Январь — 2, февраль — 1
- Январь — 1, февраль — 2
- Январь — 2, февраль — 2: заказ 2 посчитан дважды
- Январь — 1, февраль — 1: заказ 2 потерян
BETWEEN включает обе границы, а '2024-02-01' приводится к полуночи 2024-02-01 00:00:00 — заказ ровно в полночь попадает в оба отчёта. Надёжный шаблон для периодов — полуоткрытый интервал: created >= '2024-01-01' AND created < '2024-02-01'.Хотели новые или оплаченные заказы пользователя 5 (это 1 и 2). Какие
id вернёт запрос?-- orders(id, user_id, status):
-- (1,5,'new'), (2,5,'paid'), (3,7,'paid'),
-- (4,7,'new'), (5,5,'cancelled')
SELECT id FROM orders
WHERE user_id = 5 AND status = 'new' OR status = 'paid';- 1, 3
- 1, 2, 3
- 2, 3
- 1, 2
AND связывает сильнее OR, поэтому условие читается как (user_id = 5 AND status = 'new') OR status = 'paid' — и в выборку попадает оплаченный заказ 3 чужого пользователя. Нужны скобки: user_id = 5 AND (status = 'new' OR status = 'paid'), или короче status IN ('new', 'paid').Нужен список *всех* клиентов с числом их заказов за 2024 год (у кого нет — 0). Сколько строк вернёт запрос?
-- customers(id, name): (1,'Анна'), (2,'Борис'), (3,'Вера')
-- orders(id, customer_id, created):
-- (10,1,'2024-03-01'), (11,1,'2023-05-01'), (12,2,'2023-07-01')
SELECT c.name, COUNT(o.id) AS cnt
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.created >= '2024-01-01'
GROUP BY c.name;- 1
- 3
- 2
- 0
Условие на правую таблицу в
WHERE отбрасывает строки, где o.created равен NULL, — то есть всех клиентов без подходящих заказов, и LEFT JOIN фактически становится внутренним. Остаётся только Анна. Фильтр нужно перенести в ON: LEFT JOIN orders o ON o.customer_id = c.id AND o.created >= '2024-01-01' — тогда Борис и Вера вернутся с 0.Представление создано как
CREATE VIEW v AS SELECT * FROM orders ORDER BY created DESC. Приложение выполняет SELECT * FROM v JOIN customers c ON ... и рассчитывает, что строки придут отсортированными по дате. В чём ошибка?- ORDER BY в представлении применяется только при первом обращении к нему
- Ошибки нет: ORDER BY из представления сохраняется при любых JOIN
- Сортировка сохранится, только если заменить JOIN на LEFT JOIN
- Порядок гарантирует только ORDER BY самого внешнего запроса — сортировку внутри представления СУБД вправе потерять
Таблица (и результат подзапроса или представления) — неупорядоченное множество; оптимизатор может соединить данные хешем и выдать строки в любом порядке. Если порядок важен,
ORDER BY нужен в итоговом запросе. Сортировка внутри представления только тратит ресурсы — MySQL, например, часто её просто игнорирует.Возвратов в таблице нет. Что вернёт запрос и почему отчёт «сломался»?
-- payments(type, amount): ('card',100), ('cash',50)
SELECT SUM(CASE WHEN type = 'refund'
THEN amount END) AS refunds
FROM payments;- Пустой результат — ни одна строка не подошла под CASE
- 150 — CASE без ELSE возвращает amount
- NULL — CASE без ELSE даёт NULL, а SUM одних NULL тоже NULL
- 0 — строки без совпадения считаются нулями
CASE без ELSE возвращает NULL для неподходящих строк, а SUM игнорирует NULL; если все значения NULL — результат NULL, а не 0. Строка в результате всё равно одна: агрегат без GROUP BY всегда возвращает одну строку. Исправление — ELSE 0 или COALESCE(SUM(...), 0).В таблице
banned нет столбца id — есть только uid (в нём 2). Что произойдёт при выполнении запроса (PostgreSQL / MySQL / SQLite)?-- users(id, name): (1,'Ann'), (2,'Bob'), (3,'Cid')
-- banned(uid): (2)
SELECT name FROM users
WHERE id IN (SELECT id FROM banned);- Ошибка: столбец id не существует в banned
- Вернутся все пользователи: id в подзапросе — это users.id
- Вернётся только Bob
- Пустой результат: в banned нет совпадающего столбца
Имя без квалификатора ищется сначала в подзапросе, а не найдя — во внешнем запросе.
id становится ссылкой на users.id, подзапрос — коррелированным, и условие «id IN (id)» истинно для каждого пользователя, пока banned не пуста. С DELETE такая опечатка удаляет всю таблицу. Защита — всегда квалифицировать столбцы: SELECT b.id FROM banned b сразу даст ошибку.Многие товары стоят одинаково. Пользователи жалуются, что при листании одни товары повторяются на соседних страницах, а другие не показываются вовсе. В чём причина?
SELECT * FROM products
ORDER BY price
LIMIT 20 OFFSET 20;- Порядок строк с равной price не определён и может меняться между запросами — нужен уникальный тай-брейкер: ORDER BY price, id
- OFFSET считает строки с 0, а LIMIT — с 1, отсюда сдвиг на одну строку
- LIMIT применяется до ORDER BY, поэтому каждая страница сортируется отдельно
- Без DISTINCT одинаковые цены дублируют строки в результате
Сортировка по неуникальному столбцу не задаёт порядок внутри группы равных значений: от запроса к запросу (другой план, параллельное сканирование) строки с одной ценой могут переставляться, и граница страницы «режет» их по-разному. Добавление уникального столбца в конец
ORDER BY делает порядок детерминированным — это же обязательно и для keyset-пагинации.Что произойдёт при выполнении запроса в PostgreSQL 16?
SELECT * FROM users
WHERE name = "Anna";- Вернутся пользователи с именем anna в любом регистре
- Пустой результат без ошибки
- Вернутся пользователи с именем Anna
- Ошибка column "Anna" does not exist: двойные кавычки обозначают идентификатор
По стандарту SQL строковые литералы пишутся в одинарных кавычках, а двойные кавычки — для идентификаторов (имён таблиц и столбцов). PostgreSQL ищет столбец
Anna и выдаёт ошибку. MySQL без режима ANSI_QUOTES и SQLite прощают такую запись и трактуют её как строку — поэтому привычка переносится и «ломается» в PostgreSQL.В столбце
v VARCHAR(10) хранятся номера сборок. Ожидали 10. Что вернёт запрос?-- builds(v): '9', '10', '2'
SELECT MAX(v) FROM builds;- '10'
- '2'
- '9'
- Ошибка: MAX не работает со строками
Для строк
MAX использует строковое сравнение посимвольно: '9' > '2' > '10', потому что '9' больше '1' уже в первом символе. Числа нужно хранить в числовом типе или приводить при сравнении: MAX(CAST(v AS INTEGER)). Та же ловушка возникает с ORDER BY v — получится 10, 2, 9.Хотели получить только клиентов из Минска вместе с их заказами. Сколько строк вернёт запрос?
-- customers(id, name, city):
-- (1,'Анна','Минск'), (2,'Борис','Гомель'), (3,'Вера','Минск')
-- orders(id, customer_id): (10,1), (11,2)
SELECT c.name, o.id
FROM customers c
LEFT JOIN orders o
ON o.customer_id = c.id AND c.city = 'Минск';- 4
- 3
- 2
- 1
Условие в
ON у LEFT JOIN влияет только на то, какие строки *справа* присоединятся; левая таблица сохраняется целиком. Поэтому вернутся все три клиента: Анна с заказом 10, Борис и Вера с NULL (Борису заказ не присоединился из-за города). Фильтр по левой таблице должен стоять в WHERE c.city = 'Минск'.Код подставил в запрос пустой список идентификаторов. Что произойдёт в PostgreSQL 16 и MySQL 8?
SELECT * FROM users WHERE id IN ();- Синтаксическая ошибка: список
INдолжен содержать хотя бы одно значение - Вернутся все строки — пустой список игнорируется
- Вернётся пустой результат — ни один
idне входит в пустой список - Вернутся строки, где
id IS NULL
Грамматика SQL требует в
IN (...) хотя бы одно выражение, поэтому и PostgreSQL, и MySQL отвечают syntax error ещё до выполнения запроса. Код, который собирает IN из массива, должен отдельно обработать пустой список: не выполнять запрос вовсе или подставить заведомо ложное условие (WHERE 1 = 0). В PostgreSQL удобно передавать массив одним параметром: WHERE id = ANY($1) с пустым массивом корректно вернёт 0 строк.Проектирование схемы17
Связь «студенты — курсы» (многие-ко-многим) реализована таблицей
enrollments(student_id, course_id). Куда правильно поместить оценку студента за курс?- В
students— отдельным столбцомgrade - В
courses— отдельным столбцомgrade - В
students— JSON-массивом оценок по всем курсам - В
enrollments— это свойство самой связи студента и курса
Оценка зависит от пары «студент + курс», поэтому её место — в связующей таблице, рядом с ключом
(student_id, course_id); туда же идут дата записи, статус и т. п. В students или courses столбец grade может хранить только одно значение на всю строку, а JSON-массив ломает 1НФ и лишает ограничений и FK.История цен хранится с интервалом действия
[valid_from, valid_to), у текущей цены valid_to = NULL. Какое условие вернёт цену товара 1, действовавшую 2024-03-01 — в день смены цены (это 120)?-- price_history(product_id, price, valid_from, valid_to):
-- (1, 100, '2024-01-01', '2024-03-01'),
-- (1, 120, '2024-03-01', '2024-04-10'),
-- (1, 110, '2024-04-10', NULL)
SELECT price FROM price_history
WHERE product_id = 1 AND /* ? */;valid_to IS NULLvalid_from <= '2024-03-01' AND (valid_to >= '2024-03-01' OR valid_to IS NULL)valid_from <= '2024-03-01' AND (valid_to > '2024-03-01' OR valid_to IS NULL)'2024-03-01' BETWEEN valid_from AND valid_to
При полуоткрытых интервалах
valid_to старой записи совпадает с valid_from новой, поэтому верхняя граница должна сравниваться строго (>), иначе в день смены вернутся обе цены. BETWEEN тоже включает обе границы и к тому же теряет текущую запись (сравнение с NULL), а valid_to IS NULL — это цена «сейчас», а не на дату.Пользователи удаляются мягко (
deleted_at), а частичных индексов в MySQL 8 нет. Какой генерируемый столбец с UNIQUE позволит заново зарегистрировать email удалённого пользователя, но запретит два *активных* аккаунта с одним email?CREATE TABLE users (
id INT PRIMARY KEY,
email VARCHAR(255) NOT NULL,
deleted_at DATETIME, -- NULL = активен
/* генерируемый столбец ? */
);active_email VARCHAR(255) AS (CASE WHEN deleted_at IS NULL THEN email ELSE '' END) UNIQUEactive_email VARCHAR(255) AS (CASE WHEN deleted_at IS NULL THEN email END) UNIQUEactive_email VARCHAR(255) AS (email) UNIQUEactive_email VARCHAR(255) AS (CASE WHEN deleted_at IS NOT NULL THEN email END) UNIQUE
У активных строк столбец равен email, у удалённых — NULL, а уникальный индекс допускает сколько угодно NULL. Поэтому уникальность проверяется только среди активных, а удалённых с тем же email может быть много. С
ELSE '' все удалённые получают одинаковую пустую строку и конфликтуют между собой, условие IS NOT NULL проверяет уникальность не тех строк, а AS (email) — обычный UNIQUE по email. В PostgreSQL то же делают частичным индексом ... (email) WHERE deleted_at IS NULL.Что из перечисленного — реальный недостаток мягкого удаления (
deleted_at вместо DELETE)?- Каждый запрос должен помнить про фильтр
deleted_at IS NULL, иначе «удалённые» строки всплывут в выборках - Мягко удалённые строки уже невозможно восстановить
- СУБД не позволяет индексировать столбец
deleted_at - Внешние ключи начинают ссылаться на несуществующие строки
Строка физически остаётся, поэтому фильтр приходится добавлять везде — в запросы, отчёты, JOIN, уникальные индексы, — и одно забытое место показывает «удалённые» данные. Кроме того, не срабатывают
ON DELETE CASCADE, таблица растёт. Восстановление, наоборот, главный плюс мягкого удаления, а ссылки FK остаются валидными — строка ведь существует.Атрибуты товаров хранятся в EAV-таблице (Entity–Attribute–Value). В чём главная проблема такой схемы?
CREATE TABLE product_attrs (
product_id INT,
attr_name VARCHAR(50), -- 'color', 'weight', ...
attr_value VARCHAR(255)
);- Таблица быстро упрётся в лимит числа столбцов
- Такую таблицу невозможно проиндексировать
- СУБД не даст создать её, потому что она нарушает 1НФ
- Нельзя задать тип, NOT NULL или CHECK для отдельного атрибута, а сборка товара требует pivot или много JOIN
В EAV все значения — строки в одном столбце: вес нельзя сделать числом, цвет — обязательным, а значение — ссылкой на справочник. Чтобы получить товар «как строку», нужен pivot или JOIN на каждый атрибут, а фильтры по нескольким атрибутам становятся громоздкими. Индексировать EAV можно, и столбцов там как раз мало — проблема в целостности и сложности запросов.
Какая альтернатива EAV для «гибких» атрибутов товаров обычно предпочтительнее в PostgreSQL?
- Отдельная таблица под каждый товар
- Столбец
json— он индексируется автоматически и быстрееjsonb - Столбец
jsonbс GIN-индексом, а общие для всех товаров атрибуты — обычными столбцами - Столбец
text, где атрибуты перечислены через запятую
jsonb хранит документ в разобранном бинарном виде, поддерживает операторы @>, ? и индексы GIN, а частые атрибуты лучше оставить обычными типизированными столбцами. Тип json хранит исходный текст и не индексируется GIN напрямую, строка через запятую нарушает 1НФ, а таблица на каждый товар не масштабируется.Комментарии могут относиться к постам или к фото. Чем плоха такая полиморфная связь?
CREATE TABLE comments (
id INT PRIMARY KEY,
commentable_type VARCHAR(20), -- 'post' | 'photo'
commentable_id INT,
body TEXT
);- Комментарии придётся дублировать в
postsиphotos - На
commentable_idнельзя повесить внешний ключ — он ссылается на разные таблицы, и целостность держится только на коде - Такую связь вообще нельзя использовать в JOIN
- Из-за неё в
commentsнельзя объявить первичный ключ
Внешний ключ ссылается ровно на одну таблицу, поэтому БД не проверит, что пост или фото с таким id существует, и не удалит комментарии каскадно — появляются «висячие» ссылки. JOIN при этом возможен (с условием на
commentable_type). Альтернативы — отдельные nullable FK с CHECK, отдельные связующие таблицы или общий супертип commentables.Вместо полиморфной связи сделали два nullable FK. Какое CHECK-ограничение гарантирует, что комментарий привязан ровно к одному объекту (SQLite / MySQL 8, где TRUE = 1)?
CREATE TABLE comments (
id INT PRIMARY KEY,
post_id INT REFERENCES posts(id),
photo_id INT REFERENCES photos(id),
CHECK ( /* ? */ )
);(post_id IS NOT NULL) + (photo_id IS NOT NULL) = 1post_id IS NULL OR photo_id IS NULLCOALESCE(post_id, photo_id) IS NOT NULLpost_id IS NOT NULL OR photo_id IS NOT NULL
Сумма булевых значений считает заполненные ссылки, и условие «ровно одна» отсекает и пустой комментарий, и привязку к двум объектам сразу.
OR ... IS NOT NULL и COALESCE запрещают только пустой вариант, а OR ... IS NULL — только двойной. В PostgreSQL булевы значения не складываются — там пишут num_nonnulls(post_id, photo_id) = 1.Почему тип
money в PostgreSQL обычно не рекомендуют для хранения сумм?- Его максимальное значение — около двух миллионов
- Он хранит значение как float и теряет копейки при сложении
- Значения типа money нельзя суммировать через SUM
- Число знаков после запятой задаёт настройка
lc_monetary, а код валюты в значении не хранится
money — это 64-битное целое с фиксированной дробной частью, но точность и формат вывода берутся из lc_monetary сервера, а валюта не хранится: смена локали или мультивалютные данные превращаются в проблему. Обычно используют numeric(p, s) плюс отдельный столбец с кодом валюты (ISO 4217) или целые минорные единицы в bigint. Float и проблем с SUM у money нет — это частые заблуждения.Нужно хранить время встречи «15 марта следующего года в 10:00 по Минску». Почему для таких *будущих* событий часто хранят локальное время и имя зоны (
Europe/Minsk), а не только момент в UTC?- Индексы по timestamptz не работают для будущих дат
- Смещение +03:00 точнее имени зоны, поэтому его и нужно хранить вместо UTC
- Правила часового пояса (смещение, летнее время) могут измениться до события — UTC, посчитанный заранее, «уедет» от 10:00
- UTC не умеет хранить даты дальше чем на год вперёд
Для прошедших событий UTC (
timestamptz) — правильный выбор: момент уже зафиксирован. Для будущих важно намерение «10:00 по местному времени», а правительства меняют смещения и правила DST; если заранее перевести в UTC, после обновления tzdata встреча окажется в 9:00 или 11:00. Фиксированное смещение +03:00 теряет ту же информацию, что и UTC.Статусы заказа хранятся в MySQL как
status ENUM('new', 'paid', 'shipped'). Почему справочная таблица order_statuses с внешним ключом (или VARCHAR + CHECK) часто оказывается удобнее?- ENUM не позволяет искать по статусу через WHERE
- Новый статус в ENUM требует ALTER TABLE, а в справочнике это обычный INSERT, и к статусу можно добавить атрибуты (название, порядок, флаг «финальный»)
- ENUM занимает больше места, чем VARCHAR с тем же текстом
- Значения ENUM нельзя индексировать
Список значений ENUM — часть определения столбца: добавление, переименование или удаление статуса — это изменение схемы, а на большой таблице и при удалении значения
ALTER TABLE может перестраивать её целиком. Справочник меняется обычными DML-командами, хранит дополнительные свойства статуса и переносим между СУБД. Компактность (1–2 байта) и индексируемость у ENUM как раз есть.Какое определение столбца в MySQL 8 автоматически обновит
updated_at при каждом изменении строки?updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMPupdated_at TIMESTAMP DEFAULT NOW() ON INSERT NOW()updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMPupdated_at TIMESTAMP AS (CURRENT_TIMESTAMP)
DEFAULT CURRENT_TIMESTAMP заполняет значение только при вставке, а ON UPDATE CURRENT_TIMESTAMP обновляет его при каждом UPDATE, который реально изменил строку (работает для TIMESTAMP и DATETIME). Генерируемый столбец не может использовать недетерминированную функцию, а ON INSERT такого синтаксиса нет. В PostgreSQL аналога нет — там пишут триггер BEFORE UPDATE.Что произойдёт в PostgreSQL 16?
CREATE TABLE "Users" (id INT);
SELECT * FROM Users;- SELECT найдёт таблицу: регистр в именах всегда игнорируется
- Ошибка уже на CREATE TABLE: заглавные буквы в именах запрещены
- SELECT найдёт таблицу, но выдаст предупреждение о регистре
- Ошибка relation "users" does not exist: имя без кавычек приводится к нижнему регистру
PostgreSQL приводит неэкранированные идентификаторы к нижнему регистру, а имя в двойных кавычках сохраняет как есть. Таблица называется
Users, а запрос ищет users. Теперь к ней всегда придётся обращаться как "Users" — поэтому в PostgreSQL принято использовать только snake_case в нижнем регистре.Магазин принимает оплату в разных валютах. Как обычно проектируют хранение сумм?
CREATE TABLE payments (
id BIGINT PRIMARY KEY,
amount /* ? */,
currency /* ? */
);amount VARCHAR(30)со значениями вида '100.50 EUR', чтобы сумма и валюта не разъехались- Отдельный столбец под каждую валюту:
amount_usd,amount_eur,amount_jpy amount DECIMAL(19, 4)иcurrency CHAR(3)(код ISO 4217: USD, EUR, JPY) — сумма всегда хранится вместе со своей валютойamount FLOAT, а валюту не хранить: всё сразу пересчитывать в доллары по текущему курсу
Сумма без валюты бессмысленна, поэтому её хранят парой «точное число + код ISO 4217», а курс на момент операции при необходимости фиксируют отдельно. Учтите, что у валют разное число знаков после запятой (JPY — 0, KWD — 3), так что «всё в центах × 100» не универсально. Пересчёт при записи теряет исходную сумму, строка вида '100.50 EUR' не суммируется и не проверяется, а столбец на каждую валюту — повторяющаяся группа.
Нужна связь «один к одному»: у пользователя не больше одного профиля, и профиль обязательно принадлежит существующему пользователю. Какое определение
profiles.user_id это гарантирует?CREATE TABLE profiles (
id INT PRIMARY KEY,
/* user_id ... ? */
);user_id INT NOT NULL UNIQUEuser_id INT NOT NULL UNIQUE REFERENCES users(id)user_id INT UNIQUE REFERENCES users(id)user_id INT NOT NULL REFERENCES users(id)
Три требования — три ограничения:
REFERENCES проверяет существование пользователя, UNIQUE запрещает второй профиль, NOT NULL — профиль без владельца. Без UNIQUE получится «один ко многим», без REFERENCES можно сослаться на несуществующего пользователя (например, 99), а без NOT NULL допускаются «ничьи» профили — UNIQUE не запрещает NULL.Какой способ хранения дерева категорий позволяет получить всех потомков узла одним нерекурсивным запросом по индексу?
- Materialized path: столбец
path = '1/4/9/'и условиеpath LIKE '1/4/%' - Хранить id детей JSON-массивом в строке родителя
- Список смежности: только
parent_idи выборкаWHERE parent_id = 4 - Хранить у каждого узла
depthи выбиратьWHERE depth > 2
В materialized path каждый узел хранит путь от корня, и все потомки — это строки с общим префиксом;
LIKE 'префикс%' использует B-tree индекс. Тех же целей достигают closure table (таблица всех пар «предок — потомок») и nested sets. Список смежности с parent_id = 4 даёт только прямых детей — для всего поддерева нужен рекурсивный CTE.Изменения заказов пишутся триггером в таблицу аудита. Почему на
orders_audit.order_id обычно *не* вешают внешний ключ на orders(id)?CREATE TABLE orders_audit (
id BIGINT PRIMARY KEY,
order_id BIGINT NOT NULL, -- без REFERENCES orders(id)
action VARCHAR(10), -- 'INSERT' | 'UPDATE' | 'DELETE'
old_row JSON,
changed_at TIMESTAMP,
changed_by VARCHAR(64)
);- Внешний ключ в разы замедлит SELECT из таблицы аудита
- У таблицы аудита не может быть первичного ключа, а без него FK не работает
- Внешний ключ нельзя создать на таблицу, в которую пишет триггер
- Аудит должен пережить удаление заказа: FK либо запретит DELETE, либо с CASCADE сотрёт историю
Журнал изменений ценен как раз тогда, когда исходной строки уже нет: с FK без
ON DELETE удалить заказ станет невозможно, а с CASCADE вместе с заказом исчезнет и запись о его удалении. Поэтому аудит хранит «снимок» (old_row) и идентификатор как обычное значение. Ограничений на FK к таблицам с триггерами нет, а замедляют FK запись, а не чтение.Безопасность и права16
Логин подставляется в запрос склейкой строк. Злоумышленник вводит логин
admin' -- (с пробелом в конце). Что получится?$sql = "SELECT * FROM users
WHERE login = '" . $login . "'
AND pass_hash = '" . $hash . "'";- Ничего опасного: кавычка внутри строки экранируется автоматически
- Вернутся все пользователи, но вход не выполнится
- Проверка пароля закомментируется — вход под admin без пароля
- Запрос упадёт с синтаксической ошибкой из-за лишней кавычки
Кавычка закрывает строковый литерал, а
-- превращает остаток (' AND pass_hash = ...) в комментарий: условие сводится к login = 'admin'. Ничего автоматически не экранируется — именно поэтому склейка SQL с вводом пользователя опасна. Защита — параметризованные запросы.Какой способ надёжно защищает от SQL-инъекций при подстановке пользовательских *значений* в запрос?
- Удалять из ввода слова SELECT, DROP и UNION
- Параметризованные запросы:
WHERE login = ?, а значение передаётся отдельно - Оборачивать значение в двойные кавычки вместо одинарных
- Проверять ввод JavaScript-ом в браузере перед отправкой
При prepared statements текст запроса и данные передаются раздельно: значение никогда не разбирается как SQL, какие бы символы в нём ни были. Чёрные списки слов обходятся (
SeLeCt, комментарии, кодировки), смена кавычек ничего не меняет, а клиентскую проверку злоумышленник просто пропустит, отправив запрос напрямую.Разработчик параметризовал и столбец сортировки (MySQL, PDO). Что не так?
$stmt = $pdo->prepare(
"SELECT * FROM products ORDER BY ?"
);
$stmt->execute([$_GET['sort']]); // 'price'- Плейсхолдер подставляет значение, а не имя столбца: будет сортировка по константе 'price'. Имена проверяют по белому списку
- Запрос упадёт: в ORDER BY нельзя использовать выражения
- Всё правильно: сортировка защищена от инъекций и работает
- PDO сам превратит строку в имя столбца в обратных кавычках
Параметр — это всегда значение-литерал, поэтому получается
ORDER BY 'price': сортировка по одинаковой для всех строк константе, то есть фактически без сортировки. Имена таблиц, столбцов и направление (ASC/DESC) параметризовать нельзя — их выбирают из заранее заданного белого списка, например ['price' => 'price', 'name' => 'name'].Пользователь ищет строку
100%_off. Что верно про этот код?$stmt = $pdo->prepare(
"SELECT * FROM goods WHERE name LIKE ?"
);
$stmt->execute(['%' . $q . '%']);- Это SQL-инъекция: символ
%выходит за пределы строкового литерала - PDO автоматически экранирует
%и_внутри LIKE - Запрос упадёт: шаблон LIKE нельзя передавать параметром
- Инъекции нет, но
%и_из ввода работают как шаблоны — их нужно экранировать отдельно
Параметр защищает от изменения структуры запроса, но значение всё равно интерпретируется оператором
LIKE: % — любая подстрока, _ — любой символ. Поиск по 100%_off найдёт и «1000 bonus off». Спецсимволы экранируют (\%, \_ или с ESCAPE '!') перед подстановкой — драйвер этого не делает.Что такое SQL-инъекция второго порядка?
- Инъекция через второй параметр prepared statement
- Подбор пароля второй учётной записи базы данных
- Вредоносное значение безопасно сохраняется в БД, а позже другой код читает его и склеивает в SQL без параметров
- Инъекция, для которой нужно отправить два запроса с одного IP-адреса
Например, логин
x' OR '1'='1 корректно вставлен через параметры, но потом фоновая задача строит из него запрос конкатенацией — и инъекция срабатывает. Данные из своей же базы не являются «доверенными»: параметризовать нужно любой запрос, а не только тот, что получает ввод напрямую от пользователя.Как правильно параметризовать
WHERE id IN (...) для списка из произвольного числа id?- Один плейсхолдер
IN (?)и строка'1,2,3'в качестве значения - Сгенерировать по плейсхолдеру на каждый элемент —
IN (?, ?, ?)— и передать значения отдельно - Склеить
implode(',', $_GET['ids'])прямо в SQL — это же числа - IN параметризовать нельзя, поэтому список заменяют на LIKE
Один плейсхолдер — это одно значение:
IN ('1,2,3') сравнит id со строкой целиком (в MySQL '1,2,3' к тому же приведётся к числу 1). Для списка генерируют нужное число ? и передают элементы отдельно; в PostgreSQL удобно передать массив в = ANY($1). Склейка «чисел» из запроса без приведения типов — та же инъекция: в массив можно положить что угодно.Что сможет делать пользователь
app с таблицей shop.orders после этой команды (MySQL 8), если других прав у него нет?GRANT SELECT, INSERT ON shop.orders TO 'app'@'%';- Читать и добавлять строки, но не изменять и не удалять их
- Всё, включая DROP TABLE
- Только читать строки
- Читать, добавлять и изменять строки — UPDATE входит в INSERT
Привилегии выдаются поимённо:
SELECT — чтение, INSERT — вставка. UPDATE, DELETE, DROP и прочие нужно выдавать отдельно, и они не следуют друг из друга. Такой точечный набор — пример принципа наименьших привилегий, например для сервиса, который только пишет журнал заказов.Сможет ли
analyst читать orders после REVOKE (PostgreSQL)?GRANT SELECT ON orders TO analyst;
GRANT reporting TO analyst;
-- у роли reporting тоже есть SELECT ON orders
REVOKE SELECT ON orders FROM analyst;- Нет: REVOKE заодно исключает analyst из роли reporting
- Ошибка: нельзя отозвать право, которое есть и через роль
- Нет: REVOKE снимает право из всех источников
- Да: REVOKE снял только прямое право, а SELECT остаётся через роль reporting
REVOKE удаляет только ту запись о привилегии, которая была выдана напрямую. Роль analyst по-прежнему член reporting и (при атрибуте INHERIT по умолчанию) пользуется её правами. Чтобы закрыть доступ, нужно ещё REVOKE reporting FROM analyst или отозвать право у самой роли.Веб-приложение подключается к БД. Какая настройка учётной записи соответствует принципу наименьших привилегий?
- Пользователь с ALL PRIVILEGES на все базы, но с паролем из 32 символов
- Один общий пользователь для приложения, миграций и администраторов
- Отдельный пользователь с SELECT/INSERT/UPDATE/DELETE только на нужные таблицы; миграции — под другим пользователем с правами DDL
- Пользователь root — так приложение не упадёт из-за нехватки прав
Учётной записи выдают ровно то, что нужно для работы. Тогда при SQL-инъекции или утечке пароля злоумышленник не сможет удалить таблицы, читать чужие базы или создавать пользователей. Длинный пароль не ограничивает ущерб после взлома, а общий аккаунт ещё и лишает аудита: непонятно, кто что сделал.
Через месяц создали таблицу
invoices, и роль readonly не может её читать. Почему (PostgreSQL)?-- выполнено месяц назад:
GRANT SELECT ON ALL TABLES IN SCHEMA public TO readonly;- GRANT ON ALL TABLES не распространяется на таблицы с первичным ключом
- GRANT ... ON ALL TABLES касается только уже существующих таблиц; для будущих нужен ALTER DEFAULT PRIVILEGES
- Роль readonly нужно было создать с атрибутом SUPERUSER
- Права на схему public автоматически сбрасываются раз в месяц
ON ALL TABLES IN SCHEMA — разовая операция над таблицами, существующими в момент выполнения. Для новых объектов задают права по умолчанию: ALTER DEFAULT PRIVILEGES FOR ROLE app_owner IN SCHEMA public GRANT SELECT ON TABLES TO readonly; — они применятся к таблицам, которые потом создаст app_owner. Делать readonly-роль суперпользователем — прямое нарушение наименьших привилегий.Что даёт
WITH GRANT OPTION в этой команде?GRANT SELECT ON orders TO alice WITH GRANT OPTION;- alice может сама выдавать SELECT на orders другим пользователям
- alice получает все права на orders, а не только SELECT
- Право SELECT больше нельзя будет отозвать у alice
- alice получает SELECT на все таблицы схемы
WITH GRANT OPTION разрешает получателю передавать *именно это* право дальше. Отозвать его можно; если alice успела раздать право дальше, в PostgreSQL для отзыва понадобится REVOKE ... CASCADE, который снимет и выданные ею права. Набор прав и их область от этой опции не расширяются.Разработчик проверяет политику, подключившись под ролью — владельцем таблицы
docs, и видит все строки. Почему (PostgreSQL)?ALTER TABLE docs ENABLE ROW LEVEL SECURITY;
CREATE POLICY own_docs ON docs
USING (owner = current_user);- current_user в политике всегда возвращает имя суперпользователя
- Политика начнёт действовать только после перезапуска сервера
- USING применяется только к UPDATE и DELETE, а не к SELECT
- Политики RLS по умолчанию не действуют на владельца таблицы — нужен
ALTER TABLE docs FORCE ROW LEVEL SECURITY
Владелец таблицы обходит RLS, пока не включён
FORCE ROW LEVEL SECURITY; суперпользователи и роли с атрибутом BYPASSRLS обходят его всегда. Поэтому проверять политики надо под обычной ролью приложения, а приложение не должно подключаться под владельцем таблиц. USING при этом применяется и к SELECT, перезапуск не нужен.В PostgreSQL для таблицы включили
ENABLE ROW LEVEL SECURITY, но не создали ни одной политики. Что увидит обычный пользователь (не владелец) с правом SELECT?- Ошибку при каждом запросе к таблице
- Только строки, которые он вставил сам
- Ни одной строки — без политик действует запрет по умолчанию
- Все строки — без политик RLS ни на что не влияет
Если RLS включён, а подходящих политик нет, PostgreSQL применяет политику «deny by default»:
SELECT вернёт пустой результат, а UPDATE/DELETE не затронут ни одной строки (без ошибки). Это безопасное поведение: забытая политика закрывает доступ, а не открывает его. Понятие «свои строки» появляется только из явно описанной политики.Чем
USING отличается от WITH CHECK в политике RLS?CREATE POLICY p ON docs FOR ALL
USING (owner = current_user)
WITH CHECK (owner = current_user);- USING действует для SELECT, а WITH CHECK — для DELETE
- USING фильтрует существующие строки (что видно и что можно менять), WITH CHECK проверяет новые значения строк при INSERT и UPDATE
- Это синонимы, второй оставлен для совместимости
- WITH CHECK проверяется один раз — при создании политики
USING — фильтр для уже существующих строк: какие из них видны и какие можно обновить или удалить. WITH CHECK проверяет строку, которая *получится* после INSERT или UPDATE, — например, не даёт переписать owner на чужое имя. Если WITH CHECK не указан, для этой проверки используется выражение USING. Нарушение WITH CHECK даёт ошибку, а не тихий пропуск строки.Как правильно хранить пароли пользователей в таблице?
- Хеш медленной функцией с солью (bcrypt, Argon2), вычисленный в приложении
- Открытым текстом, но закрыть столбец через REVOKE
- MD5 от пароля — его нельзя расшифровать
- AES_ENCRYPT с ключом, который лежит в той же базе
Медленные хеш-функции с солью (bcrypt, scrypt, Argon2) делают перебор утёкшей базы дорогим, а соль не даёт использовать готовые таблицы. MD5 и SHA-1 считаются миллиардами в секунду на GPU, обратимое шифрование с ключом в той же БД равно открытому тексту, а права доступа не защищают от утечки бэкапа или дампа.
Приложение на том же сервере подключается к MySQL 8 через localhost как
app с паролем p1. Сможет ли оно читать shop.orders?CREATE USER 'app'@'localhost' IDENTIFIED BY 'p1';
CREATE USER 'app'@'%' IDENTIFIED BY 'p2';
GRANT SELECT ON shop.* TO 'app'@'%';- Да: права
app@%распространяются на все хосты, включая localhost - Да, если при подключении указать пароль p2
- Нет: MySQL запрещает две учётные записи с одним именем
- Нет: это отдельная учётная запись
app@localhostбез прав — привилегииapp@%к ней не относятся
В MySQL учётная запись — это пара «имя + хост». При подключении выбирается наиболее конкретное совпадение по хосту, то есть
app@localhost со своим паролем и своими (здесь — пустыми) правами. С паролем p2 с localhost войти не получится: проверка идёт для той же записи app@localhost. Права нужно выдавать именно той записи, под которой подключается приложение.Масштабирование и репликация17
В классической схеме репликации «primary → реплики» (master → slaves) как распределяют нагрузку?
- Записи распределяют по репликам, а чтение идёт только с primary
- Каждая реплика принимает записи своей части пользователей
- Все записи идут на primary, а чтение можно распределять по репликам
- Реплики нужны только для бэкапа и запросов не обслуживают
Primary — единственный узел, принимающий изменения; реплики получают поток изменений и обслуживают чтение, которое в типичном приложении составляет основную нагрузку. Запись это не масштабирует: все
INSERT/UPDATE всё равно проходят через один узел. Запись по частям данных на разные узлы — уже шардирование.Пользователь сохранил профиль (запись на primary), страница перезагрузилась — и он видит старые данные, потому что чтение идёт с реплики. Как это обычно исправляют?
- Добавить реплик — лаг уменьшится пропорционально их числу
- Некоторое время после записи читать данные этого пользователя с primary (read-your-writes) или ждать, пока реплика догонит нужную позицию
- Отключить индексы на реплике, чтобы она быстрее применяла изменения
- Направить записи на реплику, а чтение — на primary
Асинхронная реплика всегда немного отстаёт (replication lag). Гарантия «читаю свои записи» обеспечивается маршрутизацией: после записи запросы пользователя некоторое время идут на primary, либо приложение ждёт, пока реплика применит нужную позицию журнала (GTID/LSN). Дополнительные реплики лаг не уменьшают — каждая применяет тот же поток изменений.
Что может произойти при асинхронной репликации, если primary внезапно выходит из строя и реплику повышают до primary?
- Последние транзакции, которые клиент уже получил как подтверждённые, но реплика ещё не получила, будут потеряны
- Ничего: при асинхронной репликации COMMIT ждёт подтверждения от реплики
- Реплика откажется стать primary, пока старый не восстановится
- Потеряются только незакоммиченные транзакции — как при любом сбое
При асинхронной репликации
COMMIT возвращается клиенту сразу после записи на primary, а изменения уходят на реплику позже. Если primary умер в этот промежуток, подтверждённые транзакции на новой primary отсутствуют. Синхронная (или полусинхронная в MySQL) репликация уменьшает такой риск ценой задержки каждой записи.Чем секционирование (partitioning) отличается от шардирования (sharding)?
- Это одно и то же, просто разные названия в PostgreSQL и MySQL
- Секционирование делит таблицу по столбцам, а шардирование — по строкам
- Шардирование — это репликация с несколькими primary
- Секции — части одной таблицы на одном сервере БД, шарды — части данных на разных серверах
Секционирование — внутренний механизм СУБД: таблица логически одна, а физически разбита (по диапазону, списку или хешу) на секции в одном экземпляре; это упрощает удаление старых данных и сокращает сканирование. Шардирование разносит данные по независимым серверам, чтобы масштабировать запись и объём, но приносит межшардовые запросы и распределённые транзакции. Оба способа обычно режут по строкам.
В какую секцию попадёт вставленная строка (PostgreSQL 16)?
CREATE TABLE events (id BIGINT, created_at timestamptz)
PARTITION BY RANGE (created_at);
CREATE TABLE events_2024 PARTITION OF events
FOR VALUES FROM ('2024-01-01') TO ('2025-01-01');
CREATE TABLE events_2025 PARTITION OF events
FOR VALUES FROM ('2025-01-01') TO ('2026-01-01');
INSERT INTO events VALUES (1, '2025-01-01 00:00:00');- Ошибка: граница принадлежит сразу двум секциям
- В обе секции одновременно
- В events_2025: нижняя граница FROM включается, верхняя TO — нет
- В events_2024: верхняя граница TO включается
Границы RANGE-секций в PostgreSQL полуоткрытые:
FROM включительно, TO не включительно. Поэтому соседние секции стыкуются без зазоров и пересечений, а полночь 1 января относится к новому году. Пересекающиеся границы PostgreSQL не позволил бы создать.Таблица
orders секционирована по месяцам: PARTITION BY RANGE (created_at). Почему этот запрос медленный?SELECT * FROM orders
WHERE customer_id = 42;- PostgreSQL блокирует все секции на запись на время SELECT
- В условии нет ключа секционирования, поэтому отсечение секций невозможно — проверяются все секции
- Секционированные таблицы не поддерживают WHERE по другим столбцам
- Запрос просматривает только первую секцию и потом досканирует остальные
Partition pruning работает только по условиям на ключ секционирования: зная
created_at, планировщик отбрасывает ненужные секции. Без него запрос идёт во все секции (по индексу customer_id в каждой, если он есть). Секционирование не ускоряет произвольные запросы — ключ выбирают под самые частые фильтры, обычно дату.Что произойдёт при выполнении команды в MySQL 8?
CREATE TABLE orders (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
created_at DATETIME NOT NULL
)
PARTITION BY RANGE (YEAR(created_at)) (
PARTITION p2024 VALUES LESS THAN (2025),
PARTITION p2025 VALUES LESS THAN (2026)
);- Ошибка: каждый уникальный ключ, включая PRIMARY KEY, должен содержать все столбцы выражения секционирования
- Ошибка: RANGE-секционирование не поддерживает функцию YEAR()
- Таблица создастся, AUTO_INCREMENT будет сквозным для всех секций
- Таблица создастся, но id будет начинаться заново в каждой секции
В MySQL уникальность проверяется внутри каждой секции, поэтому любой
PRIMARY KEY/UNIQUE обязан включать столбцы ключа секционирования — иначе ошибка 1503 «A PRIMARY KEY must include all columns in the table's partitioning function». Исправление — PRIMARY KEY (id, created_at). Функция YEAR() в выражении RANGE разрешена.В PostgreSQL в таблицу, секционированную по
created_at, вставляют строку с датой, для которой нет подходящей секции (и секции DEFAULT тоже нет). Что произойдёт?- Нужная секция будет создана автоматически
- Строка запишется в саму родительскую таблицу
- Строка попадёт в последнюю созданную секцию
- Ошибка «no partition of relation ... found for row»
Родительская секционированная таблица данных не хранит, а секции автоматически не создаются —
INSERT завершится ошибкой. Поэтому секции на будущие периоды создают заранее (cron, расширение pg_partman) или добавляют PARTITION OF ... DEFAULT для «непредвиденных» значений.Зачем приложению пул соединений с БД?
- Чтобы кэшировать результаты SELECT между запросами
- Чтобы шифровать трафик между приложением и БД
- Чтобы переиспользовать открытые соединения: новое соединение дорогое, а их число у СУБД ограничено
- Чтобы запросы одной транзакции выполнялись параллельно
Установка соединения — это TCP, аутентификация, а в PostgreSQL ещё и отдельный серверный процесс; тысячи соединений расходуют память и упираются в
max_connections. Пул держит небольшое число соединений и выдаёт их запросам по очереди. Кэширование результатов и шифрование — задачи других механизмов.PgBouncer работает в режиме
pool_mode = transaction. Что из этого может сломаться?- Обычные транзакции BEGIN ... COMMIT — через такой пул их выполнять нельзя
- Состояние сессии: SET вне транзакции, временные таблицы, сессионные advisory-блокировки — следующая транзакция может попасть в другое серверное соединение
- INSERT ... RETURNING — пул не возвращает сгенерированные значения
- Запросы длиннее 8 КБ — они не помещаются в буфер пула
В transaction-режиме серверное соединение закрепляется за клиентом только на время транзакции, а потом отдаётся другому клиенту. Всё, что живёт дольше транзакции на уровне сессии, —
SET параметров, LISTEN, временные таблицы, pg_advisory_lock — теряется или «протекает» к чужим клиентам. Транзакции и RETURNING работают как обычно.Что на практике утверждает теорема CAP?
- При сетевом разделении распределённая система вынуждена выбирать: отвечать на запросы (доступность) или гарантировать согласованность
- Любая БД обеспечивает не больше двух свойств из трёх в любой момент, даже без сбоев сети
- Реляционные БД всегда CA, а NoSQL — всегда AP
- Чем больше реплик, тем выше одновременно согласованность и доступность
Разделение сети (P) в распределённой системе неизбежно, поэтому реальный выбор — между C и A на время сбоя: отказать части клиентов или отвечать возможно устаревшими данными. Пока сеть исправна, можно иметь и то и другое. Ярлыки по типу СУБД неточны: многие системы настраиваются в обе стороны (например, уровнями согласованности в Cassandra).
В каком случае NoSQL-хранилище вместо реляционной БД наиболее оправдано?
- Любой проект, где больше миллиона строк
- Учёт денежных переводов с транзакциями, затрагивающими несколько счетов
- Отчёты с многотабличными JOIN и сложной агрегацией
- Кэш и сессии с доступом по ключу и огромным числом простых чтений и записей (например, Redis)
Key-value и документные хранилища сильны там, где доступ идёт по ключу, схема гибкая, а нужна горизонтальная масштабируемость и низкая задержка. Многострочные ACID-транзакции, сложные JOIN и аналитика — сильная сторона реляционных СУБД. Объём сам по себе не причина: миллионы и даже миллиарды строк — обычная работа для PostgreSQL или MySQL.
Данные шардируют по диапазонам
created_at: январь — шард 1, февраль — шард 2 и так далее. Какая проблема возникнет?- Проблем нет: записи распределятся по шардам равномерно
- Нельзя будет выбрать данные за конкретный месяц
- Почти все новые записи пойдут в один «горячий» шард текущего месяца, а остальные будут простаивать
- Шарды начнут дублировать данные друг друга
При монотонно растущем ключе (время, автоинкремент) вся запись приходится на шард с последним диапазоном — горизонтальное масштабирование записи не работает. Поэтому для записи обычно выбирают хеш от ключа или ключ с высокой кардинальностью (например,
user_id); диапазоны по времени хороши для секционирования внутри одного сервера и архивации.SaaS-сервис шардирует данные. Почему ключ шардирования часто выбирают как
tenant_id (компания-клиент), а не id отдельных строк?- Шардировать по id строк запрещено в большинстве СУБД
- Все данные одного клиента оказываются на одном шарде, и его JOIN и транзакции не становятся межшардовыми
- tenant_id уникален для каждой строки, поэтому распределение идеально
- Так шарды гарантированно получаются одинакового размера
Почти все запросы SaaS-приложения ограничены одним клиентом, и если его заказы, счета и пользователи лежат вместе, JOIN и транзакции выполняются локально. При шардировании по
id строк данные клиента разлетятся по всем шардам, и каждый запрос станет распределённым. Минус — крупный клиент может перегрузить свой шард, поэтому большие тенанты иногда выносят отдельно.Почему реплика не заменяет резервную копию?
- Ошибочный DELETE или DROP TABLE тут же реплицируется — на реплике данных тоже не станет
- Реплика хранит только индексы, без самих данных
- Реплика всегда отстаёт на сутки, поэтому данные устаревшие
- Реплика недоступна для чтения, пока работает primary
Репликация защищает от отказа оборудования, но послушно повторяет любые логические ошибки: удалённое на primary удаляется и на репликах за доли секунды. Для восстановления «на момент до ошибки» нужны бэкапы и архив журналов (PITR) или реплика с намеренной задержкой (
recovery_min_apply_delay в PostgreSQL).Таблица логов секционирована по годам. Почему второй способ удалить старые данные предпочтительнее (PostgreSQL)?
-- способ 1
DELETE FROM logs
WHERE created_at < '2024-01-01';
-- способ 2
ALTER TABLE logs DETACH PARTITION logs_2023;
DROP TABLE logs_2023;- DETACH автоматически переносит строки в архивную таблицу
- DELETE на секционированных таблицах запрещён
- DROP TABLE можно откатить, а DELETE — нет
- Удаление секции — быстрая операция с метаданными, без построчного удаления, записи каждой строки в WAL и последующего VACUUM
DELETE миллионов строк пишет каждую в WAL, оставляет «мёртвые» версии, которые потом должен вычистить VACUUM, и долго держит блокировки строк. Отключение и удаление секции почти мгновенно и сразу освобождает место — это одна из главных причин секционировать по времени. Оба способа транзакционны в PostgreSQL, а DETACH никуда строки не переносит: секция становится обычной таблицей.Чем логическая репликация PostgreSQL (
PUBLICATION / SUBSCRIPTION) отличается от физической потоковой?- Физическая позволяет выбрать отдельные таблицы, а логическая — только весь кластер
- Логическая всегда синхронная, а физическая — асинхронная
- Логическая передаёт изменения строк выбранных таблиц и работает между разными мажорными версиями; физическая копирует весь кластер побайтно и требует той же версии
- Логическая автоматически реплицирует DDL, а физическая — нет
Физическая репликация передаёт WAL как есть: реплика — побайтная копия всего кластера той же мажорной версии, доступная только на чтение. Логическая декодирует WAL в изменения строк, позволяет выбрать таблицы, писать в подписчик и переезжать между версиями (миграции с минимальным простоем). DDL логическая репликация *не* переносит — схему на подписчике меняют вручную.
How the quiz works
- Pick topics and a level — Junior covers the basics, Middle the everyday details, Senior the tricky corners of the language.
- Answer by tapping an option or with the keyboard: 1–4 or A–D, Enter for the next question.
- Read the explanation — after a mistake it opens right away, after a correct answer it is one tap away.
- Review your mistakes — "Retry mistakes" after the quiz, or the "Only my mistakes" mode later: your answers are remembered in this browser.
An unfinished quiz survives a page reload, so you can continue any time.
Quiz topics
- SELECT и WHERE 7
- Псевдонимы и DISTINCT 7
- NULL 10
- Типы данных 10
- Операторы и выражения 9
- Сортировка и LIMIT 10
- JOIN 14
- GROUP BY и агрегаты 14
- HAVING 6
- Подзапросы 11
- UNION и множества 8
- DDL и ограничения 7
- INSERT, UPDATE, DELETE 11
- Ключи и связи 8
- Нормализация 6
- Индексы 10
- Транзакции и блокировки 9
- Оконные функции 13
- Оптимизация запросов 7
- CTE и рекурсия 9
- CASE и функции 8
- Даты и строки 10
- Представления и процедуры 5
- PostgreSQL 20
- JSON в базе 15
- Индексы: продвинутое 15
- MySQL и InnoDB 20
- MVCC и обслуживание 15
- Кодировки и сортировка 15
- Практические задачи 23
- Аналитические запросы 12
- Найдите ошибку в запросе 16
- Проектирование схемы 17
- Безопасность и права 16
- Масштабирование и репликация 17
Other quizzes
Ruby Quiz414 questionsJavaScript Quiz440 questionsjQuery Quiz110 questionsPHP Quiz410 questionsSymfony Quiz64 questionsLaravel Quiz30 questionsPython Quiz410 questionsGo Quiz410 questionsTypeScript Quiz210 questionsReact Quiz410 questionsJava Quiz115 questionsC# Quiz65 questionsHTML Quiz210 questionsCSS Quiz210 questionsOOP Quiz50 questionsGit Quiz50 questionsQA Quiz40 questionsZig Quiz115 questions
