Hvordan bruger du EXPLAIN og EXPLAIN ANALYZE?

Question

Accepted Answer

**`EXPLAIN`** viser PostgreSQL's **query execution plan** — hvordan den vil køre en query (hvilke scans, joins, indexes). **`EXPLAIN ANALYZE`** kører faktisk queryen og viser real timing og row counts. Dette er de primære værktøjer til at diagnosticere langsomme queries.

## EXPLAIN — planen (uden at køre)

```sql
EXPLAIN SELECT * FROM orders WHERE customer_id = 5;
-- shows the PLAN: scan type, estimated cost, estimated rows — but doesn't run it
```

## EXPLAIN ANALYZE — planen med REAL execution data

```sql
EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 5;
-- ACTUALLY runs it → shows REAL time, ACTUAL rows, and where time was spent
EXPLAIN (ANALYZE, BUFFERS) SELECT ...;   -- also shows buffer/cache usage
```

`EXPLAIN ANALYZE` er mere brugbar, fordi den viser *faktisk* performance (real timing, real row counts) — hvilket afslørar hvor queryen virkelig bruger tid, ikke kun estimater.

## Læsning af planen: de vigtigste ting at se efter

```text
SCAN TYPES (most important):
  Seq Scan      → FULL TABLE SCAN (reads every row) — slow on big tables, often the problem
  Index Scan    → uses an index to find rows — fast
  Index Only Scan → reads only the index (doesn't touch the table) — fastest
  Bitmap Scan   → for combining indexes / many matches

WATCH FOR:
  ✗ Seq Scan on a large table being filtered → likely a MISSING INDEX
  ✗ Estimated rows VERY different from actual rows → outdated statistics (run ANALYZE)
  ✗ Expensive joins, sorts spilling to disk ("external merge")
  ✗ The node with the highest actual time = the bottleneck
```

## Et diagnostisk eksempel

```sql
EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 5;
-- "Seq Scan on orders ... actual time=120ms" → a full scan, slow

CREATE INDEX idx_orders_customer ON orders(customer_id);

EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 5;
-- "Index Scan using idx_orders_customer ... actual time=0.05ms" → fixed!
```

## Hvorfor det betyder noget

`EXPLAIN` og `EXPLAIN ANALYZE` er vigtige, primære værktøjer til at **diagnosticere og optimere langsomme queries** i PostgreSQL — query performance er kritisk for applikationer, og disse værktøjer er hvordan du forstår *hvorfor* en query er langsom og verificerer rettelser, så at mestre dem er vigtig senior-level viden for database performance work.

Den fundamentale værdi er **synlighed ind i execution planen**: i stedet for at gætte hvorfor en query er langsom, afslører `EXPLAIN ANALYZE` (som kører queryen og viser real timing og row counts) præcis hvordan Postgres udfører den og hvor tiden bruges.

De vigtigste ting at genkende er **scan typerne** — især at identificere en **`Seq Scan` (full table scan)** på en stor filtreret tabel, som normalt indikerer et **manglende index** (det mest almindelige og impactfuldt query performance problem), versus en hurtig **`Index Scan`**.

At forstå hvordan man læser planen (scan typer, sammenligning af estimeret versus faktiske rows for at opdage forældet statistik, identifikation af den mest omkostningstunge node som flaskehalsen, overvågning af disk-spilling sorts) er nøglefærdigheden for query optimering.

Diagnostisk workflow — kør `EXPLAIN ANALYZE`, identificer flaskehalsen (ofte en Seq Scan), anvend rettelsen (normalt tilføjelse af et index), og kør igen for at verificere — er standardtilgangen, måling-driven tilgang til query optimering.

Since langsomme queries er en ledende årsag til dårlig database performance, og siden `EXPLAIN`/`EXPLAIN ANALYZE` er *de* værktøjer til at diagnosticere dem (afsløring af manglende indexes, dårlige planer og flaskehalse) og verificering af optimeringer, er at mestre dem vigtig, høj-værdigt viden for PostgreSQL performance — det er hvordan du systematisk finder og reparerer langsomme queries i stedet for at gætte, en kritisk færdighed for performante databaser og et almindeligt emne for database optimization work.