---
title: "PostgreSQL 19 vs. 18: Natives REPACK, pg_plan_advice, Graph-Mythos & Upgrade-Leitfaden"
description: "Ausführlicher Technik-Vergleich PostgreSQL 19 vs. 18: natives REPACK (CONCURRENTLY), pg_plan_advice für stabile Query-Pläne, ON CONFLICT DO SELECT, Auto-Scaling Async I/O, warum SQL/PGQ-Graphabfragen vor Beta 4 entfernt wurden und alle pg_upgrade-Blocker."
author: Aleksei Aleinikov
date: 2026-11-20
lang: de
tags: [postgresql 19 vs 18, postgresql 19, postgresql 19 features, postgresql repack concurrently, pg_plan_advice, on conflict do select, postgresql 19 upgrade]
canonical: https://www.alekseialeinikov.com/de/blog/topics/data/postgresql-19-vs-18-features-performance-upgrade-leitfaden
source: alekseialeinikov.com
---

# PostgreSQL 19 vs. 18: Natives REPACK, pg_plan_advice, Graph-Mythos & Upgrade-Leitfaden

Während **PostgreSQL 18** mit dem asynchronen I/O-Subsystem (`io_uring` und Worker-Threads) vor allem die rohe Storage-Geschwindigkeit verbessert hat, liefert **PostgreSQL 19** genau die Betriebs- und Entwickler-Features, auf die DBA- und Backend-Teams seit Jahren gewartet haben.

Statt für Online-Wartung externe Extensions pflegen zu müssen oder bei jedem Major-Upgrade Plan-Regressionen zu fürchten, bringt PostgreSQL 19 **natives `REPACK (CONCURRENTLY)`**, **`pg_plan_advice`**, **`INSERT ... ON CONFLICT DO SELECT`**, **paralleles Index-Autovacuum** und **automatisch skalierendes Async I/O** direkt im Core – zusammen mit einigen **neuen Defaults und `pg_upgrade`-Blockern**, die eine blind übernommene `postgresql.conf` aus v18 sofort stoppen.

![PostgreSQL 19 vs. 18 Titelbild: Facettierter kobaltblauer PostgreSQL-Elefant aus optischem Glas auf einem zweistufigen Edelstahl-Sockel im hellen Tageslichtstudio.](https://media.alekseialeinikov.com/data/7b3e9a4c1d8f/cover-1200.9b8409540c5d46bc.webp)

> [!NOTE]
> **Gegen die offiziellen PostgreSQL-19.0-Release-Notes geprüft.** Alle GUC-Namen, SQL-Erweiterungen, zurückgezogenen Beta-Features (`SQL/PGQ`) und `pg_upgrade`-Blocker stammen direkt aus den [offiziellen Release Notes zu PostgreSQL 19.0](https://www.postgresql.org/docs/release/19.0/) und den Ankündigungen der Core-Entwickler.

> [!KEY]
> **Das kurze Urteil: Lohnt sich das Upgrade von 18 auf 19?** **Ja** – besonders für schreibintensive OLTP-Cluster mit Tabellen-Bloat (`REPACK (CONCURRENTLY)` + paralleles Index-Autovacuum) und hohe Concurrency (`ON CONFLICT DO SELECT`). Prüfe jedoch **vorab deine `postgresql.conf`**: Der alte v18-Parameter `io_workers` führt beim Start zu `FATAL`, `jit` steht jetzt auf `off` – und **SQL/PGQ-Graphabfragen haben es doch nicht in den Release geschafft**.

## PostgreSQL 19 vs. 18 im direkten Überblick

Die meisten Upgrade-Entscheidungen hängen davon ab, ob der Mehrwert ein `pg_upgrade`-Wartungsfenster rechtfertigt. Im direkten Vergleich zu [PostgreSQL 18](https://www.alekseialeinikov.com/de/blog/topics/data/postgresql-in-docker-produktion) punktet Version 19 vor allem bei Betrieb, SQL-Komfort und Defaults:

| Bereich | **PostgreSQL 18** | **PostgreSQL 19** | **Auswirkung in Produktion** |
|---|---|---|---|
| **Async I/O (AIO)** | Festes `io_workers` (`io_uring` / Worker, ~3× schnellere Cold-Scans) | Auto-Scaling `io_min_workers` / `io_max_workers` + `EXPLAIN (ANALYZE, IO)` | Passt sich Cloud-Storage-Lastspitzen an; **altes `io_workers` entfernt** |
| **Online-Komprimierung** | `VACUUM FULL` (blockiert R/W) oder externes `pg_repack` | Natives **`REPACK`** & **`REPACK (CONCURRENTLY)`** | Bloat-Bereinigung ohne Downtime direkt im Core |
| **Autovacuum** | Sequenzielle Index-Bereinigung pro Tabelle | **Paralleles Index-Autovacuum** + gewichtetes Bloat-/Alters-Scoring | Weniger Wartungsrückstau auf großen Multi-Index-Tabellen |
| **Plan-Stabilität** | Externes `pg_hint_plan` oder SQL-Umbau | Core **`pg_plan_advice`** + **`pg_stash_advice`** | `JOIN_ORDER` / `HASH_JOIN` gezielt fixieren ohne Code-Deploy |
| **Upsert / Get-or-Create** | `ON CONFLICT DO NOTHING` + zweites `SELECT` | **`INSERT ... ON CONFLICT DO SELECT [FOR UPDATE] RETURNING`** | Atomar in einem Round-Trip, weniger Race Conditions |
| **JIT-Standard** | `jit = on` (seit v12) | **`jit = off`** | Verhindert zufällige JIT-Latenzspitzen bei kurzem OLTP |
| **TOAST-Kompression** | `pglz` Standard | **`lz4` Standard** (`default_toast_compression`) | Schnelleres Packen/Entpacken von JSONB und Text |
| **Lock-Diagnose** | `log_lock_waits = off` | **`log_lock_waits = on`** | Sofortige Sichtbarkeit bei Lock-Wartezeiten > 1 s |
| **Logical Replication** | Neustart nötig für `wal_level`-Wechsel | Aktivierung aus `wal_level = replica` **ohne Neustart** + Sequences | Zero-Downtime-CDC und sauberer Failover |

## 1. Natives `REPACK (CONCURRENTLY)`: Das Ende von `pg_repack`?

Jahrelang gab es bei massivem Table Bloat nur zwei unbequeme Wege: `VACUUM FULL` / `CLUSTER` (sperrt mit `ACCESS EXCLUSIVE` sämtliche Lese- und Schreibzugriffe) oder externe Tools wie `pg_repack` / `pg_squeeze`.

PostgreSQL 19 integriert die Online-Komprimierung nativ über **`REPACK`** und **`REPACK (CONCURRENTLY)`**:

```sql
-- Online-Komprimierung ohne Blockade laufender Reads oder Writes
REPACK (CONCURRENTLY) orders;

-- Tabelle physisch entlang eines Index neu ordnen (ersetzt blockierendes CLUSTER)
REPACK (CONCURRENTLY) orders USING INDEX orders_created_at_idx;
```

![Sperr-Zeitachse im Vergleich zwischen VACUUM FULL, pg_repack und PostgreSQL 19 nativem REPACK (CONCURRENTLY): VACUUM FULL blockiert alles per ACCESS EXCLUSIVE, während REPACK (CONCURRENTLY) unter SHARE UPDATE EXCLUSIVE kopiert, parallele Writes per temporärem Logical-Replication-Slot mitnimmt und nur für den kurzen Dateitausch exklusiv sperrt.](https://media.alekseialeinikov.com/data/7b3e9a4c1d8f/postgresql-19-repack-locks-1200.a88b100f215b0cfd.webp)

Unter der Haube arbeitet `REPACK (CONCURRENTLY)` sauber nach dem Online-Migrations-Muster:
1. Setzt nur ein leichtes **`SHARE UPDATE EXCLUSIVE`** Lock, sodass `SELECT`, `INSERT`, `UPDATE` und `DELETE` normal weiterlaufen.
2. Nutzt einen **temporären Logical-Replication-Slot**, um Änderungen während der Kopierphase aufzufangen.
3. Hält **`ACCESS EXCLUSIVE`** nur für den Sekundenbruchteil des finalen Dateitauschs.

Zusammen mit dem **parallelen Index-Autovacuum** und dem neuen **gewichteten Autovacuum-Scoring** (Tabellenalter, Bloat-Anteil, Zeit seit dem letzten Lauf) bleiben große Tabellen deutlich länger sauber – besonders in Kombination mit der passenden [Wahl der PostgreSQL-Indextypen (`B-tree`, `GIN`, `BRIN`)](https://www.alekseialeinikov.com/de/blog/topics/data/postgresql-indizes-welcher-typ-wann-benchmark).

## 2. `pg_plan_advice`: Stabile Ausführungspläne ohne Code-Änderung

Jeder DBA kennt das Risiko nach einem Major-Upgrade: 99 % der Queries werden schneller, aber eine zentrale Abfrage kippt nach `ANALYZE` vom `Hash Join` in einen Nested Loop und legt die CPU lahm.

Mit **`pg_plan_advice`** und **`pg_stash_advice`** liefert PostgreSQL 19 erstmals offizielle Core-Module für Plan-Stabilität. Über Query-IDs lassen sich gezielte Plan-Vorgaben (`JOIN_ORDER`, `HASH_JOIN`, `SEQ_SCAN`, `INDEX_SCAN`) hinterlegen, ohne ORM-Queries im Anwendungscode umschreiben zu müssen.

## 3. `INSERT ... ON CONFLICT DO SELECT`: Atomares Get-or-Create

Beim klassischen *Get-or-Create*-Muster musste man bislang entweder `ON CONFLICT DO NOTHING` mit einem zweiten `SELECT` kombinieren oder Savepoints gegen `unique_violation` nutzen.

PostgreSQL 19 löst das mit **`INSERT ... ON CONFLICT DO SELECT`** nativ in einem Statement:

```sql
INSERT INTO api_clients (external_id, tier)
VALUES ('tenant-42', 'pro')
ON CONFLICT (external_id) DO SELECT FOR UPDATE
RETURNING id, tier, created_at;
```

Das spart Netzwerk-Round-Trips, verhindert Race Conditions und vermeidet unnötigen Subtransaktions-Overhead unter hoher Last.

Zusätzlich vereinfacht PostgreSQL 19 JSON-Exporte mit **`COPY ... TO ... (FORMAT JSON)`** (wahlweise als NDJSON-Stream oder per `FORCE_ARRAY` als einzelnes JSON-Array) und macht `row_to_json()`-Workarounds überflüssig:

```sql
-- Zeilen als NDJSON streamen oder mit FORCE_ARRAY als JSON-Array ausgeben
COPY (SELECT id, tier FROM api_clients) TO STDOUT (FORMAT JSON, FORCE_ARRAY);
```

*(Hinweis: `FORMAT JSON` gilt vorerst nur für `COPY TO`, noch nicht für `COPY FROM`.)*

## 4. Neue Produktions-Defaults: `jit = off`, `lz4`-TOAST & Live Logical Replication

Mehrere stille Standard-Änderungen in PostgreSQL 19 wirken sich direkt auf Latenz, CPU und Betrieb aus:

![Vergleich der Standardwerte und Betriebsänderungen zwischen PostgreSQL 18 und PostgreSQL 19: Auto-Scaling-AIO-Worker, jit standardmäßig off, LZ4 als TOAST-Standard, aktiviertes log_lock_waits, paralleles Index-Autovacuum und Logical Replication ohne Neustart.](https://media.alekseialeinikov.com/data/7b3e9a4c1d8f/postgresql-19-vs-18-defaults-1200.3a1a1e29fdc47b39.webp)

- **`jit = off` als Standard:** Seit v12 aktiv, führte LLVM-JIT bei kurzen OLTP-Queries oft zu Latenzspitzen statt Tempo. Der neue Standard schützt OLTP-Systeme – **wer schwere OLAP-Aggregationen fährt, sollte `jit = on` nach dem Upgrade gezielt testen**.
- **`default_toast_compression = lz4`:** Neue TOAST-Daten (`jsonb`, lange Texte) nutzen nun `LZ4` statt `pglz` und entlasten die CPU bei minimalem Kompressionsunterschied. Bestehende Zeilen bleiben bis zum Update unverändert.
- **`log_lock_waits = on` & prozessspezifisches `log_min_messages`:** Lock-Wartezeiten über `deadlock_timeout` (1 Sekunde) landen nun automatisch im Log, und `log_min_messages` akzeptiert kommaseparierte Prozess-Level (etwa getrennt für `checkpointer` und normale `backend`-Prozesse).
- **Logical Replication ohne Neustart + Sequences:** Aus `wal_level = replica` lässt sich Logical Replication im laufenden Betrieb aktivieren – inklusive **logischer Replikation von Sequence-Werten**.
- **Schnellere Foreign-Key-Prüfungen & skalierendes AIO:** Schreibintensive Foreign-Key-Workloads laufen spürbar schneller, `io_min_workers`/`io_max_workers` skalieren Async-I/O-Worker automatisch und `EXPLAIN (ANALYZE, IO)` zeigt exakte I/O-Werte.

## 5. Der Graph-Mythos: Warum SQL/PGQ wieder aus PostgreSQL 19 flog

Wer nach PostgreSQL-19-Features sucht, stößt häufig auf frühe Beta-Artikel zu `CREATE PROPERTY GRAPH` und `GRAPH_TABLE` (`SQL/PGQ` aus SQL:2023).

**Die Faktenlage:** Zwar war SQL/PGQ in frühen Betas enthalten, doch **vor Beta 4 zogen die Core-Committer rund 47 Commits komplett zurück**, um Katalog-Komplexität und langfristige Standard-Fallen zu vermeiden.

**SQL/PGQ ist in PostgreSQL 19.0 nicht enthalten** und frühestens für **PostgreSQL 20** vorgesehen. Wer heute Graph-Abfragen braucht, greift weiterhin zu Apache AGE oder prüft anhand unseres Leitfadens [Brauchst du eine Graphdatenbank?](https://www.alekseialeinikov.com/de/blog/topics/data/brauchst-du-eine-graphdatenbank-2026), ob ein dediziertes System sinnvoll ist.

## Checkliste vor `pg_upgrade` (18 → 19): Blocker & Breaking Changes

Bevor du `pg_upgrade` auf einem v18-Cluster startest, solltest du diese sechs Punkte abarbeiten:

![Vorab-Checkliste für das Upgrade von PostgreSQL 18 auf PostgreSQL 19: entfernte Parameter io_workers und escape_string_warning löschen, alte btree_gist inet/cidr-Indizes ersetzen, Objekt-Namen auf CR/LF prüfen, Dumps wegen erzwungenem standard_conforming_strings neu ziehen und MD5/UDP-RADIUS ablösen.](https://media.alekseialeinikov.com/data/7b3e9a4c1d8f/postgresql-19-upgrade-checklist-1200.1355e0c24ea6b1a2.webp)

1. **`io_workers` und `escape_string_warning` aus `postgresql.conf` entfernen:** `io_workers` aus v18 wurde durch `io_min_workers`/`io_max_workers` ersetzt. Bleiben die alten Parameter stehen, bricht der Start mit **`FATAL: configuration file contains errors`** ab.
2. **Alte `btree_gist`-Indizes auf `inet`/`cidr` prüfen:** `pg_upgrade` stoppt, wenn noch Indizes mit alten `gist_inet_ops`- oder `gist_cidr_ops`-Operatorklassen existieren. Vorher auf die eingebauten Operatorklassen umstellen.
3. **Keine `\r`/`\n` in Datenbank- oder Rollennamen:** Steuerzeichen in Namen werden blockiert (ebenso wurde `MULE_INTERNAL` entfernt).
4. **Dumps mit v19-Tools aktualisieren:** `standard_conforming_strings` ist fest auf `on` erzwungen; ältere Dumps mit `off` schlagen beim Einspielen fehl. Bei `pg_trgm`/`tsvector` ggf. Locale-Provider prüfen und reindizieren.
5. **OLAP-Performance mit `jit = off` testen:** Bei analytischen Workloads `jit = on` gezielt pro Datenbank oder Rolle wieder setzen.
6. **Security-Aufräumen (`MD5` & `RADIUS`):** Erfolgreiche `MD5`-Logins erzeugen nun Server-Warnungen (`md5_password_warnings`, zusätzlich gibt es `password_expiration_warning_threshold` mit 7 Tagen) – auf `SCRAM-SHA-256` migrieren. **UDP-`RADIUS` wurde komplett gestrichen.**

## Wann sich das Upgrade jetzt lohnt

- **Früh umsteigen**, wenn du schreibintensive OLTP-Cluster unter v17/v18 (oder Container-Setups wie [PostgreSQL in Docker für Produktion](https://www.alekseialeinikov.com/de/blog/topics/data/postgresql-in-docker-produktion)) betreibst, regelmäßig mit Bloat kämpfst (`REPACK (CONCURRENTLY)`) oder viele Get-or-Create-Upserts (`ON CONFLICT DO SELECT`) fährst.
- **Auf `19.1` / `19.2` warten** bei hochkonservativen Core-Systemen – und die Zeit nutzen, um `io_workers` aus Terraform/Helm-Templates zu entfernen und `MD5`-Rollen auf `SCRAM-SHA-256` umzustellen.
