EXPLAIN ANALYZE в PostgreSQL: как читать план запроса на примерах

EXPLAIN показывает план запроса и оценки планировщика, EXPLAIN ANALYZE выполняет запрос и добавляет фактическое время и число строк по каждому узлу.

Разбираем вывод построчно на учебной базе в миллион заказов: как читать cost, rows и loops, что значат Seq Scan и Bitmap Heap Scan и как найти причину медленного запроса.

Статью написал:
Ваня Буявец, продюсер, основатель Checkroi
Ваня Буявец
Основатель Checkroi, продюсер, эксперт в выборе онлайн-курсов
Все 3286 статей автора Подписаться на Телеграм-канал
Одобрено экспертом:
Наташа Буявец, основатель Checkroi, эксперт по онлайн-курсам
Наташа Буявец
Основательница Checkroi, продюсер Youtube-каналов, эксперт по онлайн-курсам
Все 3940 экспертных мнений Подписаться на Телеграм-канал
Обложка: EXPLAIN ANALYZE в PostgreSQL: как читать план запроса на примерах

EXPLAIN показывает план, который PostgreSQL выбрал для запроса, и прогноз планировщика: сколько строк он ждёт от каждого шага и во сколько этот шаг обойдётся. EXPLAIN ANALYZE запрос выполняет и дописывает к прогнозу факт: время каждого узла в миллисекундах и реальное число строк.

Читать план нужно от самых вложенных строк к верхней. Ищите узел, на котором копится время, и сравнивайте у него ожидаемые rows с фактическими: сильное расхождение почти всегда и есть причина медленного запроса.

Если SQL для вас пока новый, начните с разбора языка SQL и статьи о том, как устроена СУБД. Все планы ниже настоящие: это вывод psql на учебной базе с миллионом заказов, скрипт для неё есть в статье, так что любой пример можно повторить у себя. А если работа с базами данных нужна вам как профессия, посмотрите курсы по PostgreSQL в нашем каталоге.

Чем 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: пошаговая инструкция

  1. Откройте клиент, в котором выполняете запросы: psql, DBeaver с подключением к PostgreSQL или pgAdmin. EXPLAIN это обычная SQL-команда, настраивать для неё ничего не нужно.
  2. Посмотрите план без выполнения: EXPLAIN SELECT …;. Если запрос долгий или что-то меняет, на этом шаге можно остановиться.
  3. Запустите EXPLAIN (ANALYZE, BUFFERS) SELECT …;. BUFFERS покажет, сколько блоков данных нашлось в кеше и сколько пришлось читать. В PostgreSQL 18 этот вывод включается при ANALYZE автоматически, в 17-й и более ранних версиях параметр пишут явно.
  4. Выполните ту же команду второй раз и сравнивайте второй прогон: первый обычно медленнее, потому что данных ещё нет в кеше.
  5. Найдите узел с самым большим 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.

CheckroiCheckroiПодборка курсов по PostgreSQL157 курсов • 27 школСравните цены, школы, программу и найдите выгодные предложения по обучениюСравнить→

Пример оптимизации запроса: от 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.
Ваня БуявецКанал основателя Checkroi Вани БуявцаЗабирайте промпты и обучение по нейросетям в моём Телеграм-каналеБольше 3 800 человек уже применяют Claude Code, ChatGPT и другие нейросети в работе, учёбе, бизнесе и жизниПерейти в канал

Визуализаторы плана: когда текст уже не читается

Дерево плана запроса на экране с подсвеченным тяжёлым узлом

План с десятками узлов удобнее разбирать в визуализаторе. Вы вставляете вывод 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 для начинающих
Перейти на сайт курса
SkillboxSkillbox24 813 ₽ - 1 месяцОбзор курса
PostgreSQL База
Перейти на сайт курса
Слёрм (Slurm)Слёрм30 000 ₽7500 ₽/мес.2 годаОбзор курса
Профессия «Аналитик данных с нуля до middle»
Перейти на сайт курса
НетологияНетология145 600 ₽6066 ₽/мес.12 месяцевОбзор курса
Профессия «Python-разработчик»
Перейти на сайт курса
SkillboxSkillbox157 335 ₽5987 ₽/мес.10 месяцевОбзор курса
Профессия «Data Scientist PRO»
Перейти на сайт курса
SkillboxSkillbox224 595 ₽7245 ₽/мес.12 месяцевОбзор курса

Больше программ — в полном каталоге курсов по PostgreSQL

Если думаете о профессии вокруг баз данных, посмотрите, кто такой администратор баз данных и как стать SQL-разработчиком.

Часто задаваемые вопросы

Чем EXPLAIN отличается от EXPLAIN ANALYZE?

EXPLAIN только строит план и показывает оценки планировщика: стоимость, ожидаемое число строк и их ширину. EXPLAIN ANALYZE выполняет запрос и дописывает к оценкам фактическое время каждого узла в миллисекундах, реальное число строк и количество проходов loops.

Выполняет ли EXPLAIN ANALYZE запрос на самом деле?

Да. Результат SELECT отбрасывается, но INSERT, UPDATE и DELETE меняют данные как обычно. Чтобы посмотреть план такого запроса без последствий, выполните его в транзакции: BEGIN; EXPLAIN ANALYZE …; ROLLBACK;.

Что такое cost в плане запроса PostgreSQL?

Это оценка стоимости узла в условных единицах планировщика: первое число до выдачи первой строки, второе до последней. За единицу традиционно принимают чтение одной страницы с диска, поэтому cost нельзя перевести в миллисекунды, а сравнивать имеет смысл узлы внутри одного плана.

Seq Scan в плане всегда плохо?

Нет. На маленькой таблице или когда запросу нужна большая часть строк, чтение подряд обходится дешевле прыжков по индексу. Тревожный признак другой: Seq Scan с большим Rows Removed by Filter, который отдаёт всего несколько строк из миллиона.

Что делает команда ANALYZE в PostgreSQL без EXPLAIN?

Она собирает статистику о содержимом таблицы и сохраняет её в системном каталоге pg_statistic, а планировщик по этой статистике оценивает число строк. Обычно ANALYZE запускает автоочистка, но после массовой загрузки данных его стоит выполнить вручную.

Как понять по плану, почему запрос медленный?

Найдите узел с самым большим actual time, не забывая умножать его на loops, и сравните у него ожидаемые rows с фактическими. Расхождение в сотни раз обычно означает устаревшую статистику, Sort Method: external merge Disk говорит о нехватке work_mem, а Seq Scan при индексе часто вызван функцией над столбцом в WHERE.

Читайте Checkroi первым в Google
Добавьте Checkroi в избранные источники — и наши разборы курсов и обзоры школ будут показываться выше в вашей выдаче Google.
Оставить комментарий
0 комментариев
Форма комментария

Оставьте комментарий

Напишите, что думаете. Нам важно ваше мнение!