EXPLAIN показывает план, который PostgreSQL выбрал для запроса, и прогноз планировщика: сколько строк он ждёт от каждого шага и во сколько этот шаг обойдётся. EXPLAIN ANALYZE запрос выполняет и дописывает к прогнозу факт: время каждого узла в миллисекундах и реальное число строк.
Читать план нужно от самых вложенных строк к верхней. Ищите узел, на котором копится время, и сравнивайте у него ожидаемые rows с фактическими: сильное расхождение почти всегда и есть причина медленного запроса.
Если SQL для вас пока новый, начните с разбора языка SQL и статьи о том, как устроена СУБД. Все планы ниже настоящие: это вывод psql на учебной базе с миллионом заказов, скрипт для неё есть в статье, так что любой пример можно повторить у себя. А если работа с базами данных нужна вам как профессия, посмотрите курсы по PostgreSQL в нашем каталоге.
SkillboxPostgreSQL для начинающих24 813 ₽1 месяц
СлёрмPostgreSQL База30 000 ₽2 года
НетологияПрофессия «Аналитик данных с нуля до middle»145 600 ₽12 месяцев
GeekBrainsПрофессия «Программист Java»118 255 ₽7 месяцев
ЭдюсонDevOps-инженер119 900 ₽7 месяцев
SkillFactoryОбучение профессии Data Science с нуля203 706 ₽12 месяцев
Чем EXPLAIN отличается от EXPLAIN ANALYZE

Обе команды пишутся перед запросом. Разница одна, но важная: выполняется запрос или нет.
| EXPLAIN | EXPLAIN ANALYZE | |
|---|---|---|
| Выполняет запрос | Нет, только строит план | Да, целиком |
| Что показывает | Оценки: cost, rows, width | Оценки плюс actual time, фактические rows и loops |
| Сколько работает | Миллисекунды даже для тяжёлого запроса | Столько же, сколько сам запрос |
| Когда брать | Запрос слишком долгий или меняет данные | Нужно найти, где на самом деле уходит время |
В описании команды EXPLAIN об этом есть отдельное предупреждение: с ANALYZE оператор выполняется на самом деле. EXPLAIN отбрасывает только результат SELECT, а у INSERT, UPDATE и DELETE все изменения остаются.
Команды, которые меняют данные, проверяйте внутри транзакции и откатывайте её. Так выглядит безопасный прогон DELETE:
SELECT count(*) FROM orders WHERE status = 'cancelled';
BEGIN;
EXPLAIN ANALYZE DELETE FROM orders WHERE status = 'cancelled';
ROLLBACK;
SELECT count(*) FROM orders WHERE status = 'cancelled';
count
--------
100002
(1 row)
BEGIN
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------
Delete on orders (cost=0.00..23940.00 rows=0 width=0) (actual time=222.057..222.057 rows=0 loops=1)
-> Seq Scan on orders (cost=0.00..23940.00 rows=99720 width=6) (actual time=0.002..34.825 rows=100002 loops=1)
Filter: (status = 'cancelled'::text)
Rows Removed by Filter: 1099998
Planning Time: 0.031 ms
Execution Time: 222.135 ms
(6 rows)
ROLLBACK
count
--------
100002
(1 row)
DELETE отработал, план с фактическим временем получен, а ROLLBACK вернул все 100 002 строки на место. Этот прогон мы делали последним, когда в таблице уже было 1,2 млн строк, поэтому в Rows Removed by Filter стоит 1099998. Зачем нужны BEGIN и ROLLBACK, разобрано в статье про группы команд SQL, а чем DELETE отличается от очистки таблицы целиком, рассказываем в материале о TRUNCATE и DELETE.
Как запустить EXPLAIN ANALYZE: пошаговая инструкция
- Откройте клиент, в котором выполняете запросы: psql, DBeaver с подключением к PostgreSQL или pgAdmin. EXPLAIN это обычная SQL-команда, настраивать для неё ничего не нужно.
- Посмотрите план без выполнения:
EXPLAIN SELECT …;. Если запрос долгий или что-то меняет, на этом шаге можно остановиться. - Запустите
EXPLAIN (ANALYZE, BUFFERS) SELECT …;. BUFFERS покажет, сколько блоков данных нашлось в кеше и сколько пришлось читать. В PostgreSQL 18 этот вывод включается при ANALYZE автоматически, в 17-й и более ранних версиях параметр пишут явно. - Выполните ту же команду второй раз и сравнивайте второй прогон: первый обычно медленнее, потому что данных ещё нет в кеше.
- Найдите узел с самым большим actual time и сравните у него rows из оценки и из факта.
Учебная база для примеров
Две таблицы: 50 000 клиентов из пяти городов и миллион заказов за 600 дней, около 10 % из них отменены.
SELECT setseed(0.42);
CREATE TABLE customers (
id serial PRIMARY KEY,
name text NOT NULL,
city text NOT NULL
);
INSERT INTO customers (name, city)
SELECT 'Клиент ' || g,
(ARRAY['Москва','Казань','Пермь','Самара','Томск'])[1 + (g % 5)]
FROM generate_series(1, 50000) g;
CREATE TABLE orders (
id serial PRIMARY KEY,
customer_id int NOT NULL REFERENCES customers(id),
amount numeric(10,2) NOT NULL,
status text NOT NULL,
created_at timestamp NOT NULL
);
INSERT INTO orders (customer_id, amount, status, created_at)
SELECT 1 + (random() * 49999)::int,
round((random() * 9000 + 100)::numeric, 2),
CASE WHEN random() < 0.9 THEN 'paid' ELSE 'cancelled' END,
timestamp '2025-01-01' + random() * interval '600 days'
FROM generate_series(1, 1000000);
VACUUM ANALYZE customers;
VACUUM ANALYZE orders;
Время у вас будет другим: оно зависит от железа и настроек. Форма планов совпадёт. Вывод в статье снят в PostgreSQL 17. В 18-й версии фактическое число строк печатается с двумя знаками после запятой (rows=16.00), а у индексных узлов появилась строка Index Searches, это тоже есть в списке изменений PostgreSQL 18.
Канал основателя Checkroi Вани Буявца3 800 человек читают мой Телеграм-канал про нейросетиСобрал промпты для Claude Code и ChatGPT, разборы ИИ-инструментов и лайфхаки по продвижению бизнеса в одном местеПрисоединитьсяКак читать план запроса PostgreSQL
Ищем заказы одного клиента. Индекса по customer_id пока нет. Сначала обычный EXPLAIN:
EXPLAIN SELECT * FROM orders WHERE customer_id = 4242;
QUERY PLAN
--------------------------------------------------------------------------
Gather (cost=1000.00..13679.43 rows=21 width=27)
Workers Planned: 2
-> Parallel Seq Scan on orders (cost=0.00..12677.33 rows=9 width=27)
Filter: (customer_id = 4242)
(4 rows)
Теперь тот же запрос с ANALYZE:
EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 4242;
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------
Gather (cost=1000.00..13679.43 rows=21 width=27) (actual time=0.598..10.775 rows=16 loops=1)
Workers Planned: 2
Workers Launched: 2
-> Parallel Seq Scan on orders (cost=0.00..12677.33 rows=9 width=27) (actual time=0.683..8.449 rows=5 loops=3)
Filter: (customer_id = 4242)
Rows Removed by Filter: 333328
Planning Time: 0.006 ms
Execution Time: 10.779 ms
(8 rows)
План устроен как дерево. Каждая строка со стрелкой -> обозначает узел, отступ показывает вложенность. Работа идёт снизу вверх: вложенный узел отдаёт строки родителю.
Здесь Parallel Seq Scan читает таблицу сразу тремя процессами (основной и два фоновых), а Gather собирает их результаты в один поток.
| Что в строке | Что это значит |
|---|---|
| cost=0.00..12677.33 | Оценка стоимости до первой строки и до последней. Единицы условные: по документации, за единицу традиционно принимают чтение одной страницы с диска. Сравнивать имеет смысл стоимости узлов внутри одного плана |
| rows=9 | Сколько строк планировщик ждёт от узла за один проход |
| width=27 | Ожидаемый средний размер строки в байтах |
| actual time=0.683..8.449 | Миллисекунды до первой строки и до последней |
| rows=5 loops=3 | Факт: в среднем 5 строк за проход, проходов было 3 |
| Rows Removed by Filter: 333328 | Сколько прочитанных строк узел выбросил по условию WHERE, тоже в среднем на проход |
| Planning Time | Время на построение плана |
| Execution Time | Время выполнения запроса целиком |
Сложим цифры: 333 328 выброшенных строк × 3 прохода плюс 16 найденных дают ровно миллион. Seq Scan прочитал всю таблицу, чтобы отдать 16 заказов, и это первый признак, что запросу не хватает индекса.
loops: умножайте время на число проходов
Здесь чаще всего ошибаются новички. В разделе документации про EXPLAIN ANALYZE сказано прямо: если узел выполнялся несколько раз, его actual time и rows считаются как среднее по всем итерациям, и общее время получают умножением на loops.
Возьмём заказы одиннадцати клиентов (индекс по customer_id уже создан, о нём в разделе ниже):
EXPLAIN ANALYZE
SELECT c.name, o.amount
FROM customers c JOIN orders o ON o.customer_id = c.id
WHERE c.id BETWEEN 10 AND 20;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------
Nested Loop (cost=4.88..951.43 rows=220 width=24) (actual time=0.012..0.208 rows=215 loops=1)
-> Index Scan using customers_pkey on customers c (cost=0.29..8.51 rows=11 width=22) (actual time=0.002..0.003 rows=11 loops=1)
Index Cond: ((id >= 10) AND (id <= 20))
-> Bitmap Heap Scan on orders o (cost=4.59..85.51 rows=21 width=10) (actual time=0.003..0.017 rows=20 loops=11)
Recheck Cond: (c.id = customer_id)
Heap Blocks: exact=215
-> Bitmap Index Scan on orders_customer_id_idx (cost=0.00..4.58 rows=21 width=0) (actual time=0.001..0.001 rows=20 loops=11)
Index Cond: (customer_id = c.id)
Planning Time: 0.243 ms
Execution Time: 0.217 ms
(10 rows)
Bitmap Heap Scan по orders выполнился 11 раз, по разу на каждого клиента. 0,017 мс × 11 ≈ 0,19 мс, то есть почти всё время запроса. И rows=20 здесь тоже среднее: всего узел отдал 215 строк.
На миллисекундах это не страшно. Но если loops доходит до сотен тысяч, вложенный цикл становится главным тормозом, и такой пример есть в разделе об ошибках.
Узлы плана: что значат Seq Scan, Index Scan и Nested Loop
Названия узлов повторяются от плана к плану. Вот те, что встречаются чаще всего:
| Узел | Что делает | Когда насторожиться |
|---|---|---|
| Seq Scan | Читает таблицу подряд, от первой страницы до последней | Большой Rows Removed by Filter при маленьком результате |
| Index Scan | Находит строку в индексе и идёт за ней в таблицу | Строк много: прыжки по таблице обходятся дороже чтения подряд |
| Index Only Scan | Берёт данные прямо из индекса, без таблицы | Heap Fetches заметно больше нуля: часть строк всё равно читается из таблицы |
| Bitmap Index Scan + Bitmap Heap Scan | Сначала собирает адреса подходящих строк по индексу, затем читает таблицу в порядке страниц | Обычно норма для выборок среднего размера |
| Nested Loop | Для каждой строки внешнего узла выполняет внутренний | loops в тысячах и больше, особенно при оценке rows=1 |
| Hash Join | Строит хеш-таблицу по одной таблице и проходит по второй | Batches больше 1: хеш-таблица не поместилась в память |
| Merge Join | Сливает два отсортированных потока | Под ним дорогой Sort |
| Sort | Сортирует строки для ORDER BY, DISTINCT и соединения слиянием | Sort Method: external merge Disk |
| HashAggregate, GroupAggregate | Группирует строки для GROUP BY | Batches больше 1 или сортировка на диске под GroupAggregate |
Как устроены соединения со стороны запроса, подробно разобрано в статье про виды JOIN, а про сортировку есть материал об ORDER BY.
Пример оптимизации запроса: от Seq Scan к индексу

Вернёмся к заказам клиента 4242. Без индекса запрос шёл 10,779 мс и читал миллион строк. Создаём индекс и запускаем EXPLAIN ANALYZE с буферами:
CREATE INDEX orders_customer_id_idx ON orders (customer_id);
EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE customer_id = 4242;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------
Bitmap Heap Scan on orders (cost=4.59..85.51 rows=21 width=27) (actual time=0.015..0.031 rows=16 loops=1)
Recheck Cond: (customer_id = 4242)
Heap Blocks: exact=16
Buffers: shared hit=16 read=3
-> Bitmap Index Scan on orders_customer_id_idx (cost=0.00..4.58 rows=21 width=0) (actual time=0.012..0.012 rows=16 loops=1)
Index Cond: (customer_id = 4242)
Buffers: shared read=3
Planning:
Buffers: shared hit=19 read=1
Planning Time: 0.152 ms
Execution Time: 0.042 ms
(11 rows)
Execution Time упал с 10,779 до 0,042 мс. Seq Scan сменился парой Bitmap Index Scan и Bitmap Heap Scan, строка Rows Removed by Filter исчезла: лишние заказы больше не читаются.
BUFFERS: кеш или диск
Строка Buffers: shared hit=16 read=3 говорит, откуда пришли блоки данных:
- shared hit: блок уже лежал в кеше PostgreSQL, читать его не пришлось;
- shared read: блока в кеше не было, его запросили у операционной системы;
- temp read и temp written: временные файлы, они появляются, когда сортировке или хешу не хватило памяти.
Индекс только что создан, поэтому три его блока пришлось прочитать. Повторный запуск того же запроса показал Buffers: shared hit=19 без read и Execution Time 0,008 мс.
Отсюда правило: сравнивать «до» и «после» нужно на прогретом кеше. Иначе вы сравните чтение с диска с чтением из памяти и припишете индексу чужую заслугу.
Частые ошибки и что с ними делать
Функция над столбцом выключает индекс
Симптом: индекс по created_at есть, а в плане всё равно Seq Scan. Считаем заказы за 15 марта:
CREATE INDEX orders_created_at_idx ON orders (created_at);
EXPLAIN ANALYZE SELECT count(*) FROM orders WHERE date(created_at) = '2026-03-15';
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
Finalize Aggregate (cost=14724.42..14724.43 rows=1 width=8) (actual time=15.309..16.045 rows=1 loops=1)
-> Gather (cost=14724.21..14724.42 rows=2 width=8) (actual time=15.263..16.042 rows=3 loops=1)
Workers Planned: 2
Workers Launched: 2
-> Partial Aggregate (cost=13724.21..13724.22 rows=1 width=8) (actual time=13.894..13.894 rows=1 loops=3)
-> Parallel Seq Scan on orders (cost=0.00..13719.00 rows=2083 width=0) (actual time=0.013..13.871 rows=531 loops=3)
Filter: (date(created_at) = '2026-03-15'::date)
Rows Removed by Filter: 332802
Planning Time: 0.150 ms
Execution Time: 16.064 ms
(10 rows)
Причина: индекс построен по created_at, а условие сравнивает date(created_at). Для планировщика это другое выражение, и индекс к нему не подходит.
Решение: переписать условие диапазоном, не трогая столбец.
EXPLAIN ANALYZE SELECT count(*) FROM orders
WHERE created_at >= '2026-03-15' AND created_at < '2026-03-16';
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Aggregate (cost=58.81..58.82 rows=1 width=8) (actual time=0.148..0.148 rows=1 loops=1)
-> Index Only Scan using orders_created_at_idx on orders (cost=0.42..54.55 rows=1706 width=0) (actual time=0.059..0.121 rows=1593 loops=1)
Index Cond: ((created_at >= '2026-03-15 00:00:00'::timestamp without time zone) AND (created_at < '2026-03-16 00:00:00'::timestamp without time zone))
Heap Fetches: 0
Planning Time: 0.047 ms
Execution Time: 0.155 ms
(6 rows)
Index Only Scan, 0,155 мс вместо 16,064. Та же ловушка срабатывает с lower(email), извлечением года и месяца и любыми другими вычислениями над столбцом в WHERE. Как выбирать даты диапазоном, разобрано в статье про BETWEEN, а функции дат — в материале об извлечении года и месяца в PostgreSQL.
Sort Method: external merge Disk
Симптом: сортировка пишет на диск, в Buffers появляются temp read и temp written. С этого примера параллельность в сессии выключена первой строкой скрипта, так планы получаются короче.
SET max_parallel_workers_per_gather = 0;
EXPLAIN (ANALYZE, BUFFERS)
SELECT customer_id, amount FROM orders
WHERE created_at >= '2026-01-01' ORDER BY amount;
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------
Sort (cost=62381.61..63354.01 rows=388962 width=10) (actual time=86.377..123.363 rows=390924 loops=1)
Sort Key: amount
Sort Method: external merge Disk: 8056kB
Buffers: shared hit=7478 read=1065, temp read=1007 written=1012
-> Bitmap Heap Scan on orders (cost=7286.88..19617.91 rows=388962 width=10) (actual time=10.348..30.183 rows=390924 loops=1)
Recheck Cond: (created_at >= '2026-01-01 00:00:00'::timestamp without time zone)
Heap Blocks: exact=7469
Buffers: shared hit=7475 read=1065
-> Bitmap Index Scan on orders_created_at_idx (cost=0.00..7189.64 rows=388962 width=0) (actual time=9.848..9.848 rows=390924 loops=1)
Index Cond: (created_at >= '2026-01-01 00:00:00'::timestamp without time zone)
Buffers: shared hit=6 read=1065
Planning:
Buffers: shared hit=20
Planning Time: 0.019 ms
Execution Time: 131.023 ms
(15 rows)
Причина: 390 тысяч строк не поместились в work_mem. По документации, это память для сортировок и хеш-таблиц до того, как PostgreSQL начнёт писать временные файлы, и по умолчанию её 4 МБ.
Решение: поднять work_mem в сессии под конкретный запрос.
SET work_mem = '64MB';
EXPLAIN (ANALYZE, BUFFERS)
SELECT customer_id, amount FROM orders
WHERE created_at >= '2026-01-01' ORDER BY amount;
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------
Sort (cost=55731.61..56704.01 rows=388962 width=10) (actual time=84.741..96.325 rows=390924 loops=1)
Sort Key: amount
Sort Method: quicksort Memory: 24505kB
Buffers: shared hit=8540
-> Bitmap Heap Scan on orders (cost=7286.88..19617.91 rows=388962 width=10) (actual time=8.030..27.348 rows=390924 loops=1)
Recheck Cond: (created_at >= '2026-01-01 00:00:00'::timestamp without time zone)
Heap Blocks: exact=7469
Buffers: shared hit=8540
-> Bitmap Index Scan on orders_created_at_idx (cost=0.00..7189.64 rows=388962 width=0) (actual time=7.544..7.544 rows=390924 loops=1)
Index Cond: (created_at >= '2026-01-01 00:00:00'::timestamp without time zone)
Buffers: shared hit=1071
Planning Time: 0.036 ms
Execution Time: 102.833 ms
(13 rows)
Сортировка ушла в память (quicksort, 24 505 kB), temp из Buffers пропал, время сократилось со 131,023 до 102,833 мс. Глобально work_mem лучше не раздувать: в описании параметра предупреждают, что этот объём может занять каждая операция сортировки или хеширования в каждом сеансе, и общий расход памяти может многократно превзойти настройку.
Оценка rows=1, а по факту 200 000 строк
Симптом: планировщик ждёт одну строку, а получает сотни тысяч. Чтобы показать это на учебной базе, мы выключили для таблицы автоочистку и одной командой вставили 200 000 возвратов со статусом refund.
ALTER TABLE orders SET (autovacuum_enabled = false);
INSERT INTO orders (customer_id, amount, status, created_at)
SELECT 1 + (random() * 49999)::int, 500, 'refund', timestamp '2026-08-25'
FROM generate_series(1, 200000);
EXPLAIN ANALYZE
SELECT c.city, count(*)
FROM orders o JOIN customers c ON c.id = o.customer_id
WHERE o.status = 'refund'
GROUP BY c.city;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------
GroupAggregate (cost=23910.16..23910.18 rows=1 width=20) (actual time=157.261..165.959 rows=5 loops=1)
Group Key: c.city
-> Sort (cost=23910.16..23910.16 rows=1 width=12) (actual time=155.111..161.061 rows=200000 loops=1)
Sort Key: c.city
Sort Method: external merge Disk: 3184kB
-> Nested Loop (cost=0.29..23910.15 rows=1 width=12) (actual time=26.018..142.330 rows=200000 loops=1)
-> Seq Scan on orders o (cost=0.00..23901.84 rows=1 width=4) (actual time=26.012..34.701 rows=200000 loops=1)
Filter: (status = 'refund'::text)
Rows Removed by Filter: 1000000
-> Index Scan using customers_pkey on customers c (cost=0.29..8.31 rows=1 width=16) (actual time=0.000..0.000 rows=1 loops=200000)
Index Cond: (id = o.customer_id)
Planning Time: 0.098 ms
Execution Time: 166.497 ms
(13 rows)
Причина: статистика устарела. Планировщик уверен, что статуса refund в таблице нет, и выбирает вложенный цикл. Внутренний Index Scan в итоге выполняется 200 000 раз (loops=200000), а сортировка уходит на диск.
Решение: обновить статистику командой ANALYZE.
ANALYZE orders;
EXPLAIN ANALYZE
SELECT c.city, count(*)
FROM orders o JOIN customers c ON c.id = o.customer_id
WHERE o.status = 'refund'
GROUP BY c.city;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------
HashAggregate (cost=27027.48..27027.53 rows=5 width=20) (actual time=61.075..61.077 rows=5 loops=1)
Group Key: c.city
Batches: 1 Memory Usage: 24kB
-> Hash Join (cost=1542.00..26014.08 rows=202680 width=12) (actual time=29.764..51.418 rows=200000 loops=1)
Hash Cond: (o.customer_id = c.id)
-> Seq Scan on orders o (cost=0.00..23940.00 rows=202680 width=4) (actual time=26.144..33.587 rows=200000 loops=1)
Filter: (status = 'refund'::text)
Rows Removed by Filter: 1000000
-> Hash (cost=917.00..917.00 rows=50000 width=16) (actual time=3.606..3.607 rows=50000 loops=1)
Buckets: 65536 Batches: 1 Memory Usage: 2973kB
-> Seq Scan on customers c (cost=0.00..917.00 rows=50000 width=16) (actual time=0.005..1.651 rows=50000 loops=1)
Planning Time: 0.206 ms
Execution Time: 61.096 ms
(13 rows)
Оценка стала 202 680 строк вместо одной, вложенный цикл сменился на Hash Join, запрос ускорился со 166,497 до 61,096 мс.
Обычно статистику обновляет автоочистка, и в описании команды ANALYZE так и написано: демон запускает анализ, когда таблица заполняется данными и по мере её изменений. Но после массовой загрузки лучше не ждать и выполнить ANALYZE сразу.
Ещё три ошибки, которые встречаются часто
- EXPLAIN ANALYZE на UPDATE или DELETE изменил данные. Команда выполняет оператор целиком. Решение: BEGIN, EXPLAIN ANALYZE, ROLLBACK, как в первом разделе.
- Первый прогон сравнили со вторым. В первом блоки читаются с диска, во втором берутся из кеша. Решение: запускать оба варианта запроса по два раза и сравнивать повторные прогоны.
- Под EXPLAIN ANALYZE запрос идёт дольше, чем обычно. Замер времени каждого узла сам стоит ресурсов: в описании параметра TIMING отмечено, что постоянное чтение системных часов может значительно замедлить запрос. Решение:
EXPLAIN (ANALYZE, TIMING OFF), если вам нужны только фактические rows.
Визуализаторы плана: когда текст уже не читается

План с десятками узлов удобнее разбирать в визуализаторе. Вы вставляете вывод EXPLAIN ANALYZE и получаете дерево, где тяжёлые узлы подсвечены.
| Сервис | Чем удобен |
|---|---|
| explain.tensor.ru | Интерфейс на русском, есть отметка «не публиковать в архиве» |
| explain.dalibo.com | Принимает текст и JSON, есть автономная версия в одном HTML-файле, которая работает без отправки плана в интернет |
В плане видны имена таблиц и значения из WHERE. Если план снят с рабочей базы, перед отправкой проверьте настройки приватности сервиса. Для dalibo вывод лучше получать в JSON: EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) SELECT …;.
EXPLAIN ANALYZE в MySQL
В MySQL команда тоже есть: её добавили в версии 8.0.18. Она выполняет запрос и показывает время и число строк по каждому шагу, но вывод устроен иначе: дерево итераторов в формате TREE вместо узлов PostgreSQL.
Логика чтения та же: найти шаг, где копится время, и сравнить ожидаемые строки с фактическими. Про сам SELECT в MySQL есть отдельная статья с примерами.
Где освоить PostgreSQL системно
Прочитать один план вы теперь сможете. Чтобы оптимизация стала рабочим навыком, нужны индексы разных типов, транзакции, блокировки и настройка сервера, а это уже программа курса. Вот курсы по PostgreSQL из нашего каталога, все варианты собраны на странице курсов PostgreSQL.
| Курс | Школа | Стоимость со скидкой | В рассрочку | Длительность | Обзор курса от Checkroi |
|---|---|---|---|---|---|
| PostgreSQL для начинающих Перейти на сайт курса | 24 813 ₽ | - | 1 месяц | Обзор курса | |
| PostgreSQL База Перейти на сайт курса | 30 000 ₽ | 7500 ₽/мес. | 2 года | Обзор курса | |
| Профессия «Аналитик данных с нуля до middle» Перейти на сайт курса | 145 600 ₽ | 6066 ₽/мес. | 12 месяцев | Обзор курса | |
| Профессия «Python-разработчик» Перейти на сайт курса | 157 335 ₽ | 5987 ₽/мес. | 10 месяцев | Обзор курса | |
| Профессия «Data Scientist PRO» Перейти на сайт курса | 224 595 ₽ | 7245 ₽/мес. | 12 месяцев | Обзор курса |
Больше программ — в полном каталоге курсов по PostgreSQL
Если думаете о профессии вокруг баз данных, посмотрите, кто такой администратор баз данных и как стать SQL-разработчиком.




