PostgreSQL 19 releases: online table repair and in-core plan control anchor a late, deliberate update
The PostgreSQL Global Development Group shipped PostgreSQL 19 today. It landed about six weeks behind the project's usual mid-October window and leaner than its beta cycle had led you to expect. Several ambitious features were pulled late in the process. What remains is a deliberate "reliability at scale" release, built around non-blocking table repair, in-core query-plan control, sharper replication, and a batch of performance gains you get without touching code.
The first release candidate dropped October 15. RC2 was slated for November 12. Most major PostgreSQL releases over the past decade arrived between mid-September and mid-October, so this lag is noticeable.
Between feature freeze on April 8 and the Beta 4 checkpoint, committers yanked a heavy list: SQL/PGQ property graph queries, online partition merge and split, toggling data checksums without restarting the cluster, temporal row-versioned operations, and GROUP BY ALL.
The community's explanation, laid out by committers Peter Eisentraut and Robert Haas, centers on AI-assisted testing. Haas, a committer at Databricks, documented the situation in a blog post titled plainly "Postgres 19 is late, and it's AI's fault." He found that back-patch commits rose more than 60% year over year, and back-patching to at least one prior release jumped 74% in a single year. What actually shifted was how many mistakes got caught and reported after the fact, not the number of new commits going in.
Eisentraut framed it as layered pressures: architectural problems in a few features, AI review surfacing more edge cases, and senior developers burning time on security work that would otherwise have seen beta review. He drew a sharp line between "faster AI-assisted discovery" and the assumption that the offending code was written by AI. Keep in mind that the August 2026 patch cycle for PostgreSQL 18 addressed 28 CVEs, a stark jump from the couple this kind of release historically averaged.
Net effect? A release the community explicitly chose for reliability over breadth. Bytebase called the move "the right call."
What actually shipped
Perhaps the most operator-friendly addition is REPACK, which folds the long-standing, confusingly named VACUUM FULL and CLUSTER into a single in-core tool. Both rewrote a table to reclaim bloat or reorder rows to match an index, and both demanded an ACCESS EXCLUSIVE lock that shut down reads and writes until completion. REPACK replaces both; the originals remain for compatibility. Its CONCURRENTLY option drops the exclusive lock. Reads and writes keep flowing against the original heap while a new version builds, and the swap happens at the end. Concurrent changes get captured via logical decoding and replayed before completion.
REPACK TABLE my_table; -- blocking rewrite, replaces VACUUM FULL / CLUSTER REPACK TABLE my_table CONCURRENTLY; -- non-blocking: reads and writes continue REPACK INDEX my_index CONCURRENTLY;
The concurrent variant consumes a replication slot, so pin the new max_repack_replication_slots setting to a sane upper bound and watch slot lag on long runs. It needs a primary key or index-based replica identity, skips partitioned parents, and builds a full temporary copy of the table. Budget roughly twice the table's disk footprint while it runs. The feature pulled more bug fixes than any other during beta, so treat the first few minor releases as your stabilization window before running it against production heaps.
PostgreSQL 19 also brings planner control into core, addressing a familiar frustration: the planner is excellent on average and occasionally picks an unacceptable plan for a long-tail query. Skewed data, stale statistics, and many-table joins can send it down a bad path. Until now the workarounds lived outside core: pg_hint_plan, application-level SET flags, and third-party plan-locking tools.
Two pieces make it work. pg_plan_advice captures a plan choice and exposes a hook for injecting advice at planning time. pg_stash_advice persists those strings keyed by stash name and query ID in shared memory, applying them automatically across all sessions running the matching query ID after a single write.
Bytebase's take is that this is plan stability without touching the application, best used as a scalpel for a small set of queries with known regressions rather than across an entire workload. Applying advice carries a cost even when it changes nothing. It also lays the groundwork for a future SQL Plan Management module, a feature Oracle and SQL Server users take for granted.
Applications that fan reads out to replicas have a long-known gap: data written to the primary may not yet be visible on a standby. WAIT FOR LSN lets a session on a standby hold until it has replayed the WAL to a specific log sequence number before running the query. Read-your-writes consistency across systems, finally.
A few logical-replication pain points get resolved too. Enabling logical replication no longer needs a restart: when wal_level is replica, the server auto-raises the effective WAL level when the first slot is created. A new read-only effective_wal_level setting reports what's actually running. Logical replication can now also replicate the sequences behind SERIAL and IDENTITY columns via ALL SEQUENCES on CREATE PUBLICATION and a new REFRESH SEQUENCES subcommand. It only syncs when you run REFRESH SEQUENCES, so drop it into your cutover runbook right before promoting a subscriber. Also new: an EXCEPT clause on publications, a SERVER clause on CREATE SUBSCRIPTION, and retain_dead_tuples for catching conflicting deletes.
A grab bag of developer-facing SQL rounds it out. INSERT ... ON CONFLICT DO SELECT ... RETURNING lets the "get or create" pattern return the conflicting row and optionally lock it, saving a round trip. COPY TO can emit newline-delimited JSON or a single JSON array with FORCE_ARRAY, and can target partitioned tables directly. lead(), lag(), and friends gain IGNORE NULLS. There's also a pile of SQL/JSON path string methods, date/timestamp versions of random(), and a 64-bit unsigned oid8 type.
Several workloads get faster with no code changes. FK checks are reported to make bulk inserts nearly twice as fast. Async I/O autoscaling, inherited from PostgreSQL 18's async I/O, now scales background workers automatically between the new io_min_workers and io_max_workers settings. LZ4 replaces pglz as the default TOAST compression. COPY FROM gets SIMD acceleration. The planner converts NOT IN to efficient anti-joins and does eager aggregation before joins. New EXPLAIN (ANALYZE, IO) and EXPLAIN (ANALYZE, WAL) options surface async I/O and full-page-write activity for diagnosis.
One detail that barely gets a spotlight but matters: PostgreSQL widened MultiXact members from 32 bits to 64 bits. That eliminates a ceiling capping total members at roughly 4 billion. Unlike transaction-ID wraparound, which everyone monitors, member exhaustion never showed up on a dashboard and could bite high-concurrency workloads in days rather than years. The ceiling is fully gone, not merely raised.
Things that changed by default
A few defaults shifted before you upgrade. JIT is now off by default; it had been on since PostgreSQL 12, and the cost model used to decide when to compile proved unreliable. Re-enable it and re-check plans if you run large analytical queries. standard_conforming_strings is now always on, which means dumps made with pre-19 pg_dump under standard_conforming_strings = off won't load, so recreate those dumps. The default inet/cidr opclasses moved from btree_gist to GiST because the old ones were broken, and pg_upgrade will refuse clusters still using the old indexes. io_workers is gone, replaced by four new io_worker variables. max_locks_per_transaction doubled to 128. RADIUS authentication is removed. MD5 login now warns after a successful auth.
Six weeks is a lot to slip. That delay reflects a deliberate community decision, not a stalled codebase. Features expected in 19, including SQL/PGQ graph queries, online checksum toggling, and partition merge and split, are now PostgreSQL 20 candidates. Whether the "AI is finding bugs faster than we can fix them" framing defines the next cycle of open-source database development remains to be seen, but PostgreSQL 19 is a sensible, production-minded release in its own right.
Head here to the official announcement and release notesĀ
