· via dev.to (home feed)
PostgreSQL 19 removes MultiXact member limit; reclaiming that space still waits on template0
PostgreSQL 19 widens MultiXact member offsets to 64 bits, removing the 2^32 member limit behind Metronome's 2025 outages, though member space still cannot be reclaimed until every database, template0 included, advances.

PostgreSQL 19 widens the member offset to 64 bits
Through version 18, the total number of MultiXact members a PostgreSQL cluster could record was capped by a 32-bit offset into the members log. PostgreSQL 19, released on 19 November 2026 according to a dev.to analysis, widens that offset to 64 bits. The underlying commit (bd8d9c9bd) eliminates MultiXactOffset wraparound and the 2^32 ceiling on total members, while the number of distinct MultiXact IDs remains capped at 2^31.
The author rebuilt the failure from scratch on PostgreSQL 18.7 and 19.0, using 19 RC2 as a cross-check; the final release reproduced every RC2 count exactly. In a fast-forwarded lab cluster, 18.7 refused writes once the multixact "members" limit was exceeded, while 19.0 pushed past 2^32 member offsets without an error, three runs out of three on each version. The cost is a slightly larger offsets segment: 8 bytes per MultiXact instead of 4. The members data itself, and the rate at which it is generated, are unchanged.
The wall Metronome hit
The motivation is documented in Metronome's root-cause analysis, cited by the dev.to post. Between 10 and 17 May 2025, Metronome had four outages lasting more than an hour each on an Aurora PostgreSQL 13.18 cluster larger than 30 TB. Dashboards showed under 50% utilization of the configured MultiXact ID threshold (autovacuum_multixact_freeze_max_age set to 400 million), yet writes were failing anyway. The limit actually reached was member space, for which PostgreSQL exposes no monitoring metric at all.
Member space fills because of how shared row locks work. When a second transaction locks a row while a first is still open, via SELECT ... FOR SHARE or the FOR KEY SHARE lock a foreign-key check takes on a parent row, PostgreSQL stores a MultiXact ID in the row and appends the list of member transaction IDs to pg_multixact/members. MultiXacts are immutable: every additional locker spawns a new MultiXact copying in all still-running members plus the newcomer. Overlapping lockers therefore pay quadratically. The author's measurements matched theory in all 108 runs: k sessions locking one row in turn produce k-1 MultiXacts and k(k+1)/2 - 1 members.
At roughly 5 bytes per member on disk, the 2^31 point where anti-wraparound activity becomes aggressive is about 10.7 GB, and the hard 2^32 stop is about 21.5 GB, in line with the "about 10GB" and "about 20GB" figures in the PostgreSQL 18 documentation.
A pause inside the transaction multiplies the cost
Under pgbench with foreign-key inserts into a child table, 64 clients plus a 5 ms pause inside each transaction generated about 61 members per insert, with 19 RC2 statistically indistinguishable from 18.7. The author's interpretation: each insert joins a MultiXact that already contains every other open inserter, so anything stretching a transaction, such as an HTTP call, a slow ORM flush, or a sleep inside a backfill, multiplies member growth. At roughly 741k members per second sustained by the lab box, an 18.x cluster would reach the 2^31 point in about 48 minutes and the hard stop in about 1.6 hours if nothing were reclaimed. The author flags this as a ceiling for one machine, not a production estimate, but the shape matches Metronome's incident: an FK-heavy backfill against a few hot parent rows.
Reclamation is still cluster-wide, and template0 still gates it
Lifting the wall does not change how space is returned. Member files are truncated only up to the minimum datminmxid across every database in the cluster, template0 included, and vacuumdb skips template0. On a fresh cluster where template0 had never been frozen, none of VACUUM, VACUUM (FREEZE) or vacuumdb --all --freeze freed a byte of member space on 18.7, 19 RC2 or 19.0. One idle session holding a row lock in a different database stalled reclamation for the entire cluster.
Upgrading does help existing bloat: after pg_upgrade to 19, each MultiXact keeps a single member, and in the author's k=64 runs the whole pg_multixact directory shrank from 107 MB to 8.2 MB, a 13x reduction. How much shrinks depends on the workload's lock pattern.
Why it matters
This is one of the few PostgreSQL limits that can take a very large cluster offline while monitoring insists nothing is wrong, because member consumption is invisible to standard metrics. Version 19 removes the write-stopping wall and shrinks accumulated bloat during upgrade, but neither the quadratic growth under concurrent foreign-key locking nor the cluster-wide reclamation coupling has changed. Operators on 18 and earlier running FK-heavy concurrent workloads should track pg_multixact size directly, ensure template0 actually gets frozen, and treat a lingering row lock in any database as a cluster-wide hazard.
- #postgresql
- #databases
- #open-source
- #performance
- #vacuum