Postgresql Updates & Release Notes

Follow

34 updates curated from 56 sources by the Releasebot Team. Last updated: Nov 13, 2026

Get this feed:
  • Nov 12, 2026
    • Date parsed from source:
      Nov 12, 2026
    • First seen by Releasebot:
      Nov 13, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 18.7

    Postgresql releases a major maintenance update focused on security and data integrity, fixing vulnerabilities, index and backup corruption risks, and problems across query planning, replication, and database operations. Users should review reindexing and full-backup guidance before relying on existing data structures or incremental backups.

    Release date: 2026-11-12

    This release contains a variety of fixes from 18.6. For information about new features in major release 18, see Section E.7.

    A dump/restore is not required for those running 18.X.

    However, several different bugs have been discovered that could result in index corruption. Examine the changelog entries below that mention REINDEX, and reindex any indexes you have that might be affected.

    Also, existing incremental backup files should not be trusted, thanks to the discovery of several ways that they could become corrupt. It's recommended that users of incremental backups take a new full backup after updating and use it as the basis for subsequent incremental backups.

    Also, if you are upgrading from a version earlier than 18.6, see Section E.2.

    Add defenses against problems caused by altering composite types concurrently with operations on data of those types (Heikki Linnakangas, Andres Freund, Nathan Bossart, Nikhil Sontakke)

    Operations such as ALTER TABLE ... ALTER COLUMN TYPE are hazardous because tuples of the older row layout may still exist in the system. While we have long had some checks to defend against that, they were never really complete, and they entirely failed to detect cases where composite types were changed concurrently with queries using them. This voluminous set of patches attempts to improve that.

    Introduce versioning logic to permit detection of composite datums that don't match the tuple descriptor we wish to interpret them with. For full protection, this change requires rebuilding C-language extensions, and there are some extensions that will require source-code changes. If necessary, the new composite_type_mismatch server parameter can be used to disable these checks, but doing so carries security risks.

    Add locking to prevent cases such as ALTER TYPE on a composite type used in a CREATE TABLE that hasn't committed yet.

    Tighten the rules about whether ALTER COLUMN TYPE is allowed when dependencies exist on the composite type. For example, it's no longer allowed when a function's default expression or new-style SQL function body depends on the type.

    The PostgreSQL Project thanks Andrew Gierth, Alexander Lakhin, Francesco Verardi, Hcamael, Tomer Fichman, OpenAI Security Research Team, Peter Geoghegan, Mehmet Ince, Bryan Green, Sumedh Pathak, Sergey Shinderuk, Yuxiao Guo, Nikhil Sontakke, Daniel Bakker, the Anthropic OSS program, Claude and Ada Logics for reporting this problem. (CVE-2026-6460)

    Cope with concurrent rowtype changes in ExecEvalFieldStore[De]Form() (Tomas Vondra, Heikki Linnakangas)

    The PostgreSQL Project thanks OpenAI Codex Security, Bronson Yen, Mehmet Ince, Claude and Ada Logics for reporting this problem. (CVE-2026-116306)

    Guard against malicious alteration of a table while a statistics import function is running on it (Masahiko Sawada)

    Previously it was possible to store statistics that no longer match the table, leading to crashes or other problems later.

    The PostgreSQL Project thanks Mehmet Ince for reporting this problem. (CVE-2026-116329)

    Enforce view row visibility in INSERT ... ON CONFLICT (Peter Geoghegan, Zsolt Parragi)

    When applied to a view, INSERT ... ON CONFLICT DO UPDATE could update rows that should be hidden by the view's WHERE clause. Although it was documented, this behavior is surely unexpected, and it gives rise to security problems: a user can update rows he should have no privilege to reach. Updating is incorrect, but inserting is impossible too (it would fail due to the unique arbiter index), so throw an error instead when the case arises. INSERT ... ON CONFLICT DO SELECT could show such rows as well, but no longer does.

    The PostgreSQL Project thanks Qing Xu, Carl Andersen, Zsolt Parragi, the Anthropic OSS program, Shihao Zhong, and Josef Šimánek for reporting this problem. (CVE-2026-16237)

    Align REASSIGN OWNED's caller-privilege checks with ALTER ... OWNER TO's checks (Zsolt Parragi)

    Since v16, giving an object to another role requires the ability to SET ROLE to that role. However, a role granted INHERIT TRUE, SET FALSE could bypass that via REASSIGN OWNED. A role granted INHERIT FALSE, SET TRUE saw the inverse problem: REASSIGN OWNED failed while ALTER OWNER succeeded. Make REASSIGN follow the ALTER OWNER rules.

    REASSIGN OWNED also bypassed the CREATEDB privilege check in ALTER DATABASE OWNER.

    In v15 and v14, REASSIGN OWNED's privilege check is stricter than the membership checks in ALTER OWNER. Leave that alone, but still fix the missing CREATEDB check.

    The PostgreSQL Project thanks Zsolt Parragi for reporting this problem. (CVE-2026-120146)

    Fix use-after-free in COPY FROM ON_ERROR reporting (Masahiko Sawada)

    An error report raised in COPY FROM could disclose server memory.

    The PostgreSQL Project thanks Jiyong Ahn, Claude and Ada Logics for reporting this problem. (CVE-2026-116310)

    Disallow closing a portal that is still being set up (Michael Paquier)

    This change forestalls various use-after-free issues.

    The PostgreSQL Project thanks Tomas Vondra for reporting this problem. (CVE-2026-116332)

    Forcibly close portals associated with transition tables at the end of the trigger function (Jeff Davis)

    This change avoids use-after-free hazards.

    The PostgreSQL Project thanks Peter Geoghegan for reporting this problem. (CVE-2026-120143)

    Fix race condition leading to use-after-free in shared tupledesc management (Robert Haas)

    The PostgreSQL Project thanks Peter Geoghegan for reporting this problem. (CVE-2026-116304)

    Fix use-after-free in pg_show_all_settings() (Masahiko Sawada)

    The PostgreSQL Project thanks Claude and Ada Logics for reporting this problem. (CVE-2026-120152)

    Fix use-after-free in expanded-record domain constraint checking (Tom Lane)

    The PostgreSQL Project thanks Claude and Ada Logics for reporting this problem. (CVE-2026-120150)

    Prevent memory corruption after a large allocation in a “generation” memory context is freed (Heikki Linnakangas)

    The PostgreSQL Project thanks Jayden Sarveshkumar for reporting this problem. (CVE-2026-116328)

    Fix buffer overrun in tsvector_delete() (Anthropic OSS program)

    With crafted input, tsvector_delete() could be induced to write more bytes than it had allocated for its result.

    The PostgreSQL Project thanks the Anthropic OSS program for reporting this problem. (CVE-2026-116315)

    Fix buffer overrun in ts_rank_cd() (Anthropic OSS program)

    With crafted input, ts_rank_cd() could be induced to write more bytes than it had allocated for its result.

    The PostgreSQL Project thanks the Anthropic OSS program for reporting this problem. (CVE-2026-116317)

    Prevent construction of invalid name values via element assignment (Tom Lane)

    array_set_element() could be abused to make the last byte of a name-type value nonzero. Subsequent uses of the value would then read past the end, resulting in crashes or disclosure of server memory. While at it, disallow construction of invalidly-encoded strings through this mechanism.

    The PostgreSQL Project thanks the Anthropic OSS program for reporting this problem. (CVE-2026-116321)

    Treat application of a leaky function to a CaseTestExpr or internal Param node as leaky (Tom Lane)

    A CaseTestExpr or internal Param represents the value of an expression somewhere else in the query. If that expression contains a Var then there is potential for information leakage. Therefore, reject such cases when deciding whether an expression is leak-proof.

    The PostgreSQL Project thanks Only see myself for reporting this problem. (CVE-2026-116327)

    Don't generate an index-based plan for an aggregate whose input and output types don't match (Tom Lane)

    Previously, we'd blindly do this if the aggregate has a SORTOP option attached. The index-based plan will return the aggregate's input column, leading to type violations and potentially to arbitrary code execution if its declared output type is different. In the master branch, disallow such aggregate declarations. In released branches, add a plan-time check to not generate such plans if the types don't match.

    The PostgreSQL Project thanks Zheng Yu, Claude and Ada Logics for reporting this problem. (CVE-2026-116331)

    Delay processing of cancel request packets until it's safe to handle them (Michael Paquier)

    With luck and good timing, an attacker could induce the process receiving a cancel request packet to exit while holding a spinlock, thereby causing a database crash and restart.

    The PostgreSQL Project thanks the Anthropic OSS program for reporting this problem. (CVE-2026-116322)

    Avoid inserting the wrong tuple into a trigger transition table in a MERGE that does an INSERT followed by an UPDATE (Heikki Linnakangas, Jacek Bylina, Jacob Robertson, Nigel Gott)

    The PostgreSQL Project thanks Jacek Bylina, Timothy Ball, Claude and Ada Logics for reporting this problem. (CVE-2026-116312)

    Check that commutator and negator operator pairs return the same data type (Tom Lane)

    Previously, substitution of a commutator or negator operator could lead to a type violation. This patch also cleans up some cases where one operator had a commutator/negator link to another, but the second operator didn't link back to the first.

    The PostgreSQL Project thanks Claude and Ada Logics for reporting this problem. (CVE-2026-116335)

    Prevent functions in index predicates and expressions from breaking REINDEX CONCURRENTLY by manipulating the indexes (Michael Paquier)

    The PostgreSQL Project thanks Florent Saudel for reporting this problem. (CVE-2026-116336)

    Prevent corrupting a newly-installed extension by renaming its target schema during CREATE EXTENSION or by installing it into a temporary schema (Noah Misch)

    With some ingenuity, an attacker could substitute objects of his creation for objects in the extension.

    The PostgreSQL Project thanks Noah Misch for reporting this problem. (CVE-2026-6467)

    Reject more unsafe names in extension script substitutions (Nathan Bossart)

    We already rejected schema and owner names containing quotes, backslashes, and dollar signs, but names containing newlines, carriage returns, comment delimiters, or the substitution tokens themselves can still achieve SQL injection. Reject all those cases too.

    The PostgreSQL Project thanks the Anthropic OSS program, Sven Klemm, and Aaron Chen for reporting this problem. (CVE-2026-120153)

    Check EXECUTE privilege before calling cast functions within to_json() and other conversion-to-JSON code (Nathan Bossart, Anthropic OSS program)

    Typically such functions would have public EXECUTE privilege anyway, but this puts the behavior on par with normal execution of casts.

    The PostgreSQL Project thanks Filip Janus and the Anthropic OSS program for reporting this problem. (CVE-2026-116303)

    Check EXECUTE privilege before calling cast functions within foreign key enforcement checks (Nathan Bossart)

    Typically such functions would have public EXECUTE privilege anyway, but this puts the behavior on par with normal execution of casts.

    The PostgreSQL Project thanks Noah Misch for reporting this problem. (CVE-2026-116303)

    Prevent DROP OWNED BY from changing row-level security policies on tables that the current user does not own (Zsolt Parragi, Anthropic OSS program)

    Previously, an unprivileged role could remove itself from restrictive policies on tables it does not own. Instead issue a warning, as is already done for privileges that the current user cannot revoke.

    The PostgreSQL Project thanks Zsolt Parragi and the Anthropic OSS program for reporting this problem. (CVE-2026-116311)

    Disallow security-restricted operations from creating types in temporary schemas (Anthropic OSS program, Nathan Bossart)

    We already disallowed creating temporary tables in this context, but a type also presents a hazard of shadowing permanent objects and thus allowing privilege escalation.

    The PostgreSQL Project thanks the Anthropic OSS program for reporting this problem. (CVE-2026-116316)

    Avoid out-of-bounds accesses in FDW batch inserts (Nathan Bossart)

    The PostgreSQL Project thanks Sumedh Pathak and Sven Klemm for reporting this problem. (CVE-2026-120149)

    Avoid out-of-bounds reads in parallel btree scans with array keys (Nathan Bossart)

    The PostgreSQL Project thanks Claude and Ada Logics for reporting this problem. (CVE-2026-116333)

    Replace the type cache's in_progress_list mechanism with something simpler and safer (Robert Haas)

    The PostgreSQL Project thanks Peter Geoghegan for reporting this problem. (CVE-2026-120144)

    Refuse to create extended statistics on expressions of transient types (Masahiko Sawada)

    Disallow CREATE STATISTICS on expressions whose types would not be allowed as table column types, most notably anonymous record types. This prevents other sessions from misinterpreting the stored values.

    The PostgreSQL Project thanks Mehmet Ince for reporting this problem. (CVE-2026-120148)

    Reject system catalogs as logical replication targets (Masahiko Sawada)

    The PostgreSQL Project thanks Qian Zhang for reporting this problem. (CVE-2026-120145)

    Check ON CONFLICT target row against RLS policies before applying user quals (Peter Geoghegan, Zsolt Parragi)

    Previously, leaky qual expressions could see rows that RLS policies should forbid them from seeing.

    The PostgreSQL Project thanks Peter Geoghegan, Zsolt Parragi, Only see myself, the Anthropic OSS program, Joao Detomini, Josef Šimánek, and Qing Xu for reporting this problem. (CVE-2026-120154)

    Validate all connection options in replication subscriptions and contrib/dblink (Jacob Champion)

    Previously, these checks were applied inconsistently.

    The PostgreSQL Project thanks Andrey Krasichkov, Bashir Altawil, and Zsolt Parragi for reporting this problem. (CVE-2026-14661)

    Handle dropped columns safely while comparing row types (Peter Geoghegan)

    Previously, two row types that had dropped columns at the same position could be considered equal even if those columns were of different physical widths. That leads to problems when trying to deconstruct tuples of those types.

    The PostgreSQL Project thanks Peter Geoghegan and Mehmet Ince for reporting this problem. (CVE-2026-120142)

    Disallow declaring SQL functions as returning type "any" (Peter Geoghegan)

    This allowed type violations.

    The PostgreSQL Project thanks Peter Geoghegan, Claude and Ada Logics for reporting this problem. (CVE-2026-18447)

    Harden more memory-size calculations against integer overflow (Álvaro Herrera)

    The PostgreSQL Project thanks Hillai Ben Sasson, Jayden Sarveshkumar, and Mehmet Ince for reporting this problem. (CVE-2026-120139)

    Fix type confusion in set-returning functions that return RECORD, when materialized in a query's target list (Melanie Plageman, Robert Haas)

    The same tuple descriptor was used across multiple calls, which is unsafe since the actual record type could vary.

    The PostgreSQL Project thanks Peter Geoghegan for reporting this problem. (CVE-2026-120141)

    Cope with concurrent rowtype changes in PL/pgSQL record field assignment (Tom Lane)

    The PostgreSQL Project thanks Claude and Ada Logics for reporting this problem. (CVE-2026-120151)

    Support “tied” Perl objects in PL/Perl and associated contrib modules (Andrey Rachitskiy)

    Up to now, if you passed a tied object to a PL/Perl operation, it would most likely get treated as undef, since we failed to perform Perl get magic on values we're passed. Tied hashes worked partially, in that you could read out their keys, but the values always read as undef.

    Originally this was intended as a master-only change, since it looks like a feature addition. But afterwards we discovered that assorted security-grade misbehaviors could be triggered by tied objects even without this patch. Rather than trying to secure two sets of behaviors, it seems best to back-patch this change first. (CVE-2026-116326)

    Fix PL/Perl to cope with errors thrown from tied objects (Tom Lane, Andrew Dunstan)

    The PostgreSQL Project thanks Ngoc Tran, the Anthropic OSS program, and Dwij Mehta for reporting this problem. (CVE-2026-116326)

    Fix type confusion in PL/Perl's get_perl_array_ref() (Andrew Dunstan)

    The PostgreSQL Project thanks Zheng Yu for reporting this problem. (CVE-2026-116309)

    Fix use-after-free in scans of Perl arrays and hashes (Tom Lane, Anthropic OSS program)

    The PostgreSQL Project thanks the Anthropic OSS program for reporting this problem. (CVE-2026-116320)

    Fix use-after-free in plperl_return_next_internal() (Anthropic OSS program)

    The PostgreSQL Project thanks the Anthropic OSS program and Ngoc Tran for reporting this problem. (CVE-2026-116319)

    In PL/Perl, fix use-after-free triggered by releasing a prepared query that is being executed (Masahiko Sawada)

    The PostgreSQL Project thanks Zheng Yu and the Anthropic OSS program for reporting this problem. (CVE-2026-116307)

    Fix use-after-free hazards in re-entrant use of PL/Tcl (Tom Lane)

    The PostgreSQL Project thanks Claude and Ada Logics for reporting this problem. (CVE-2026-116323)

    Reject re-entrant use of contrib/dblink (Masahiko Sawada)

    The PostgreSQL Project thanks Jiyong Ahn for reporting this problem. (CVE-2026-120147)

    In contrib/dict_int, return NULL for zero-length tokens (Nathan Bossart, Anthropic OSS program)

    This behavior is consistent with other text-search dictionary types, and it avoids disclosure of server memory as was possible previously.

    The PostgreSQL Project thanks Nathan Bossart and the Anthropic OSS program for reporting this problem. (CVE-2026-116308)

    Ensure that reindexdb correctly quotes index names it is dealing with (Anthropic OSS program)

    Crafted index names could yield a SQL-injection attack against the user running reindexdb.

    The PostgreSQL Project thanks the Anthropic OSS program for reporting this problem. (CVE-2026-116325)

    Use fully-qualified operator names in vacuumdb (Nathan Bossart, Anthropic OSS program)

    This prevents attacks on the user running vacuumdb.

    The PostgreSQL Project thanks Noah Misch and the Anthropic OSS program for reporting this problem. (CVE-2026-116313)

    Ensure that pg_dump quotes the names of NOT NULL constraints (Anthropic OSS program)

    Its failure to do so in some cases risked SQL injection, or even just restoring the constraint with the wrong name.

    The PostgreSQL Project thanks the Anthropic OSS program, Sarath Kumar, and Nikolay Samokhvalov for reporting this problem. (CVE-2026-116318)

    Make the [un]restrict commands functional in pg_dump's tar-format output (Noah Misch)

    This provides the intended level of protection to users who make use of the undocumented restore.sql tar member.

    The PostgreSQL Project thanks Pavel Kopylov for reporting this problem. (CVE-2026-116330)

    Harden pg_restore against corrupt archive files (Dilip Kumar, Yonghwa Lee, Nathan Bossart)

    This patch fixes out-of-bounds accesses and file path traversal hazards. There remain other issues that don't seem to amount to security bugs.

    The PostgreSQL Project thanks Dilip Kumar, Yonghwa Lee, OpenSec, and Ben Dixon for reporting this problem. (CVE-2026-116314)

    Fix use of externally-controlled format string in pg_basebackup (Peter Eisentraut)

    This problem could only be reached if files with unusual names exist in the server's data directory.

    The PostgreSQL Project thanks Peter Eisentraut for reporting this problem. (CVE-2026-16240)

    Disable btree index de-duplication support for the bpchar data type (Shihao Zhong, Peter Geoghegan)

    Index de-duplication is unsafe for bpchar because its notion of equality is weaker than bitwise equality. In particular, because bpchar equality ignores trailing spaces, values of different lengths can compare equal. De-duplication then allows index-only scans to return subtly wrong results.

    This patch disables de-duplication for new index entries, but does nothing about possible corruption of existing entries. Therefore, users who have btree indexes on bpchar columns should REINDEX them after installing this update.

    Note that this problem only applies to columns declared as bpchar, that is, lacking any length constraint. The more common usage of CHAR(n) is not at risk, even though it shares the same underlying code, because the length constraint forces otherwise-equal strings to have the same length and thus to be bitwise equal.

    Ensure that VACUUM cleans up all dead tuples in a GIN index (Peter Geoghegan)

    When a single VACUUM operation requires multiple index scans (because it is removing more tuples than it can hold in memory at once), it was possible to miss removing some index entries that should be removed. An additional bug involving a race with leaf page splits had the same effect. These bugs would eventually lead to a corrupt index with entries pointing at unrelated table rows. REINDEX is recommended if you suspect this has happened.

    Fix GIN posting tree page deletion after an incomplete page split (Peter Geoghegan)

    The deletion step could incorrectly disconnect sibling pages, causing subsequent index searches to miss rows. REINDEX is recommended if you suspect this has happened.

    Fix failure to update mutable pg_index fields for TOAST-table indexes (Bharath Rupireddy)

    REINDEX CONCURRENTLY can change these fields, but the relation cache was not expecting that, allowing index updates to be missed. The end result could be errors about “missing chunk number” due to missing index entries. Fortunately, these only represent index corruption; the TOAST table itself is fine, so a REINDEX will suffice to recover.

    Perform join removal by editing the query's parse tree, rather than trying to fix up the planner's derived data structures (Tom Lane, Richard Guo, Shihao Zhong, Ayush Tiwari)

    The original implementation of join removal in the planner has had numerous bugs over the years, including some that were never fixed. It was inherently fragile because changes in the planner's derived data structures often required adjustments in join removal, yet there was no easy way to keep that code in sync. Replace it with code that modifies the far-simpler parse tree representation and then loops around to re-generate all of the derived data. This is a significant change that normally we'd never consider back-patching, but the prospect of continuing bugs from the old implementation has driven us to take the risk of doing so.

    Fix assorted planner bugs triggered by lateral references (Richard Guo)

    These mistakes could lead to incorrect query plans causing wrong answers, or to internal planner errors such as “failed to build any N-way joins”.

    Ensure proper placement of qual clauses containing PlaceHolderVars by assigning a relation ID to antijoins made from SubLinks (Richard Guo)

    This avoids edge cases where such a qual could be pushed into the right-hand side of the antijoin, giving it the opposite of the desired semantics.

    Fix placement of PlaceHolderVars as nestloop parameters (Richard Guo)

    In rare cases, planning could fail with “failed to assign all NestLoopParams to plan nodes”, “plan should not reference subplan's variable”, or “variable not found in subplan target list” errors.

    Avoid planner failure for sort keys that are PlaceHolderVars (Richard Guo)

    Depending on the plan shape selected, such cases could produce wrong results, or could fail with “variable not found in subplan target lists”.

    Fix incorrect dropping of outer join clauses after re-associating outer joins (Richard Guo, Nitin Motiani)

    Avoid “unsupported join alias expression” failures when a whole-row Var references a join and appears below an outer join (Richard Guo)

    Handle SubLinks correctly when expanding a whole-row join alias reference (Richard Guo)

    This oversight led to errors like “cannot handle unplanned sub-select” or “unrecognized node type”.

    Do not perform self-join elimination with inheritance trees (Tender Wang)

    In traditional table inheritance, a unique index on the parent table isn't sufficient to prove uniqueness across its children too, so that the proof required for SJE isn't possible. Moreover, the code was willing to merge parent_table with parent_table ONLY, which doesn't even represent the same set of rows.

    In self-join elimination, check that clauses used to prove uniqueness actually match (Tender Wang)

    Previously, this code assumed that equality clauses with the same operands were equivalent; but in fact they could use different equality operators, or more likely different collations.

    Don't assume that DISTINCT ON ensures uniqueness of a subquery's output rows when the subquery's targetlist contains any set-returning functions (Richard Guo)

    This doesn't follow, because the set-returning functions may be evaluated after the de-duplication step.

    Fix incorrect constant-folding of a JSON constructor with a RETURNING clause inside a simple-form CASE with a constant test expression (Richard Guo)

    Fix test for pushing WHERE clauses down past a grouping step that has a different equivalence rule (Richard Guo)

    The previous release cycle's fix for this situation misbehaved for some clauses involving CASE expressions.

    Fix incorrect behavior of MIN()/MAX() index scans when query specifies FETCH ... WITH TIES (Chaitanya Choudhary)

    The WITH TIES option was accidentally copied into the sub-SELECT generated to perform the index scan, possibly triggering “more than one row returned by a subquery used as an expression” errors.

    Use the correct collation when unique-ifying a semijoin's righthand side (Andrey Rachitskiy)

    This is an issue only if the join's comparison clause uses a non-deterministic collation, since all deterministic collations agree on string equality. But if it does, it was possible to produce incorrect results with too many rows.

    Fix handling of disabled plan node types below single-child Append nodes (Tender Wang)

    The Append node failed to copy its child's disabled_nodes count, allowing it to possibly be chosen over other alternatives that contain no disabled nodes.

    Acquire a predicate lock on conflicting rows during INSERT ... ON CONFLICT (Zsolt Parragi, Andrey Borodin)

    Failure to do this resulted in incorrect behavior in serializable mode, allowing concurrent updates that should have failed with a serialization error.

    Fix integer overflow during parallel GIN index build (Ewan Young)

    Index keys were stored in an interim data structure whose size field was only 16 bits, so that keys larger than 65535 bytes were truncated, resulting in crashes or corrupted index entries.

    Fix incorrect multi-column RANGE partition pruning (David Rowley)

    When performing partition pruning with a RANGE partitioned table where pruning quals are only present for a leading prefix of the partition key, it was possible for partition pruning to prune away some partitions that shouldn't be pruned (leading to missing some rows that should be found) and/or include some partitions that were not needed.

    Fix incorrect pruning of DEFAULT partitions in range-partitioned tables that use MINVALUE or MAXVALUE bounds (Ewan Young)

    In some cases the code would incorrectly conclude that the DEFAULT partition needn't be scanned, causing failure to find some rows that should match the query.

    Fix mishandling of run-time partition pruning during EPQ rechecks (David Rowley, Zsolt Parragi)

    This error could result in silently skipping rows that should be updated, as well as possible use-after-free accesses.

    Don't use SubPlan-containing expressions in plan-startup-time partition pruning (Richard Guo)

    This avoids “SubPlan found with no parent plan” errors in edge cases.

    Fix problems with queries applying multiple sort keys to a single column (David Rowley, Ayush Tiwari)

    Some queries could crash the backend, while in other cases the additional sort specifications were ignored. Ordinarily such additional sort specifications are redundant anyway, since the first one would fully determine the result ordering. However, this is not necessarily so with non-deterministic collations, or with queries using different ORDER BY operators.

    Avoid possible re-use of stale hash tables when a hashed SubPlan is referenced in multiple places (Rahul Yadav)

    Ensure that Memoize plan nodes use the correct input collation (Shihao Zhong)

    This matters only when using non-deterministic collations.

    Fix wrong results from Memoize plans when a Param is a subexpression of a cache key (Richard Guo)

    Fix loss of parallel worker statistics for Memoize plan nodes underneath a Gather (Tatsuya Kawata)

    Only the statistics since the last rescan of the Gather were reported by EXPLAIN ANALYZE.

    Don't create a shell type if a function definition specifies an unknown return type name with array or type modifier syntax (Heikki Linnakangas)

    Such cases are surely errors, since you should create the type before doing anything advanced with it.

    Fix snapshot export and import to work properly on a snapshot taken during recovery (Peter Geoghegan, Bertrand Drouvot)

    The data layout is different in such a snapshot, but the export/import logic didn't know that, so that the imported snapshot behaved incorrectly. This led not only to wrong answers within the importing transaction, but possibly to persistent data corruption due to it setting hint bits incorrectly.

    This bug is known to be triggered by parallel pg_dump, when run on a standby server. In that context it could corrupt both the dump output and the standby server's data.

    Fix atomicity problem in transaction snapshot import (Chee Wooson)

    There was a window in which onlookers might not see the source transaction as still running, possibly allowing wrong decisions by VACUUM, for example.

    Fix import of statistics for columns that are domains over range types, multirange types, or tsvector (Michael Paquier)

    The restore logic failed to look through the domain while checking applicability of statistics types that are for these data types.

    Fix double parse transformation of PASSING arguments in JSON_TABLE (Ayush Tiwari, Amit Langote)

    This mistake caused unexpected failures such as “unexpected non-SELECT command in SubLink”.

    Fix failure to assign collations to PASSING expressions in JSON_TABLE (Venu Kummari)

    This oversight could result in wrong answers or “could not determine which collation to use for string comparison” errors.

    Fix usage of toasted text values in the PASSING arguments of JSON_TABLE and related functions (Chaitanya Choudhary, Shihao Zhong)

    The code failed to apply detoasting, resulting in incorrect output.

    Fix NULL result persistence in JSON_VALUE() RETURNING json/jsonb (Srinath Reddy Sadipiralla)

    Once JSON_VALUE(... RETURNING ...) with a json or jsonb result value returned NULL, every later evaluation of the same expression in the same statement also returned NULL, whether it should or not.

    Fix ON EMPTY/ERROR result persistence in JSON_VALUE and related constructs (Jian He, Andrey Rachitskiy)

    A NULL input could result in returning the value of the previous row's ON EMPTY / ON ERROR expression.

    Fix handling of failures in DEFAULT expressions in SQL/JSON operations (Jian He)

    An error arising while executing a DEFAULT expression could be ignored, instead producing a NULL result.

    Fix handling of domain coercion failures in SQL/JSON operations (Jian He)

    SQL/JSON query functions could throw an error, or report the wrong one, in cases where an ON ERROR or ON EMPTY clause specified some non-error behavior.

    Fix GIN index searches for plain scalar strings in strict jsonpath queries (Rui Zhao)

    A jsonb_ops index scan for a jsonpath such as strict $ == "scalar" failed to find table entries that were simply "scalar".

    Fix errors in extraction of GIN index scan conditions from jsonpath queries (Tom Lane)

    An AND operator underneath a NOT operator could be misimplemented. Also a method applied to a literal constant, for example "42".double(), was not handled correctly. These mistakes did not cause visible errors, but the GIN index search would miss some or all of the rows that should match.

    Fix edge-case error in SP-GiST quad-tree <@ searches (John Naylor)

    Due to roundoff error, the search might sometimes not descend into a quadrant that it needs to search, leading to incomplete query results.

    Fix edge-case failures in SP-GiST quad-tree indexes (Ayush Tiwari)

    Roundoff errors could allow searches and insertions to fail with “getQuadrant: impossible case” errors.

    Accept empty tsquery values in binary input (Ayush Tiwari)

    An empty tsquery value is allowed elsewhere, but tsqueryrecv() failed.

    Disallow zero-length lexemes and out-of-range phrase distance values in binary input of tsquery values (Tom Lane)

    These cases were already rejected during text input, but tsqueryrecv() omitted making equivalent checks. That allowed accepting values that would fail subsequent dump/reload.

    Treat operators-nested-too-deeply errors as soft errors in tsquery input and ltxtquery input (Tom Lane)

    Consistently enforce maximum lengths in tsvector and tsquery (Tom Lane)

    Some places thought the maximum lexeme length was MAXSTRLEN (2047), while others thought it was MAXSTRLEN-1. Fortunately, the looser bound is correct, so make them all use MAXSTRLEN. Likewise, some places were stricter than others about the total data length limit, MAXSTRPOS. These fixes avoid situations where a validly-constructed value would fail dump/reload.

    Fix right() with a length argument of INT_MIN (-2147483648) (Ewan Young)

    Due to integer overflow, the function returned the whole string when it should return an empty string.

    Fix pg_blocking_pids() to account correctly for relation extension locks (Bertrand Drouvot)

    Fix 32-vs-64-bit confusion in pg_indexam_progress_phasename() (Markos Fountoulakis)

    This function accidentally worked on common hardware, but could misbehave on 32-bit or big-endian platforms.

    Detect integer overflow in to_char() with V format (Andrey Rachitskiy)

    If the data value is an integer, and multiplying it by the power of ten implied by the V format causes integer overflow, to_char() silently emitted incorrect digits. Throw an integer overflow error instead.

    Avoid integer overflow while calculating BRIN minmax_multi distances for tid values (Tomas Vondra)

    Very large tid values could result in negative distances, which would end in making the index inefficient, though not actually corrupt.

    Avoid overflow while calculating BRIN minmax_multi distances for numeric values, and handle NaNs properly (Kirill Reshke, Tomas Vondra)

    These oversights could result in errors being thrown (preventing index summarization), or in inefficient indexes.

    Avoid overflow when computing differences for numeric ranges (Kirill Reshke)

    In this context we want to return plus or minus infinity rather than throwing an overflow error.

    Support out-of-order FLAG lines in Hunspell affix files (Ewan Young)

    Hunspell affix files usually put the FLAG line first, and our implementation silently depended on that. If it came after some lines whose meaning depends on the FLAG setting, the result would be crashes or failures to match compound words. Fix the logic so that the FLAG line can be anywhere.

    Fix OLD/NEW aliases that EXPLAIN prints in RETURNING SubPlans (Henson Choi)

    In plans involving multiple aliases, the wrong one could be printed, resulting in confusing output.

    Fix assorted errors in rule deparsing (Henson Choi)

    Always print AS before a target-relation alias in UPDATE, DELETE, or MERGE, to avoid ambiguity if that alias is set. Also ensure that xml IS DOCUMENT constructs and subquery left-hand arguments are adequately parenthesized. Also fix deparsing of AT TIME ZONE and similar constructs in a view's FROM clause; these need to be wrapped in a no-op CAST. These errors could prevent dump restoration due to a syntax error in a view, or cause reloaded views to be parsed as something different from before.

    Fix parser failure when a multi-row INSERT ... VALUES has a sub-SELECT in a target column subscript (Amit Langote)

    This led to “unexpected non-SELECT command in SubLink”.

    Fix missed preprocessing of WHERE clauses in COPY FROM (Nathan Bossart)

    This oversight led to “cache lookup failed for function 0” errors with negated operators, and probably in other cases as well.

    Disallow NOT NULL NO INHERIT constraints on partitioned tables (David Rowley, Nitin Motiani)

    This was already rejected by plain CREATE TABLE, but cases such as CREATE TABLE LIKE missed checking copied constraints, potentially allowing a partition to contain null values when it should not.

    If you suspect this might have happened in your database, issue this command to find broken constraints:

    SELECT conrelid::regclass, conname
    FROM pg_constraint
    WHERE contype = 'n' AND connoinherit
    AND conrelid IN (SELECT oid FROM pg_class WHERE relkind = 'p');

    Unwanted constraints can be removed with ALTER TABLE ... DROP CONSTRAINT ..., while ones that are wanted should be repaired with ALTER TABLE ... ALTER CONSTRAINT ... INHERIT. The latter command will fail if any null values are present in the table's partitions.

    Fix test for an existing NOT NULL constraint in ALTER TABLE ADD PRIMARY KEY (Fujii Masao, Manuel Reyes Bravo)

    Previously, dropping a NOT NULL column, adding a new column with the same name, and making it a primary key in a single ALTER TABLE command could fail with “primary key column ... is not marked NOT NULL”.

    Fix concurrent delete handling in MERGE ... WHEN NOT MATCHED BY SOURCE (Tender Wang)

    When executing a WHEN NOT MATCHED BY SOURCE action in MERGE, if the tuple from the target table was concurrently deleted, the retry code would incorrectly execute a WHEN NOT MATCHED BY TARGET action for the row instead, giving incorrect results.

    Fix race conditions with DROP TABLESPACE (Ayush Tiwari)

    A DROP executed concurrently with commands that attempt to add new objects to the tablespace could end with inconsistent catalog contents.

    Cleanly reject operations on unlogged tables during recovery (Jim Jones)

    An unlogged table will have no data on a standby, so reading it must fail. Most operations give an appropriate error for this, but COPY ... TO failed with an internal “could not open file” error, as did currtid2().

    Fix inconsistent permissions checking for role membership changes (ChangAo Chen)

    This fixes cases where what should be a permissions failure was reported as an internal “no possible grantors” error.

    Revert previous changes to free space map persistence (Alexander Korotkov)

    Commits c06d1a4ba et al. (included in the May 2026 releases) turned out to cause more trouble than they fixed.

    Avoid backend hang during temporary table cleanup at exit, if the default transaction mode is SERIALIZABLE READ ONLY DEFERRABLE (Andrey Rachitskiy)

    Cleanup would block until concurrent serializable transactions complete, which could be indefinitely if some of them are prepared transactions.

    Avoid crash when describing a FETCH statement whose cursor is gone (Dirkjan Bussink)

    Fix memory accounting for datum sorts on pass-by-reference data types (Mario Karuza)

    This error could lead to failure to enforce work_mem limits correctly, or to misleading output from EXPLAIN ANALYZE.

    If a vacuum delay sleep is requested while holding locks, don't sleep (Kevin Rocker, Andrey Borodin, Mostafa)

    Also, move several existing delay calls to points where it's actually safe to sleep.

    Fix parallel vacuum I/O timing reports (Bharath Rupireddy)

    VACUUM VERBOSE and autovacuum logs included parallel workers' blocks-read and blocks-dirtied counts, but not the time they spent doing that I/O.

    Avoid freeing the plan for a foreign-key enforcement query if the plan is still in use (Lucas Jeffrey, Trakshan Mishra, Amit Langote)

    It was possible to reach this behavior in contrived cases, such as a self-referencing ON DELETE CASCADE foreign key on tables with triggers that perform DML.

    Fix postmaster failing to exit when the startup subprocess crashes during crash restart (Zexin Li)

    The postmaster should give up and quit in this case, but it failed to do so, instead becoming stuck.

    Be more wary about scanner failures when parsing a GUC file (Michael Paquier)

    Recheck oauth_validator_libraries during OAuth authentication (Zsolt Parragi)

    This addition ensures that changes to oauth_validator_libraries are enforced immediately. Previously, if such a change made an existing oauth line in pg_hba.conf invalid, the new setting was not enforced until that situation was fixed.

    Fix postmaster crash when oauth_validator_libraries is set to a string containing only whitespace (Grigorev Jurij, Zsolt Parragi)

    Fix WAL-logging of multi-level page deletion in btree indexes (Peter Geoghegan)

    The WAL log could contain stale values for a to-be-deleted page's sibling links, resulting in complaints on standby servers if wal_consistency_checking is enabled. Barring a crash, the damage would shortly be repaired by completion of the deletion action, so that this error was usually only cosmetic.

    Avoid overly-strong WAL consistency check on buffers that are only pinned not locked (Greg Burd, Thomas Munro)

    A buffer that is not locked could be concurrently changed by other processes, so that the image captured for consistency checking is not self-consistent, leading to “incorrect resource manager data checksum in record” failures on standbys.

    Ensure that state files for pending prepared transactions are written out atomically during a checkpoint (Shihao Zhong)

    Previously it was possible for a crash to leave an invalid state file behind, causing subsequent database startup to fail.

    Do not start a checkpoint in the middle of aborting a prepared transaction (Shihao Zhong)

    A crash would allow the transaction to be committed afterwards, leading to inconsistent state.

    Do not start a checkpoint in the middle of creating a multixact (Shihao Zhong)

    This avoids possible data loss after a subsequent crash.

    Fix possible loss of tuples updated by later-aborted subtransactions (Shihao Zhong, Michael Paquier)

    A table rewrite (for example, CLUSTER or VACUUM FULL) could discard such tuples as invalid.

    Do not lose tuple's tid when storing it into a tuple table slot (Virender Singla, Greg Burd)

    Some code paths neglected to copy the tid field, which could lead to data corruption or wrong query answers in unusual cases.

    Avoid race condition in marking a partitioned index valid (Andrey Borodin, Kirill Reshke)

    This could, for example, cause parallel pg_restore to fail due to trying to recreate foreign key constraints too soon.

    Fix checks for an aborted updating transaction in multixids (Chee Wooson)

    Known consequences of this coding error include unexpected “new multixact has more than one updating member” errors, as well as incorrect failures to update a row.

    A hash index scan that starts during a bucket split could miss some index entries (Peter Geoghegan, Amit Kapila)

    Fix incorrect position tracking in TID Range Scans (Ewan Young, David Rowley)

    Sequences involving fetching backwards and then forwards again could fail to scan all the way to the end of the range.

    Avoid unnecessary buffer locking when recovery replays freeze-only and VM-only WAL records (Melanie Plageman)

    This prevents unnecessary replay delays and cancellations of standby queries.

    Avoid reading a potentially-torn copy of the pg_control file for base backups (David Steele)

    A concurrent write to the file could result in including inconsistent data in the backup.

    Prevent making incorrect copies of non-relation files in base backups (David Steele)

    Files that routinely get replaced by atomic renames, such as postgresql.auto.conf, could be truncated or zero-padded in a backup made concurrently with such a replacement.

    Ensure that base backups report checksum failures affecting single pages (Zsolt Parragi)

    Due to a logic error, checksum failures were counted in pg_stat_database only when more than one page in the same file was corrupt.

    Fix stale visibility maps in incremental backups after heap truncation (Ke, Fujii Masao, Shihao Zhong)

    An incremental backup taken after VACUUM truncates a table can restore stale visibility map bits when both data checksums and wal_log_hints are disabled, leading to data corruption.

    This fix does not correct existing WAL summaries, therefore incremental backups taken after updating can still be affected. It's recommended that users of incremental backups take a new full backup after updating and use it as the basis for subsequent incremental backups.

    Reject incremental backups based on a backup from a divergent history (Sai Pranav, Fujii Masao)

    After a failover, an incremental backup could accept a prior backup whose WAL range extends beyond the point where the new primary left the old timeline. Combining these backups could retain pages from the abandoned history, producing a corrupt backup.

    Ensure that incremental backup merges WAL summaries in LSN order (Ke, Fujii Masao)

    This error could result in stale data being included in a combined backup.

    Fix erroneous edge-case decisions about when to include WAL summaries in incremental backups (Ayush Tiwari)

    This error could result in stale data being included in a combined backup.

    Fix incorrect size estimates for incremental backups (Daria Lepikhova)

    This problem affected progress reporting in pg_basebackup and other places.

    Avoid resetting a replication subscription's two_phase state to pending if it is already enabled (Zhijie Hou)

    Executing ALTER SUBSCRIPTION ... SET (two_phase = true) twice resulted in confused state, potentially allowing data corruption on the subscriber.

    Verify the syntax of the output_plugin_libraries parameter when a value is assigned (Jacob Champion, Hayato Kuroda)

    Previously, a syntactically-incorrect value could be put into postgresql.conf, causing logical replication to fail.

    Reject REPLICA IDENTITY USING INDEX if a key column has an unvalidated NOT NULL constraint (Ante Kresic)

    A replica identity key must be not-null, but this code path would accept cases where that was not yet known to be true.

    Fix logical replication with a lossy identity index (Paul A. Jungwirth, Zhijie Hou)

    Typically identity indexes are btrees, which deliver exact results. However, GiST indexes on multiranges can be used as identity indexes, and they deliver results that require rechecking. Logical replication failed to perform the recheck, so that updates and deletes could target the wrong row on the subscriber.

    Avoid incorrect update of backend status flags during replication slot invalidation (Vlad Lesin)

    An invalidation done by an auxiliary process such as the checkpointer could clobber the status field of an unrelated backend. The consequences of this are difficult to predict, but one possibility is that hot standby feedback could be effectively disabled.

    In logical replication, handle subtransaction aborts better (Bingshuai Li, Hayato Kuroda, Zhijie Hou)

    If a subtransaction that made a catalog update aborts, logical decoding mistakenly still believed that the update was effective, potentially causing incorrect decoding output.

    Avoid race condition when building an initial decoding snapshot (Antonin Houska, Rui Zhao)

    There was a small risk of data corruption from using a snapshot that includes transactions that have committed but not yet set their CLOG status.

    In logical decoding, avoid processing a stream abort event for a subtransaction that was never actually streamed (Andrey Rachitskiy)

    This error could lead to null pointer dereferences or other misbehavior.

    Avoid null-pointer crash with missing replication option values in pgoutput logical replication sender (Zhijie Hou)

    Fix small memory leak in pgoutput with streamed prepared transactions (Ayush Tiwari)

    Fix lost wakeups in physical WAL senders (Alex Speller)

    This fix corrects some cases where a WAL sender process could sleep even though there is data waiting to be sent.

    Fix duplicate creation of temporary replication slot when a WAL receiver follows a timeline switch (ChangAo Chen)

    This mistake led to a “could not create replication slot” error followed by a restart of the WAL receiver, which would then recover, so there was no permanent damage.

    Fix race condition between logical replication subscriber and concurrent index DDL (Mikhail Nikalayeu, Vignesh C)

    Changing the state of a replication target relation's primary key or replica identity index could cause the replication apply logic to miss finding a matching row (but only once per such event).

    Fix incorrect LSNs in WAL decoding error messages (Rahul Yadav)

    These error messages reported the LSN of a WAL record that wasn't the one they were actually complaining about.

    Don't allow REPLICA IDENTITY FULL lookups to select invalid indexes (Mikhail Nikalayeu)

    Previously, logical replication could try to use an index left behind by a failed CREATE INDEX CONCURRENTLY, leading to wrong results since the index is likely incomplete.

    Fix potential use-after-free cases in WAL sender (Ayush Tiwari)

    Avoid use-after-free in jsonb_set_lax() (John Naylor)

    Fix double-free when XMLSERIALIZE(... INDENT) output exceeds 1GB (Jim Jones)

    Fix null-pointer dereferences that could occur when a schema is concurrently dropped (Baji Shaik)

    Avoid null-pointer crash in logical subscription refresh when a relevant relation is concurrently dropped (Satyanarayana Narlapuram, Bharath Rupireddy)

    Fix possible null-pointer dereference when building extended statistics on expressions (Shihao Zhong, Michael Paquier)

    This error was reachable only with unexpected (but legal) behavior of a custom typanalyze function.

    Fix possibly-stale values of pg_locks.waitstart. (Shihao Zhong)

    Harden pgstats code against partially-completed local pgstats entries (Michael Paquier)

    Fix cleanup of reused pgstats entries (Michael Paquier)

    This error led to leakage of pgstats entries, which could result in errors at backend exit or database shutdown.

    Fix memory leaks caused by not releasing all data associated with a WAL reader (Tomás Senart)

    In man

    Original source
  • Nov 12, 2026
    • Date parsed from source:
      Nov 12, 2026
    • First seen by Releasebot:
      Nov 12, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 18.7, 17.12, 16.16, 15.20, 14.25, and 19 RC 2 Released!

    Postgresql releases cumulative updates for supported versions, fixing 52 security vulnerabilities and more than 140 bugs, with improvements to data integrity, backups, and query reliability. PostgreSQL 14 reaches end of life, while PostgreSQL 19 advances to its second release candidate.

    The PostgreSQL Global Development Group has released an update to all supported versions of PostgreSQL, including 18.7, 17.12, 16.16, 15.20, and 14.25, as well as the second release candidate of PostgreSQL 19. This release fixes 52 security vulnerabilities and over 140 bugs reported over the last several months.

    There are several issues that may require you to take extra steps after updating, which are described in detail below. See the "Updating" section for more information on post-update steps you may need to take.

    For the full list of changes, please review the release notes.

    PostgreSQL 14 EOL Notice

    This is the final release of PostgreSQL 14. PostgreSQL 14 is now end-of-life and will no longer receive security and bug fixes. If you are running PostgreSQL 14 in a production environment, we suggest that you make plans to upgrade to a newer, supported version of PostgreSQL. Please see our versioning policy for more information.

    Security Issues

    The following security vulnerabilities are closed in this update release. You can find more details about the vulnerabilities and their affected versions in the links below:

    • CVE-2026-6460: Type confusion after ALTER ... SET DATA TYPE executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-6467: Extension script schema mishandling executes arbitrary SQL (CVSS v3.1: 7.2)
    • CVE-2026-14661: dblink and subscriptions can append to arbitrary files (CVSS v3.1: 8.1)
    • CVE-2026-16237: INSERT ... ON CONFLICT can read or modify rows despite auto-updatable view WHERE condition (CVSS v3.1: 5.4)
    • CVE-2026-16240: pg_basebackup can use backup manifest content as a format string (CVSS v3.1: 3.7)
    • CVE-2026-18447: Output parameter type confusion executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116303: Foreign key and JSON conversions bypass EXECUTE privilege on cast functions (CVSS v3.1: 3.1)
    • CVE-2026-116304: Parallel RECORD typmod use-after-free executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116306: Composite-type change during field assignment executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116307: plperl prepared-query use-after-free executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116308: dict_int reads beyond zero-length tokens (CVSS v3.1: 4.3)
    • CVE-2026-116309: plperl blessed-reference type confusion may execute arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116310: COPY error context uses freed field storage (CVSS v3.1: 4.3)
    • CVE-2026-116311: DROP OWNED can remove restrictive row security policies from non-owned tables (CVSS v3.1: 5.4)
    • CVE-2026-116312: MERGE can place the wrong row in a trigger transition table (CVSS v3.1: 5.4)
    • CVE-2026-116313: vacuumdb --missing-stats-only lets a database owner execute code as the vacuumdb user (CVSS v3.1: 7.2)
    • CVE-2026-116314: pg_restore executes arbitrary code due to missing non-plain archive validation (CVSS v3.1: 8.8)
    • CVE-2026-116315: tsvector_delete() heap buffer overflow executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116316: Security-restricted operations can create types in pg_temp, which later queries of the session find (CVSS v3.1: 8.8)
    • CVE-2026-116317: ts_rank_cd() heap buffer overflow may execute arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116318: pg_dump not-null constraint name allows SQL injection (CVSS v3.1: 8.8)
    • CVE-2026-116319: plperl reentrant return_next() use-after-free executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116320: plperl array and hash conversion use-after-free executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116321: Unterminated name value discloses server memory (CVSS v3.1: 4.3)
    • CVE-2026-116322: Pre-authentication cancel request can leak a spinlock (CVSS v3.1: 5.3)
    • CVE-2026-116323: pltcl reentrant result conversion use-after-free executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116325: reindexdb index name quoting allows SQL injection (CVSS v3.1: 8)
    • CVE-2026-116326: plperl tied-object exceptions follow stale sigjmp_buf (CVSS v3.1: 8.8)
    • CVE-2026-116327: security_barrier analysis can expose hidden values through indirect expressions (CVSS v3.1: 4.3)
    • CVE-2026-116328: Generation memory context integer wraparound executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116329: Statistics import type confusion executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116330: pg_dump tar restore.sql fails to block psql command injection (CVSS v3.1: 8.8)
    • CVE-2026-116331: Min/max aggregate type confusion executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116332: Portal setup use-after-free executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116333: Parallel B-tree array scan reads beyond array bounds (CVSS v3.1: 6.5)
    • CVE-2026-116335: Commutator or negator result-type confusion executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-116336: REINDEX CONCURRENTLY does not block DROP INDEX during index functions (CVSS v3.1: 8.8)
    • CVE-2026-120139: Tuple-size integer wraparound executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-120141: Materialized set-returning function type confusion executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-120142: Dropped-column type confusion executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-120143: Transition-table cursor use-after-free executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-120144: Type-cache invalidation gap executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-120145: Logical replication can write to subscriber system catalogs, executing arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-120146: REASSIGN OWNED bypasses role SET and CREATEDB checks (CVSS v3.1: 4.3)
    • CVE-2026-120147: dblink reentrant disconnect use-after-free executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-120148: Extended-statistics pseudo-type confusion executes arbitrary code (CVSS v3.1: 8.1)
    • CVE-2026-120149: FDW batch-insert mismatch executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-120150: Expanded-record domain-check use-after-free executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-120151: plpgsql record-field type confusion executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-120152: pg_show_all_settings() use-after-free discloses memory (CVSS v3.1: 4.3)
    • CVE-2026-120153: Extension-script substitutions allow SQL injection through object names (CVSS v3.1: 7.2)
    • CVE-2026-120154: INSERT ... ON CONFLICT can read rows despite row security policies (CVSS v3.1: 4.3)

    Bug Fixes and Improvements

    This update fixes over 140 bugs that were reported in the last several months. The issues listed below affect PostgreSQL 18. Many of these issues also affect other supported versions of PostgreSQL.

    • Fix exporting and importing snapshots taken on a standby server. The issue was detected when running a parallel pg_dump against a standby server, and could corrupt both the dump output and the standby server's data. More generally, a transaction that imported a snapshot taken on a standby server could return wrong results.
    • Several fixes for GIN indexes that could lead to index corruption, causing queries to miss rows or to return unrelated rows. If you suspect a GIN index is affected, you should reindex it. See the release notes for more details on the issue, and the "Updating" section for post-update steps.
    • Fix possible index corruption in pg_trgm GiST indexes that could cause searches to miss matching rows. You need to reindex after updating; see the "Updating" section.
    • Fix a case where, after REINDEX CONCURRENTLY rebuilt an index on a TOAST table, later index updates could be missed, leading to missing chunk number errors. If you've encountered this issue, after updating, you'll need to reindex. See the "Updating" section.
    • Disallow NOT NULL NO INHERIT constraints on partitioned tables in all cases, including CREATE TABLE ... LIKE. Previously, this could allow a partition to contain NULL values when it should not. See the "Updating" section for how to find and repair affected constraints.
    • Disable B-tree index deduplication for columns declared as bpchar without a length, which could cause index-only scans to return wrong results. If you have B-tree indexes on bpchar columns, you should reindex them after updating. See the "Updating" section.
    • Several fixes for incremental backups that could produce corrupt backups. We recommend taking a new full backup after updating and using it for subsequent incremental backups. See the "Updating" section.
    • Several fixes for base backups, including avoiding a torn copy of the pg_control file, and avoiding truncated or zero-padded copies of files such as postgresql.auto.conf that are replaced while the backup is running.
    • Rework the planner's join removal implementation. While this is a significant change for an update release, it was made to avoid continued bugs from the previous implementation.
    • Fix possible loss of rows during a table rewrite (for example, CLUSTER or VACUUM FULL) when a row had been updated by a subtransaction that later aborted.
    • Fix parallel vacuum I/O timing reports.
    • Several fixes that could cause data loss or inconsistency after a crash, including starting a checkpoint while creating a multixact or while aborting a prepared transaction. This release also writes the state files of pending prepared transactions atomically, as a crash could previously leave behind an invalid file that prevented the server from starting.
    • Several fixes to the planner that could produce wrong query results, including queries with LATERAL references, outer joins, self-join elimination on tables using inheritance, DISTINCT ON in a subquery with set-returning functions, and queries using non-deterministic collations.
    • Several fixes to partition pruning that could cause rows to be missed, including multi-column RANGE-partitioned tables when a query filters only on the leading columns, DEFAULT partitions on tables using MINVALUE or MAXVALUE bounds, and concurrent updates that could silently skip rows that should be updated.
    • Fix INSERT ... ON CONFLICT to acquire a predicate lock on the conflicting row under SERIALIZABLE isolation. Previously, concurrent updates that should have failed with a serialization error could succeed.
    • Fix MERGE with WHEN NOT MATCHED BY SOURCE when the target row is concurrently deleted. Previously, a WHEN NOT MATCHED BY TARGET action could run instead, giving incorrect results.
    • Several fixes for SQL/JSON functions such as JSON_TABLE and JSON_VALUE that could return incorrect results.
    • Several fixes for logical replication that could cause a subscriber to apply changes incorrectly.
    • Several fixes for standby servers, including avoiding unnecessary replay delays and query cancellations in certain cases.
    • Fix psql to accept multiple COPY ... FROM STDIN commands in a single command string. The fix for CVE-2026-6464 caused psql to reject these.
    • Several fixes that could cause a dump to fail to restore, or cause a restored view to behave differently from the original. These include views and rules that use AT TIME ZONE in a FROM clause or a target alias named set, tsvector and tsquery values that could fail to reload.
    • Fix the server becoming stuck, instead of exiting, if the startup process crashes while the server is restarting after a crash.

    This release also updates time zone data files to tzdata release 2026f. Beginning in November 2026, Canada's Northwest Territories (America/Inuvik) are on year-round UTC-06 and Manitoba (America/Winnipeg) is on year-round UTC-05. This release assumes their TZ abbreviations will be CST and EST respectively (though this could change). It also reflects that Cuba will stay on daylight saving time this winter, and that the EST5EDT, CST6CDT, MST7MDT, and PST8PDT zone names now use their indicated UTC offsets for old timestamps instead of the history of their associated city-named zones.

    Updating

    All PostgreSQL update releases are cumulative. As with other minor releases, users are not required to dump and reload their database or use pg_upgrade in order to apply this update release; you may simply stop PostgreSQL and update its binaries.

    If you suspect that a GIN index is affected by one of the corruption issues fixed in this release, you should reindex it, for example:

    REINDEX INDEX your_index_name;
    

    If you use pg_trgm, you should reindex any GiST indexes that use the gist_trgm_ops operator class.

    If you see missing chunk number errors when reading a table, you should reindex the table, which also reindexes its TOAST table, for example:

    REINDEX TABLE your_table_name;
    

    If you use incremental backups, we recommend taking a new full backup after updating and using it as the basis for subsequent incremental backups.

    If you use partitioned tables, the following query finds NOT NULL NO INHERIT constraints on partitioned tables:

    SELECT conrelid::regclass, conname FROM pg_constraint WHERE contype = 'n' AND connoinherit AND conrelid IN (SELECT oid FROM pg_class WHERE relkind = 'p');
    

    You can remove unwanted constraints with ALTER TABLE ... DROP CONSTRAINT .... Constraints you want to keep should be repaired with ALTER TABLE ... ALTER CONSTRAINT ... INHERIT, which will fail if any of the table's partitions contain NULL values in that column.

    If you have B-tree indexes on bpchar columns (that is, columns declared as bpchar without a length), you should reindex them after updating. Columns declared as char(n) are not affected.

    Users who have skipped one or more update releases may need to run additional post-update steps; please see the release notes from earlier versions for details.

    For more details, please see the release notes.

    A Note on PostgreSQL 19 RC 2

    This release marks the second release candidate of PostgreSQL 19. As a release candidate, PostgreSQL 19 RC 2 will be mostly identical to the initial release of PostgreSQL 19, though some more fixes may be applied prior to the general availability of PostgreSQL 19. PostgreSQL 19 RC 2 also includes the fixes in this update release that apply to PostgreSQL 19.

    The planned date for the general availability of PostgreSQL 19 is November 19, 2026. Please see the "Release Schedule" section for more details.

    Upgrading to PostgreSQL 19 RC 2

    To upgrade to PostgreSQL 19 RC 2 from earlier versions of PostgreSQL, you will need to use a major version upgrade strategy, e.g. pg_upgrade or pg_dump/pg_restore. For more information, please visit the documentation section on upgrading:

    https://www.postgresql.org/docs/19/upgrading.html

    If you use pg_upgrade and have indexes that use full text search, pg_trgm, or fuzzystrmatch, please review the "Migration to Version 19" section of the release notes, as you may need to reindex them after upgrading.

    Changes Since 19 RC 1

    Several bug fixes were applied to PostgreSQL 19 during the RC 1 period. These include:

    • Revert a change that allowed JSON_ARRAY() and JSON_OBJECT() expressions over arrays, composite types, and range types to be used in expression indexes, generated columns, and partition keys, as these indexes could become out-of-date. If you created any of these objects while testing PostgreSQL 19, you need to drop or redefine them before upgrading, as pg_dump/pg_restore and pg_upgrade will fail to recreate them.
    • Fix wrong results in GROUPING SETS queries, where a column not included in the current grouping set could show a value instead of NULL.
    • Fix an infinite loop in first_value() and nth_value() when using IGNORE NULLS with some EXCLUDE frame options.
    • Fix eager aggregation running volatile functions in a join condition once per group instead of once per row.
    • Fix promotion of a standby server waiting indefinitely if a session is blocked sending data to a client that has stopped reading.
    • Fix the LISTEN/NOTIFY queue becoming stuck if a session is interrupted while reading notifications.
    • Fix foreign key checks that could fail with an error when the referencing column's type needs a cast to be compared with the referenced column.
    • Fix performance regressions in hash-based query execution, including hash tables that could be sized far beyond the work_mem limit based on the planner's row estimate.

    For a detailed list of fixes, please visit the open items page.

    Release Schedule

    This is the second release candidate for PostgreSQL 19. Unless an issue is discovered that requires a delay or an additional release candidate, PostgreSQL 19 should be made generally available on November 19, 2026.

    For further information please see the Beta Testing page.

    Original source
  • All of your release notes in one feed

    Join Releasebot and get updates from Postgresql and hundreds of other software products.

    Create account
  • Oct 15, 2026
    • Date parsed from source:
      Oct 15, 2026
    • First seen by Releasebot:
      Oct 15, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 19 RC 1 Released!

    Postgresql releases the first candidate of version 19, bringing bug fixes for REPACK, query planning, logical replication, parallel autovacuum, and JSON output. A second candidate is planned for November 12, with general availability targeted for November 19, 2026.

    PostgreSQL Project

    The PostgreSQL Global Development Group announces that the first release candidate of PostgreSQL 19 is now available for download. As a release candidate, PostgreSQL 19 RC 1 will be mostly identical to the initial release of PostgreSQL 19, though some more fixes may be applied prior to the general availability of PostgreSQL 19.

    The next scheduled update release for supported versions of PostgreSQL, on November 12, 2026, will include a large number of fixes. Because of this, the release team decided to include these fixes in PostgreSQL 19 before its general availability. This means a second release candidate, PostgreSQL 19 RC 2, will be available on the same day as the update release.

    The planned date for the general availability of PostgreSQL 19 is November 19, 2026. Please see the "Release Schedule" section for more details.

    Upgrading to PostgreSQL 19 RC 1

    To upgrade to PostgreSQL 19 RC 1 from earlier versions of PostgreSQL, you will need to use a major version upgrade strategy, e.g. pg_upgrade or pg_dump/pg_restore. For more information, please visit the documentation section on upgrading:

    https://www.postgresql.org/docs/19/upgrading.html

    Changes Since 19 Beta 4

    Several bug fixes were applied to PostgreSQL 19 during the Beta 4 period. These include:

    • Several fixes for REPACK (CONCURRENTLY).
    • Several fixes for pg_plan_advice.
    • Several fixes for new query planner optimizations that rely on whether an expression can be NULL.
    • Several fixes for the automatic enablement of logical replication when wal_level is set to replica.
    • Fix postgres_fdw statistics import to run as the owner of the foreign table instead of the user running ANALYZE.
    • Several fixes for parallel autovacuum.
    • Fix COPY (query) TO ... (FORMAT json) to use the query's column names, including aliases, as the JSON keys instead of the table's column names.

    For a detailed list of fixes, please visit the open items page.

    Release Schedule

    This is the first release candidate for PostgreSQL 19. The release team plans to issue a second release candidate, PostgreSQL 19 RC 2, on November 12, 2026. Unless an issue is discovered that requires a delay or an additional release candidate, PostgreSQL 19 should be made generally available on November 19, 2026.

    For further information please see the Beta Testing page.

    Links

    • Download
    • Beta Testing Information
    • PostgreSQL 19 Beta Release Notes
    • PostgreSQL 19 Open Issues
    • Submit a Bug
    • Donate

    If you have corrections or suggestions for this release announcement, please send them to the [email protected] public mailing list.

    Original source
  • Sep 24, 2026
    • Date parsed from source:
      Sep 24, 2026
    • First seen by Releasebot:
      Sep 25, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 19 Beta 4 Released!

    Postgresql releases PostgreSQL 19 Beta 4 with feature previews, key bug fixes, and several planned features reverted as the project sharpens the path to a stable major release.

    The PostgreSQL Global Development Group announces that the fourth beta release of PostgreSQL 19 is now available for download. This release contains PostgreSQL 19 feature previews ahead of general availability, though some details of the release can change during the beta period.

    You can find information about all of the PostgreSQL 19 features and changes in the release notes:
    https://www.postgresql.org/docs/19/release-19.html

    The next planned release of PostgreSQL 19 is the release candidate, which should occur in early October. Based on testing and evaluation, this means that the PostgreSQL 19 GA may also occur in October. More details will be provided as we move closer to these releases.

    This beta release reverted several features that were originally planned for PostgreSQL 19. The PostgreSQL community strongly believes that, first and foremost, PostgreSQL must be reliable. Additionally, the community strives for a predictable release schedule. Because of this, the community chose to remove some features from the PostgreSQL 19 release so they can be potentially be included in a later major release after more time working through the community development and review process.

    Your testing and feedback help the community ensure that PostgreSQL 19 upholds our standards of delivering a stable, reliable release of the world's most advanced open source relational database. Please read more about our beta testing process and how you can contribute:
    https://www.postgresql.org/developer/beta/

    Upgrading to PostgreSQL 19 Beta 4

    To upgrade to PostgreSQL 19 Beta 4 from an earlier version of PostgreSQL, you will need to use a strategy similar to upgrading between major versions of PostgreSQL (e.g. pg_upgrade or pg_dump/pg_restore). For more information, please visit the documentation section on upgrading.

    Changes Since Beta 3

    Fixes and changes in PostgreSQL 19 Beta 4 include:

    • Revert SQL/PGQ (property graph query) support.
    • Revert online enabling and disabling of data checksums.
    • Revert support for temporal updates/deletes provided by the FOR PORTION OF clause.
    • Revert ALTER TABLE ... MERGE PARTITIONS and ALTER TABLE ... SPLIT PARTITIONS.
    • Remove the pg_get_role_ddl(), pg_get_tablespace_ddl(), and pg_get_database_ddl() functions.
    • Revert a change that forced LC_COLLATE to C in the postmaster process.
    • Several fixes to the performance improvement feature for the foreign key constraint checks.
    • Several fixes for the new REPACK command, including crashes, incorrect behavior with invalid indexes and materialized views, and several permission and error-reporting corrections.
    • Several fixes for the new WAIT FOR command, including a deadlock and clearer reporting of isolation-level errors.
    • Fix validation of an empty FOREIGN_JOIN list in pg_plan_advice.
    • Several fixes for CREATE PUBLICATION ... EXCEPT.
    • Fix logical replication initial table synchronization when replicating from an older PostgreSQL version to v19.
    • Several fixes for logical replication conflict detection.
    • Several fixes for the new autovacuum scoring system, including for TOAST tables.
    • Fix for the COPY FROM SIMD optimization.
    • Fix a crash when accessing a partition whose concurrent detach did not complete.
    • Clarify that failed transactions are reported separately when using pgbench --continue-on-error.

    Please see the release notes for a complete list of new and changed features:
    https://www.postgresql.org/docs/19/release-19.html

    Testing for Bugs & Compatibility

    The stability of each PostgreSQL release greatly depends on you, the community, to test the upcoming version with your workloads and testing tools to find bugs and regressions before the general availability of PostgreSQL 19. As this is a Beta, minor changes to database behaviors, feature details, and APIs are still possible. Your feedback and testing will help determine the final tweaks on the new features, so please test in the near future. The quality of user testing helps determine when we can make a final release.

    A list of open issues is publicly available in the PostgreSQL wiki. You can report bugs using this form on the PostgreSQL website:
    https://www.postgresql.org/account/submitbug/

    Beta Schedule

    This is the fourth beta release of version 19. The PostgreSQL Project is planning to move to the release candidate portion of the release cycle, and will continue to issue release candidates until PostgreSQL 19 is made generally available. For further information please see the Beta Testing page.

    Links

    • Download
    • Beta Testing Information
    • PostgreSQL 19 Beta Release Notes
    • PostgreSQL 19 Open Issues
    • Submit a Bug
    • Donate

    If you have corrections or suggestions for this release announcement, please send them to the [email protected] public mailing list.

    Original source
  • Aug 13, 2026
    • Date parsed from source:
      Aug 13, 2026
    • First seen by Releasebot:
      Aug 13, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 18.6, 17.11, 16.15, 15.19, 14.24 and 19 Beta 3 Released!

    Postgresql releases a major update across supported versions with 28 security fixes, over 110 bug fixes, and the third beta of PostgreSQL 19. It improves stability, query correctness, replication, indexing, and time zone data while calling out post-update checks for GIN, btree_gist, and ltree indexes.

    PostgreSQL Global Development Group Release

    The PostgreSQL Global Development Group has released an update to all supported versions of PostgreSQL, including 18.6, 17.11, 16.15, 15.19, and 14.24, as well as the third beta release of PostgreSQL 19. This release fixes 28 security vulnerabilities and over 110 bugs reported over the last several months.

    This release skips PostgreSQL 18 versions from PostgreSQL 18.4 to 18.6. 18.5 was not shipped due to a regression.

    There are three issues that may require you to take extra steps after updating, which are described in detail below. These issues are related to:

    • Parallel GIN index builds
    • btree_gist
    • ltree

    For the full list of changes, please review the release notes.

    PostgreSQL 14 EOL Notice

    PostgreSQL 14 will stop receiving fixes on November 12, 2026. If you are running PostgreSQL 14 in a production environment, we suggest that you make plans to upgrade to a newer, supported version of PostgreSQL. Please see our versioning policy for more information.

    Security Issues

    The following security vulnerabilities are closed across in this update release. You can find more details about the vulnerabilities and their affected versions in the links below:

    • CVE-2026-6464: psql COPY FROM STDIN early failure processes data lines as psql commands (CVSS v3.1: 8.1)
    • CVE-2026-6469: ALTER TABLE ALTER TYPE resets extended statistics ownership (CVSS v3.1: 3.8)
    • CVE-2026-6470: Fails to check type USAGE privilege (CVSS v3.1: 4.3)
    • CVE-2026-6471: Logical decoding can dlopen arbitrary file (CVSS v3.1: 7.2)
    • CVE-2026-14662: tsvector and tsquery undersize allocations, via integer wraparound (CVSS v3.1: 8.8)
    • CVE-2026-14663: pgcrypto, for OpenSSL-disabled ciphers, silently encrypts to and decrypts from cleartext (CVSS v3.1: 6.5)
    • CVE-2026-14664: Regexp heap buffer overflow executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-14666: Row security caching disregards role modifications (CVSS v3.1: 4.2)
    • CVE-2026-14668: ctid type confusion in selectivity estimator discloses derivative of arbitrary read (CVSS v3.1: 8.1)
    • CVE-2026-14669: to_char heap buffer overflow executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-14670: plperl tied object heap buffer overflow executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-14671: refint plan cache type confusion executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-14672: Observable response discrepancy with non-default scram_iterations provides user existence oracle (CVSS v3.1: 5.3)
    • CVE-2026-14673: amcheck does not clear untrusted search path (CVSS v3.1: 3.8)
    • CVE-2026-14676: pg_stat_statements heap buffer overflow executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-14677: 32-bit pltcl and plperl undersize allocations, via integer wraparound (CVSS v3.1: 8.8)
    • CVE-2026-14678: pg_trgm picksplit reads past end of buffer (CVSS v3.1: 4.3)
    • CVE-2026-14679: Stack buffer overflow in argument match writes 0x0 and 0x1 to server memory (CVSS v3.1: 8.2)
    • CVE-2026-14680: Type confusion via "internal" arguments (CVSS v3.1: 8.8)
    • CVE-2026-14681: Improper enforcement of GSSAPI encryption when coupled with SSL (CVSS v3.1: 4.2)
    • CVE-2026-15741: Expression deparse allows SQL injection via EXTRACT argument (CVSS v3.1: 8.8)
    • CVE-2026-15742: fuzzystrmatch writes effectively-arbitrary addresses, via integer wraparound (CVSS v3.1: 8.8)
    • CVE-2026-16238: Type confusion in pg_restore_attribute_stats() executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-16239: Type confusion in cursor CLOSE + DECLARE executes arbitrary code (CVSS v3.1: 8.8)
    • CVE-2026-16241: ECPG integer underflow can crash the client (CVSS v3.1: 3.8)
    • CVE-2026-18024: ascii() function reads past end of buffer (CVSS v3.1: 4.3)
    • CVE-2026-18408: psql \unrestrict lets superuser of pg_dump origin server execute arbitrary code in psql client (CVSS v3.1: 8.8)
    • CVE-2026-19385: pg_dump heap buffer overflow executes arbitrary code (CVSS v3.1: 8.8)

    Bug Fixes and Improvements

    This update fixes over 110 bugs that were reported in the last several months.

    This specific issue only affects PostgreSQL 14, 15, and 16, but we're highlighting it in the release announcement due to its severity:

    • Fix a self-deadlock that could occur while replaying WAL generated by an older minor version. This regression, introduced in the previous set of minor releases, could cause a standby server following a primary running an older minor version to become stuck.

    The remainder of issues listed below affect PostgreSQL 18. Many of these issues also affect other supported versions of PostgreSQL.

    • Fix parallel GIN index builds to correctly update the table's reltuples value in pg_class. Previously, a parallel worker could report an uninitialized row count, leaving reltuples set to a bogus value (including Infinity or NaN). Such a value can cause autovacuum and autoanalyze to not process the table, and this situation will not self-correct. If you have any tables with GIN indexes, we recommend checking that their reltuples values look reasonable after updating. See the "Updating" section for how to identify and repair affected tables.
    • Several fixes to btree_gist, including for NaN handling for float4/float8 that could give wrong answers for columns containing NaN and correct sorting of bit/bit varying values during index building. You may need to reindex btree_gist indexes on float or bit columns after updating. See the "Updating" section.
    • Fix an integer overflow in ltree comparisons. ltree values containing more than about 14,653 labels could compare incorrectly, which could present as a corrupt B-tree index. If you use ltree, you may need to reindex affected indexes after updating. See the "Updating" section.
    • Fix partition pruning for RANGE-partitioned tables so the DEFAULT partition is no longer skipped in cases where it should be scanned. Previously this could cause rows to be missing from query results.
    • Several fixes for partitioned tables that have foreign-table partitions, including when run-time partition pruning determined that some partitions don't need to be scanned, in-flight requests to foreign servers were not always handled correctly, leading to failures.
    • Several fixes to RETURNING with OLD and NEW.
    • Improve hash join performance when there are multiple join keys and many NULL values.
    • Several fixes to the planner that could produce wrong query results, including value IN (array) tests where the array might be empty, and COUNT() window functions that use an EXCLUDE clause or lack ORDER BY.
    • Add missing checks for the hashability of equality comparisons on container types (arrays, composite types, and ranges). Without these checks, the planner could choose a hash-based plan that then failed at execution with a "could not identify a hash function" error.
    • Fix attaching partitions of indexes that are exclusion constraints, which also fixes dump/restore of partitioned exclusion constraints.
    • Fix REINDEX CONCURRENTLY on an index backing a deferred uniqueness constraint, which could cause false constraint-violation reports.
    • Restore an index-scan optimization that converts a LIKE or regular-expression exact-match pattern into an equality index condition when the index and expression collations differ.
    • Several fixes to jsonpath, including that the @? and @@ operators now correctly raise an error for an undefined variable in the path expression. Previously, because these operators cannot supply variable values, an undefined variable was treated as a JSON null rather than an error, which could also lead to unbounded memory consumption.
    • Ensure access is blocked to other sessions' temporary tables, which could lead to silently incorrect results.
    • Fix "no empty local buffer available" errors during temporary table access when a large effective_io_concurrency setting could allow a single read stream to consume all local buffers.
    • Prevent autovacuum from processing databases in the wrong order (lowest-priority first instead of highest).
    • Restore VACUUM's wraparound failsafe mode to use the full shared buffer pool as intended, which had slowed down emergency vacuuming.
    • Fix possible incorrect decoding of index tuples during GiST and SP-GiST index-only scans, which could emit corrupted data.
    • Fix a race condition in conflict detection under SERIALIZABLE isolation. A conflict could be missed when examining an initially-empty btree index, allowing conflicting transactions to commit and breaking serializability.
    • Fix WAL logging of operations that clear bits in table visibility maps. This could lead to producing incorrect incremental backups or potentially leaving torn-page writes uncorrected.
    • Fix logical decoding of empty prepared transactions. A prepared transaction with no decodable changes could send COMMIT PREPARED or ROLLBACK PREPARED to the output plugin with no preceding PREPARE, which breaks replication for the built-in subscriber.
    • Several fixes to libpq, including ensuring it drains all pending bytes from the SSL or GSS decryption buffer when reading data, avoiding cases where a client waits for data that has already arrived.
    • Fix pg_createsubscriber to clean up objects left on a publisher after failure, including a replication slot.
    • Fix pg_restore with --statistics or --statistics-only so that, when combined with other selective-restore options such as --schema, it restores the expected items, matching the behavior of pg_dump.

    This release also updates time zone data files to tzdata release 2026c, in which Alberta (America/Edmonton) will be on year-round UTC-06 (effectively, permanent DST) beginning in November 2026. This release assumes that their TZ abbreviation will be CST from that time forward (though this could change). It also reflects that Morocco (Africa/Casablanca) will move to permanent UTC+00, without daylight saving transitions, on September 20, 2026.

    Updating

    All PostgreSQL update releases are cumulative. As with other minor releases, users are not required to dump and reload their database or use pg_upgrade in order to apply this update release; you may simply stop PostgreSQL and update its binaries.

    If you have any tables with GIN indexes, we recommend checking their reltuples values after updating. A prior bug in parallel GIN index builds could have left reltuples set to a bogus value (including Infinity or NaN) that prevents autovacuum and autoanalyze from ever processing the table. The following query lists the tables that have a GIN index, along with their current reltuples:

    SELECT DISTINCT t.oid::regclass, t.reltuples FROM pg_class t JOIN pg_index i ON t.oid = i.indrelid JOIN pg_class ic ON i.indexrelid = ic.oid WHERE t.relhasindex AND ic.relam = 2742;
    

    For any table whose reltuples value looks incorrect, run ANALYZE on it (or create another index) to reset the value.

    If you use btree_gist, you should reindex btree_gist indexes on float4 or float8 columns that might contain NaN values, as well as btree_gist indexes on bit or bit varying columns, for example:

    REINDEX INDEX your_index_name;
    

    If you use ltree and have btree indexes over ltree values with very many labels (more than about 14,653), you should reindex those indexes, since they may be corrupt, for example:

    REINDEX INDEX your_index_name;
    

    Users who have skipped one or more update releases may need to run additional post-update steps; please see the release notes from earlier versions for details.

    For more details, please see the release notes.

    A Note on the PostgreSQL 19 Beta

    This release marks the third beta release of PostgreSQL 19.

    In the spirit of the open source PostgreSQL community, we strongly encourage you to test the new features of PostgreSQL 19 on your systems to help us eliminate bugs and other issues. While we do not advise you to run PostgreSQL 19 Beta 3 in production environments, we encourage you to find ways to run your typical application workloads against this beta release.

    Your testing and feedback helps the community ensure that PostgreSQL 19 upholds our standards of delivering a stable, reliable release of the world's most advanced open source relational database. Please read more about our beta testing process and how you can contribute:

    https://www.postgresql.org/developer/beta/

    Upgrading to PostgreSQL 19 Beta 3

    To upgrade to PostgreSQL 19 Beta 3 from an earlier version of PostgreSQL, you will need to use a strategy similar to upgrading between major versions of PostgreSQL (e.g. pg_upgrade or pg_dump/restore). For more information, please visit the documentation section on upgrading.

    Changes Since Beta 2

    Fixes and changes in PostgreSQL 19 Beta 3 include:

    • Revert GROUP BY ALL.
    • Several fixes for the new FOR PORTION OF temporal table syntax.
    • Several fixes for the new logical replication sequence synchronization feature, including a race involving REFRESH SEQUENCES.
    • Fix an "unexpected logical decoding status change" error that could occur when logical decoding is activated concurrently.
    • Fix issues around ownership changes for subscriptions.
    • Fix wrong query results from postgres_fdw when pushing down an array comparison such as field = ANY($1) that involves an implicit type coercion.
    • Fix a crash during foreign-key checks involving a nullable UNIQUE constraint.
    • Fix pg_plan_advice parsing of underscores in numeric literals.
    • Fix a missing FORMAT clause when deparsing JSON_ARRAY(query).

    Please see the release notes for a complete list of new and changed features:

    https://www.postgresql.org/docs/19/release-19.html

    Testing for Bugs & Compatibility

    The stability of each PostgreSQL release greatly depends on you, the community, to test the upcoming version with your workloads and testing tools to find bugs and regressions before the general availability of PostgreSQL 19. As this is a Beta, minor changes to database behaviors, feature details, and APIs are still possible. Your feedback and testing will help determine the final tweaks on the new features, so please test in the near future. The quality of user testing helps determine when we can make a final release.

    A list of open issues is publicly available in the PostgreSQL wiki. You can report bugs using this form on the PostgreSQL website:

    https://www.postgresql.org/account/submitbug/

    If you have corrections or suggestions for this release announcement, please send them to the [email protected] public mailing list.

    Original source
  • Similar to Postgresql with recent updates:

  • Aug 13, 2026
    • Date parsed from source:
      Aug 13, 2026
    • First seen by Releasebot:
      Aug 13, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 18.6

    Postgresql releases a broad security and stability update with many crash, data integrity, and privilege fixes, plus improvements to logical decoding, replication, planner behavior, libpq, and contrib modules. It also adds OpenSSL 4 support and updates time zone data to tzdata 2026c.

    This release contains a variety of fixes from 18.4. For information about new features in major release 18, see Section E.6.

    Note: 18.5 was never released, due to a regression discovered post-wrap.

    A dump/restore is not required for those running 18.X.

    However, the first three security entries below describe configuration adjustments and data cleanups that you may need to make after updating.

    Also, if you have any GIN indexes, see the changelog entry below about possibly-corrupt reltuples values for their tables.

    Also, if you use contrib/btree_gist or contrib/ltree, you may need to reindex indexes made with those extensions; see the relevant entries below.

    Also, if you are upgrading from a version earlier than 18.2, see Section E.4.

    Security

    • Restrict logical decoding output plugins to the set specified by a new server parameter output_plugin_libraries (Jacob Champion) (§)
      Previously, a replication user could select any loadable library for logical decoding, allowing exploits of various sorts. To allow locking this down without breaking setups that worked before, introduce a whitelist of allowed output plugins.
      By default, only the output plugins shipped as part of PostgreSQL (pgoutput and test_decoding) are included in output_plugin_libraries. Installations that rely on other output plugins must add them after updating the server, for example output_plugin_libraries = 'pgoutput, test_decoding, my_trusted_decoder'
      Additionally, pg_upgrade --check will fail if the output_plugin_libraries parameter on the new cluster does not permit the plugins of logical replication slots on the old cluster, when migrating from versions 17 and later. Make necessary additions to the new cluster's setting before performing pg_upgrade.
      The PostgreSQL Project thanks Vladimir Tokarev and Yu Kunpeng for reporting this problem. (CVE-2026-6471)

    • Fix contrib/pgcrypto's PGP encryption to detect unsupported ciphers (Daniel Gustafsson) (§)
      Previously, if OpenSSL rejected the requested cipher (for example, because it is running in FIPS mode, or the legacy provider hasn't been loaded), pgcrypto failed to notice the failure and simply XOR'd the non-encrypted block with the plaintext, rendering the “encryption” trivially breakable. This will typically occur with deprecated or non-FIPS cipher algorithms (cipher-algo=blowfish/bf, twofish, cast5, or 3des).
      By default, pgcrypto will now fail to decrypt any messages that were affected in this way. To allow retrieval of such data, a new option ignore-cipher-failure has been added to pgp_pub_decrypt() and pgp_sym_decrypt(). Setting ignore-cipher-failure=1 will restore their previous behavior, allowing the faulty encryption wrapper to be stripped off:

    pgp_sym_decrypt(encrypted_column, any key, 'ignore-cipher-failure=1')
    

    Once the affected messages are identified and stripped of their wrappers, they can then be re-encrypted with a modern algorithm. It is important however that the behavior of OpenSSL be the same as it was when the faulty messages were created: if the set of unsupported algorithms is not the same, this approach will not work. See the documentation for ignore-cipher-failure.
    The PostgreSQL Project thanks Shishir Sharma for reporting this problem. (CVE-2026-14663)

    • Fix psql to skip in-line data following a scripted COPY ... FROM STDIN command, even if the COPY fails before sending PGRES_COPY_IN (Tom Lane) (§)
      Previously, if a COPY command failed at startup (for instance, because the target table doesn't exist) psql would not realize that and would proceed to read the following in-line data as SQL commands. In the best case that's wrong and in the worst case it's a SQL-injection hazard. Teach psql to recognize syntactically-valid COPY ... FROM STDIN commands and to skip data on its own authority if the server doesn't respond with PGRES_COPY_IN.
      While this fix is unlikely to affect any production SQL scripts, test scripts might intentionally exercise failing COPY ... FROM STDIN commands. Those will need to gain a . data terminator line after each such command.
      The PostgreSQL Project thanks Alexander Lakhin for reporting this problem. (CVE-2026-6464)

    • Cross-check the output row type of a portal running EXECUTE or FETCH (Robert Haas) (§)
      EXECUTE and FETCH use two portals: an outer one for the statement itself, and an inner one running the query being executed on its behalf. It was previously possible to make the declared row types of the two portals diverge, leading to server memory disclosure and arbitrary code execution.
      The PostgreSQL Project thanks Ben Morris (in collaboration with Claude and Anthropic Research) and Peter Geoghegan for reporting this problem. (CVE-2026-16239)

    • Fix buffer overrun with long time zone abbreviation in to_char() (Tom Lane) (§)
      This can easily crash the server, and exploits leading to arbitrary code execution have been reported.
      The PostgreSQL Project thanks Hcamael, Amjad Shahzad, Tan Zhen of AntAISecurityLab, Tomer Fichman, Zheng Yu, Amy Burnett (OpenAI Codex Security), Rick de Jager, Heewon Song, Sylvie Mayer, Aleksander Alekseev, and Hillai Ben Sasson for reporting this problem. (CVE-2026-14669)

    • Fix buffer overrun in regexp match/split functions (Masahiko Sawada) (§)
      If passed invalidly-encoded data, these functions could write past the end of their conversion buffer.
      The PostgreSQL Project thanks Francesco Verardi for reporting this problem. (CVE-2026-14664)

    • Harden the ascii() function against invalid input (Michael Paquier) (§)
      By supplying invalidly-encoded input, this function could be coaxed to read and return a few bytes of data that it shouldn't. In assert-enabled builds, its assertions could be triggered too.
      The PostgreSQL Project thanks Hcamael for reporting this problem. (CVE-2026-18024)

    • Fix multirange type handling in pg_restore_attribute_stats() (OpenAI Security Research Team) (§)
      pg_restore_attribute_stats() treated multirange types just like their underlying range type. This works correctly for the bounds histogram, but it was wrong for all the other statistics kinds.
      The PostgreSQL Project thanks Amy Burnett (OpenAI Codex Security) for reporting this problem. (CVE-2026-16238)

    • Make scalarineqsel() check that a constant it expects to be of type tid actually is (Tom Lane) (§)
      This expectation will hold for all the built-in operators that use this estimator, but a maliciously-constructed operator could violate it, leading to a crash or server memory disclosure.
      The PostgreSQL Project thanks Hcamael for reporting this problem. (CVE-2026-14668)

    • Harden tsvector and tsquery code against overly long values (both individual lexemes and total vector/query length) (Tom Lane) (§)
      The documented limits were not enforced in all code paths.
      The PostgreSQL Project thanks Yuhang Wu, Zhenpeng Lin, Zheng Yu, and Hcamael for reporting these problems. (CVE-2026-14662)

    • Fix various places that mistakenly assumed they would not have to deal with more than FUNC_MAX_ARGS function arguments (Tom Lane) (§)
      Notably, the server's actual limit on the number of arguments to an aggregate function is FUNC_MAX_ARGS - 1, but the parser failed to enforce that, creating hazards downstream.
      The PostgreSQL Project thanks Zheng Yu, ylwangtju, and Masahiko Sawada for reporting these problems. (CVE-2026-14679)

    • Reject calls from SQL to functions that take or return type internal (Tom Lane) (§)
      The existing defenses against doing this have been shown to be insufficient, so add more explicit checks.
      The PostgreSQL Project thanks Amy Burnett (OpenAI Codex Security) for reporting this problem. (CVE-2026-14680)

    • Preserve the ownership of extended statistics objects when they are rebuilt by ALTER TABLE (Masahiko Sawada) (§)
      Previously, the role running ALTER TABLE gained ownership of such objects, but that seems inappropriate.
      The PostgreSQL Project thanks Noah Misch for reporting this problem. (CVE-2026-6469)

    • When deparsing an EXTRACT() function call, quote the field name if needed (Nathan Bossart) (§)
      The parser accepts any string literal as a field name in EXTRACT(), deferring validation to execution. If the call is stored and deparsed (for example during pg_dump), the string body was regurgitated verbatim, allowing SQL injection.
      The PostgreSQL Project thanks Ben Morris (in collaboration with Claude and Anthropic Research) for reporting this problem. (CVE-2026-15741)

    • Check for USAGE privilege on data types in places that formerly failed to check that (Nathan Bossart) (§)
      CREATE TYPE AS RANGE did not check, nor did ALTER TABLE OF, nor did commands that create stored expressions. These omissions allowed roles without USAGE privilege to nonetheless create objects depending on the type, possibly blocking the type's owner from changing the type later.
      The PostgreSQL Project thanks Jingzhou Fu for reporting this problem. (CVE-2026-6470)

    • Invalidate role-dependent cached plans after role changes (Ilya Staroverov, Shinya Kato, Nathan Bossart) (§)
      Role membership, role attribute, and database ownership changes may impact the expected behavior of row-level security policies, but previously we'd continue to use cached plans that were made according to the old state of affairs.
      The PostgreSQL Project thanks Ilya Staroverov and Shinya Kato for reporting this problem. (CVE-2026-14666)

    • Reject GSSEncRequest after direct SSL connection (Michael Paquier) (§)
      After establishing a TLS-encrypted connection, the server would still accept a request for GSSAPI encryption. If that succeeded, the connection would proceed using TLS encryption, but it would look like a GSS connection to the pg_hba rules. Thus, a pg_hba policy intending to disallow TLS would not be enforced correctly.
      The PostgreSQL Project thanks p4p3r for reporting this problem. (CVE-2026-14681)

    • Make mock SCRAM authentication secrets more plausible (Nathan Bossart) (§)
      If a SCRAM login is attempted against a role that doesn't exist or doesn't have a SCRAM secret, we generate a mock secret and carry out the authentication handshake anyway, to avoid revealing these facts to an attacker. But the mock secret was made with a fixed iteration count, which in itself can be an observable response discrepancy. Use the configuration setting scram_iterations instead, to make the mock secret look more like the installation's real secrets.
      The PostgreSQL Project thanks Radim Marek for reporting this problem. (CVE-2026-14672)

    • Fix out-of-bounds writes in ecpg applications caused by invalid bytea data received from the server (Michael Paquier) (§)
      ecpg assumed without checking that any bytea value must begin with \x. A broken or malicious server might send a string shorter than 2 bytes, resulting in memory clobber in the application.
      The PostgreSQL Project thanks ylwangtju for reporting this problem. (CVE-2026-16241)

    • Do not do backquote expansion on the argument of psql's \unrestrict command (Nathan Bossart) (§)
      This oversight in the fix for CVE-2025-8714 allows a malicious server to inject shell commands into plain-text dump output that will be run at restore time on the machine running psql, the exact scenario that CVE-2025-8714 intended to prevent.
      The PostgreSQL Project thanks Lucas Velgus, Filip Janus, and Daniel Bakker for reporting this problem. (CVE-2026-18408)

    • Remove pg_dump's assumption that pg_proc.protrftypes cannot have more than FUNC_MAX_ARGS entries (Tom Lane) (§)
      Since there could be entries for both input and output arguments, it's feasible for this array's length to exceed FUNC_MAX_ARGS (which constrains only input arguments). Even if that were not so, pg_dump cannot assume that the server was built with the same value of FUNC_MAX_ARGS that it has. An overrun would lead to a memory clobber inside pg_dump.
      The PostgreSQL Project thanks Masahiko Sawada for reporting this problem. (CVE-2026-19385)

    General

    • Harden PL/Perl against “tied” Perl arrays and hashes (Tom Lane) (§)
      A tied object that doesn't behave like a regular one could lead to memory overwrite, or to constructing a corrupt result array (which would likely cause problems later).
      The PostgreSQL Project thanks Hcamael for reporting this problem. (CVE-2026-14670)

    • Fix integer overflows in memory-allocation calculations in PL/Perl and PL/Tcl (Heikki Linnakangas) (§)
      This is the same type of problem as CVE-2026-6473, just in a different part of the code, and is fixed in the same way.
      The PostgreSQL Project thanks the Tulya Project (Team Dhiutsa, Bitecope Technologies Private Ltd) for reporting this problem. (CVE-2026-14677)

    • Ensure that contrib/amcheck functions restrict search_path before executing index expressions (Noah Misch) (§)
      Because amcheck will run such index expressions as the owner of their tables, a caller could potentially hijack search_path-dependent functions to run arbitrary code as the table owner. By default this is not a vulnerability because only superusers are allowed to call amcheck functions; but if that privilege was granted out, it created a larger hazard than the documentation suggests.
      The PostgreSQL Project thanks Yuelin Wang and Jacob Brazeal for reporting this problem. (CVE-2026-14673)

    • Fix integer overflows in contrib/fuzzystrmatch's levenshtein() and levenshtein_less_equal() functions (Nathan Bossart) (§)
      Passing large cost values to these functions could cause integer overflows, thereby producing nonsensical results, and even causing out-of-bounds writes in some cases.
      The PostgreSQL Project thanks Ben Morris (in collaboration with Claude and Anthropic Research) for reporting this problem. (CVE-2026-15742)

    • Fix buffer overrun in contrib/pg_stat_statements (Álvaro Herrera) (§)
      Query normalization didn't accurately account for the amount of space the normalized string would require.
      The PostgreSQL Project thanks Sajeeb Lohani (with TrendAI Zero Day Initiative) and Yuelin Wang for reporting this problem. (CVE-2026-14676)

    • Fix datatype error in contrib/pg_trgm's GiST picksplit function (Heikki Linnakangas) (§)
      This mistake resulted in reading past the end of the buffer, typically causing bad split decisions; but a crash could ensue if you're very unlucky.
      The PostgreSQL Project thanks Mehmet D. Ince for reporting this problem. (CVE-2026-14678)

    • Remove the plan cache in contrib/refint (Ayush Tiwari) (§)
      This caching behavior has several serious bugs, notably that check_foreign_key() embeds the new key values in its cascade-UPDATE queries, so a cached plan reuses the originally-needed values rather than the key values that should be used. The simplest solution is to remove it.
      The PostgreSQL Project thanks Hcamael for reporting this problem. (CVE-2026-14671)

    • Ensure that parallel GIN index builds update the table's pg_class.reltuples value correctly (Jan Nidzwetzki, Tomas Vondra) (§)
      A parallel worker could report an uninitialized value for the number of rows it processed, leading to a bogus value for reltuples, even Infinity or NaN. Such values could lead to subsequent autovacuum and autoanalyze operations never deciding that the table needs to be processed. If so, the situation will not self-heal. A manual ANALYZE command, or creation of another index, will be needed to reset reltuples to the correct value. If you have any tables with GIN indexes, it's recommended to check to see if their reltuples entries look sane. A query such as this may be helpful:

    SELECT DISTINCT t.oid::regclass, t.reltuples
    FROM pg_class t
      JOIN pg_index i ON t.oid = i.indrelid
      JOIN pg_class ic ON i.indexrelid = ic.oid
    WHERE t.relhasindex AND ic.relam = 2742;
    
    • Fix mis-handling of asynchronous reads when rescanning an asynchronous Append plan node (Alexander Korotkov, Gleb Kashkin, Etsuro Fujita) (§)
      When an upper plan node rescans an Append before having read the entire Append output, we need to discard any in-flight requests sent to external servers (by postgres_fdw for example). This was not done correctly in cases where a subplan has parameter changes or is discarded by partition pruning in the next scan. The outcome could be incorrect query results, an infinite loop, or an assertion failure.

    • Fix error in partition pruning for RANGE-partitioned tables (David Rowley) (§)
      In some cases the DEFAULT partition would be skipped when it should not be, which could lead to rows missing from query results.

    • Correctly update foreign-data-wrapper state in a ModifyTable plan node after pruning result relations (Ayush Tiwari, Rafia Sabih) (§)
      Previously, if run-time partition pruning determined that some partitions of a partitioned target table need not be scanned and the table had any foreign-table partitions, a crash or erroneous behavior was likely.

    • Fix missed concurrent update in UPDATE with RETURNING OLD on a table that has a BEFORE UPDATE trigger (Dean Rasheed) (§)
      If the target row was concurrently updated, then at isolation level READ COMMITTED any OLD values in RETURNING should reflect the updated row. But stale values were returned if there was a trigger (although the trigger itself, and the final output row, saw the correct values).

    • Fix hash join performance issue when there are multiple join keys and many NULL values (David Rowley) (§)
      Null-keyed tuples should not get inserted into the hash table, since they will never match any other tuples. The code got this wrong if the null was in a non-last join column, bloating the hash table quite a lot if many inputs contain nulls.

    • Fix parsing of parenthesized OLD / NEW in RETURNING expressions (Marko Grujic) (§)
      Expressions such as (old).colname and (old).* were mis-handled, effectively converting them to NEW references.

    • Fix planner's nullability and strictness checks for value IN (array) expressions (Ayush Tiwari) (§)
      These checks should only succeed if the array operand is known to be non-empty, but that consideration was missed, allowing optimizations to be applied that should not be. This could result in wrong query answers if the array actually was empty.

    • Fix incorrect join removal logic (Matheus Alcantara, Richard Guo) (§)
      In edge cases, it was possible for a constant output value coming from within the nullable side of an outer join to not be replaced by NULL when it should be.

    • Clean up PlaceHolderVars more thoroughly during join removal (Richard Guo, Arne Roland) (§)
      This fix corrects various edge cases that could trip assertions or result in incorrect plans.

    • Add missed checks for hashability of equality comparisons on container datatypes (arrays, composites, ranges) (Andrei Lepikhov, Tom Lane) (§)
      The planner must verify hashability of the container's component type(s) before deciding it can use a hash-based plan type. This step was missed in some places, leading to “could not identify a hash function” failures at execution.

    • Avoid pushing WHERE clauses down past a grouping step that has a different equivalence rule (Richard Guo) (§)
      A test on a grouping column that is grouped by a nondeterministic collation is safe to push down only if it is a comparison using that same collation. Otherwise it might filter some rows the grouping would have merged.

    • Fix mis-optimization of COUNT window functions that have an EXCLUDE clause or lack ORDER BY (Chengpeng Yan, David Rowley) (§)
      These window functions were treated as monotonic when they should not be, allowing wrong answers to be computed.

    • Avoid “cache lookup failed for collation 0” error when planner looks up statistics for a column of type "char" (Feng Wu) (§)

    • Fix ALTER COLUMN ... DROP EXPRESSION to work when there are multiple levels of partitions (Alberto Piai) (§)

    • Fix attaching partitions of indexes that are exclusion constraints (Japin Li) (§)
      Notably, this oversight broke dump/restore of partitioned exclusion constraints.

    • Prevent setting NO INHERIT on partitioned NOT NULL constraints via ALTER CONSTRAINT (Andreas Karlsson) (§)
      NOT NULL constraints on partitioned tables are supposed to be inherited by all partitions, and therefore must not be marked NO INHERIT. This rule was correctly enforced by constraint creation, but not by ALTER TABLE ... ALTER CONSTRAINT.

    • Disallow renaming a rule to _RETURN (Tom Lane) (§)
      That name is reserved for a view's ON SELECT rule, but ALTER RULE allowed renaming other rules to _RETURN, causing trouble later.

    • Fix missing lock release for role membership grants in DROP OWNED BY (Jeff Davis) (§)
      This oversight resulted in a warning message, followed by retaining a lock on the membership grant until the end of the transaction.

    • Fix failure of EXPLAIN when deparsing SQL/JSON aggregates (Richard Guo) (§)
      Some plan structures resulted in “invalid JsonConstructorExpr underlying node type” errors.

    • Fix use of REINDEX CONCURRENTLY with a deferred uniqueness constraint (Nitin Motiani) (§)
      The transient index copy created during REINDEX CONCURRENTLY was incorrectly marked as enforcing immediate uniqueness, causing spurious reports of constraint violation.

    • Fix LIKE matching with nondeterministic collations and backslashes (Nitin Motiani, Tom Lane) (§)
      When using a nondeterministic collation, LIKE mishandled an escaped backslash (\), treating it as effectively not there. It also did the wrong thing with a leading backslash preceding an ordinary character; in that case the backslash should be effectively ignored, but it caused the ordinary character to be matched exactly rather than allowing the nondeterministic collation to decide if there's a match.

    • Fix LIKE /regex optimization for indexscan with exact-match pattern (Jelte Fennema-Nio) (§)
      Refactoring for LIKE with non-deterministic collations accidentally broke the optimization for converting a LIKE or regex exact-match pattern to an equality index condition when the index collation doesn't match the expression collation. Among other things, that made psql's \d \tablename command much slower.

    • Fix matching of localized month/day names in to_date() (Heikki Linnakangas) (§)
      The matching logic misbehaved in cases where case-folding changes the byte length of the string.

    • Correct case-folding rules for Greek final sigma (Jeff Davis) (§)
      If the string is preceded only by Case Ignorable characters, don't consider it to be a final sigma. This only affects the built-in pg_unicode_fast locale.

    • Fix incorrect NFC recomposition for Hangul U+11A7 (TBASE) (Diego Frias, Michael Paquier) (§)
      This character was treated as a valid T syllable, which it is not, and hence silently swallowed during normalization.

    • Avoid possible truncation of output lexemes in case-insensitive synonym dictionaries (Jeff Davis) (§)
      If folding to lower case increased the byte length of a lexeme, it was incorrectly truncated to its original byte length when emitted.

    • Defend against truncated UTF-8 characters in case-conversion logic (Jeff Davis) (§)

    • Fix typo in hash_record_extended() (Man Zeng) (§)
      The code failed to initialize the second isnull argument passed to FunctionCallInvoke(). This is harmless for existing in-core extended hash support functions, which will not examine that value. However, extension-provided hash functions could be affected if they inspect PG_ARGISNULL(1).

    • Fix pg_get_publication_tables() to not fail if a publishable table is dropped concurrently (Bharath Rupireddy) (§)

    • Prevent satisfies_hash_partition() from crashing with VARIADIC NULL (Robert Haas) (§)

    • Report invalid-weight errors more cleanly and consistently in tsvector_filter() and allied functions (Ewan Young) (§)
      In particular, report weight characters that are not printable ASCII in octal form (\nnn), as charout() would render them. This avoids possibly producing an invalidly-encoded error message.

    • Reject out-of-range timestamp shift values in uuidv7() (Baji Shaik) (§)
      The shift value must not be so large as to produce a timestamp out of the range that a v7 UUID can represent. Previously, a garbage UUID value was produced.

    • Fix mishandling of namespace nodes in xpath() (Michael Paquier) (§)
      This fix avoids an unexpected “could not copy node” error.

    • Fix jsonpath's .decimal method to not throw a hard error for incorrect precision or scale (Ewan Young) (§)
      Silent mode should suppress these errors, but failed to.

    • Fix NULL-pointer crash when IS JSON or similar constructs have an argument that is of string category but lacks a cast to type text (Ayush Tiwari) (§)
      There are no such data types in core PostgreSQL, but the problem is reachable with some extension types.

    • Ensure that SQL/JSON ON EMPTY / ON ERROR DEFAULT values are coerced to the correct typmod (Ewan Young) (§)
      For example, the declared precision and scale of a numeric target column were not applied to the default value.

    • Avoid machine-dependent behavior when dividing the smallest possible money value by -1 (Andrey Rachitskiy) (§)

    • Fix crash after out-of-memory failure partway through creation of a cache entry for a text search dictionary (Tom Lane) (§)

    • Fix memory-safety bugs in processing of incorrect ispell/hunspell dictionary files (Andrey Rachitskiy) (§)

    • Prevent access to other sessions' temporary tables (Jim Jones, Daniil Davydov, Alexander Korotkov) (§)
      Some code paths failed to prevent this, leading to silently wrong (inconsistent) results.

    • Prevent “no empty local buffer available” errors during temporary table access (Melanie Plageman) (§)
      Limit the number of local buffers that the read streaming mechanism is allowed to use. Previously, a large value of effective_io_concurrency could allow a single stream to use all the buffers, resulting in failure.

    • Fix the order in which autovacuum processes databases (Rustam Khamidullin) (§)
      It was unintentionally processing databases from lowest to highest score, when it should be doing the reverse.

    • Restore full use of shared buffer pool in VACUUM's wraparound failsafe mode (Melanie Plageman) (§)
      An ordinary VACUUM is limited to use just a few shared buffers, so as not to impinge too much on other processing. However, in failsafe mode we want to reclaim transaction IDs as quickly as possible, so that limit is supposed to be abandoned to allow vacuuming to proceed as fast as possible. This behavior was accidentally broken during refactoring in v18; restore it.

    • Fix memory leak in parallel vacuum worker processes (Baji Shaik) (§)
      Progress reports from a parallel worker leaked about 1kB per report, with the waste accumulating for the life of the worker process.

    • Honor query cancel and vacuum delay during GIN index posting-tree cleanup (Paul Kim, Alexander Korotkov) (§)
      The posting tree for a common value can be large, so that this missed check could allow vacuum to run for a long time before noticing an interrupt.

    • Fix possible mis-decoding of index tuples during GiST and SP-GiST index-only scans (Peter Geoghegan) (§)
      This error could lead to emitting corrupted data from an index-only scan plan. The only affected core opclass is GiST's range_ops, and it could only fail if the range column were not the first index column.

    • Ensure that the new last block of a bulk-extended table is added to its free space map promptly (Jingtang Zhang) (§)
      An off-by-one error caused the last block of a multi-block table extension to not be marked as free in the map. This would eventually get corrected by vacuum, but meanwhile the space wouldn't be used.

    • Avoid possible double-free or infinite error recovery loop in resource cleanup during transaction abort (Tom Lane) (§)

    • When creating directories, tolerate concurrent creation of the same directory (Andrew Dunstan, Tom Lane) (§)

    • Fix JIT-compiled tuple deconstruction code to account correctly for virtual generated columns (David Rowley) (§)

    • Prevent creation of dangling object dependencies by acquiring a shared lock on any object being depended on (Bertrand Drouvot) (§)
      The shared lock will conflict with any attempt to drop the depended-on object, eliminating the race condition that formerly existed. For example, if one session drops a schema (that appears empty to it) concurrently with some other session creating a function in that schema, previously both transactions could commit, leaving an invalid function definition behind. Now, one transaction or the other will fail.

    • Fix race condition in conflict detection for SERIALIZABLE isolation mode (Peter Geoghegan) (§)
      A conflict could be missed when examining an initially-empty btree index, allowing failure of serializability due to improperly allowing conflicting transactions to commit.

    • Fix race condition in ProcSignalBarrier code (Masahiko Sawada) (§)
      This error could result in processes getting stuck, typically after reporting “still waiting for backend with PID nnnn to accept ProcSignalBarrier”.

    • Fix race conditions when a set of processes that belong to the same lock group exit at the same time (Vlad Lesin) (§)
      These errors could lead to PANIC aborts, with messages such as “latch already owned”. The issue does not normally arise in regular parallel query, since the leader won't exit before seeing its workers finish; but some extensions reach the problem.

    • Fix WAL logging of operations that clear bits in tables' visibility maps (Melanie Plageman, Andres Freund) (§)
      Such VM changes were missed by the WAL summarizer, potentially leading to incorrect incremental backups. We also failed to log full-page images of such VM pages when needed, potentially allowing torn page writes to go uncorrected. This could lead to misbehavior later, such as wrong results from index-only scans.

    • Prevent WAL summarizer process from getting stuck at a timeline switch (Robert Haas) (§)

    • Fix race with timeline selection in logical decoding during standby promotion (Bertrand Drouvot) (§)
      Logical decoding being performed on the standby could fail with a “requested WAL segment has already been removed” error. A repeat attempt would succeed, so there was no permanent problem but there was an availability hazard.

    • Avoid exposing a WAL receiver's full connection string during timeline jumps (Chao Li) (§)
      The pg_stat_wal_receiver view should show a sanitized version of the connection string, without sensitive data. But it transiently showed the full string when we re-use an existing WAL receiver.

    • Use run-time checks, not just Asserts, to verify the correct number of columns in tuples received during logical replication (Varik Matevosyan) (§)
      A malicious or buggy publisher could send inconsistent numbers of columns. While we could not find a scenario in which this would have serious ill effects, extra caution seems warranted.

    • Clean up quoting of string parameters within constructed replication commands (Tom Lane) (§)
      Various places that generate replication commands were not being adequately careful about quoting replication slot names and other parameters that need to be inserted into those commands. This could result in unexpected syntax errors in those commands. In principle, a crafted replication slot name could result in SQL injection; but such a scenario seems very unlikely to occur in practice, since replication operations can only be invoked by highly-privileged users and there is no reason for them to use a slot name coming from an untrustworthy source.

    • Fix logical decoding of empty prepared transactions (Masahiko Sawada) (§)
      A prepared transaction that did not cause any decodable updates could result in sending COMMIT/ROLLBACK PREPARED to the output plugin with no preceding PREPARE. For the built-in subscriber this breaks replication, and other plugins will probably not like it either.

    • Fix corruption of unlogged sequences after standby promotion (Fujii Masao) (§)
      Previously, if an unlogged sequence was created on the primary and replicated to a standby, accessing the sequence after promoting the standby could fail with “bad magic number in sequence” or related errors.

    • Fix cascading standby reconnect failure after archive fallback (Marco Nenciarini) (§)
      A cascading standby could fail to reconnect to its upstream standby with “requested starting point ... is ahead of the WAL flush position” after falling back to archive recovery.

    • Prevent accepting hot-standby connections before WAL replay has reached a consistent database state (Nikhil Sontakke) (§)

    • Do not try to clear pg_database.dathasloginevt locally on a standby server (Ayush Tiwari) (§)
      Event trigger cleanup tried to perform that action on standby servers as well as the primary. That can't work on a standby, and there's no need anyway since replay of the primary's database change will soon fix it.

    • Avoid race condition while dropping obsolete replication slots (Xuneng Zhou) (§)
      An incorrect unlock and log message could occur if another session immediately re-used the dropped slot's shared-memory entry.

    • Avoid race condition while dropping ephemeral replication slots (Zhijie Hou) (§)
      The slot-releasing code performed some additional updates to the replication slot's shared-memory entry after releasing the slot. This is unsafe since another session could immediately re-use the dropped slot's shared-memory entry. Skip those updates in the case of an ephemeral slot.

    • Fix stale progress reports during logical replication table synchronization (Shinya Kato) (§)
      Previously, the pg_stat_progress_copy view in the subscriber would continue to show the initial COPY operation as active even after the data copy had finished. The stale entry remained visible until synchronization caught up with the publisher.

    • Clear base backup progress on backup failure (Chao Li) (§)
      Previously the pg_stat_progress_basebackup view would continue to show a stale progress entry after a failure, until the replication client disconnected. pg_basebackup normally disconnects immediately, but other clients might not.

    • Fix possible PANIC due to concurrent drop of pgstats entries when track_functions is enabled (Sami Imseih, Michael Paquier) (§)

    • Clean up broken local pgstats entry after failing to obtain space for the corresponding shared hashtable entry (Niall Newman) (§)
      Failure to do this led to a null-pointer dereference the next time the local entry was used.

    • Avoid recording incorrect I/O operation statistics after a failed read or write (Bertrand Drouvot) (§)

    • In PL/Perl, avoid NULL pointer dereference crash when working with an invalid PostgreSQL::InServer::ARRAY object (Xing Guo) (§)

    • In PL/Python, properly check for errors when working with sequence and mapping objects (Richard Guo) (§)
      Previously, a broken object or an unhandled exception could result in a NULL pointer dereference crash.

    • In libpq, always drain all pending bytes from the SSL or GSS decryption buffer during pqReadData() (Jacob Champion) (§)
      This avoids edge cases where libpq or its calling application waits for more data to arrive on the socket, but actually all the data has already arrived.

    • Improve libpq's handling of out-of-memory conditions (Anthonin Bonnefoy) (§)

    • Fix libpq's trace facility to print new-style BackendKeyData and CancelRequest messages correctly (Anthonin Bonnefoy) (§)

    • Allow libpq to accept ParameterDescription messages exceeding 30000 bytes (Ning Sun) (§)
      Previously, this message type was not among those that libpq's validity heuristics believed could be long. The limit resulted in failure for prepared queries having more than 7498 parameters, which is unlikely but supported.

    • Fix null-pointer crash in ecpg compiler (Jehan-Guillaume de Rorthais) (§)
      ecpg failed on a DECLARE section containing a union nested inside a struct.

    • Reject multiple descriptor header items in ecpg's GET/SET DESCRIPTOR statements (Masashi Kamura) (§)
      Previously the grammar allowed this syntax, but broken C code was generated. Adjust the grammar and the documentation to allow only one header item.

    • Fix issues with deferred errors in pipeline mode in psql (Michael Paquier) (§)
      psql could get stuck or suffer an assertion failure in some scenarios where the server reports an error in response to a Sync message, such as a deferred constraint violation.

    • Make line widths match in psql's expanded aligned output format (Pavel Stehule) (§)
      When the table's data rows are narrower than the record header lines, widen the data rows to match the headers, avoiding unsightly output.

    • Enforce the intended upper limit for psql's special variable WATCH_INTERVAL (Sven Klemm, Daniel Gustafsson) (§)
      If a too-large value was given, psql reported an error but applied the setting anyway.

    • Fix psql's privilege check for showing database size in \l+ (Christoph Berg) (§)
      The underlying server function permits users who have pg_read_all_stats privileges to see the sizes of all databases, even if they lack CONNECT privilege. But psql was unaware of that provision and would not call the function unless the user has CONNECT privilege.

    • Fix psql's tab completion for \df to consider procedures too (Erik Wienhold) (§)

    • Fix thread-safety bug in pgbench (Fujii Masao) (§)
      When pgbench runs with multiple threads and the --verbose-errors option, different threads could attempt to use the same buffer to construct error messages, leading to corrupted log output.

    • In pg_combinebackup, prevent infinite loop if the source file is shorter than expected (Peter Eisentraut) (§)

    • Fix cleanup of publisher-side objects after errors in pg_createsubscriber (Nisha Moond) (§)
      When pg_createsubscriber fails after creating logical replication objects, it should remove the publication and replication slot that it created on the publisher. Some error cases failed to do so.

    • Use the source cluster's group-read file permissions for pg_recvlogical output files (Fujii Masao) (§)
      pg_recvlogical was documented to behave this way, but it never actually enabled group-read.

    • Fix inconsistent behavior of pg_restore with --statistics or --statistics-only (Chao Li, Michael Paquier) (§)
      When combined with other selective-restore options such as --schema, these options failed to restore the expected items, unlike pg_dump with similar options.

    • Fix vacuumdb --missing-stats-only to ignore partitioned expression indexes (Baji Shaik) (§)
      Previously, vacuumdb would always attempt to ANALYZE the partitioned table, accomplishing nothing since statistics are never created for partitioned indexes, only for their leaf indexes.

    • In contrib/amcheck, fix failure to report corruption of a btree metapage's allequalimage flag (Chao Li) (§)

    • In contrib/amcheck, fix query-lifespan memory leak while verifying a GIN index (Kirill Reshke) (§)

    • In contrib/amcheck, handle short-header varlena datums correctly (Andrey Borodin) (§)
      This error could result in doing excess work while verifying a btree index, but seems not to have had any worse consequences.

    • In contrib/btree_gist, fix NaN handling in the float4 and float8 opclasses (Bill Kim, Tom Lane) (§)
      Comparisons, as well as the GiST penalty and distance functions, did not account for NaN and would give the wrong answer when handed one. It is recommended to reindex btree_gist indexes on float columns after installing this update, if there is any possibility that there are NaN entries in those columns.

    • In contrib/btree_gist, fix sorting of bit / varbit entries during GiST index construction (Tom Lane) (§)
      Values of bit types were sorted as though they were byteas, which did not cause any obvious failure but would result in an inefficient index, since the types' representations are different. It is recommended to reindex btree_gist indexes on bit columns after installing this update.

    • In contrib/btree_gist, fix searches using a not-equal operator (Ayush Tiwari) (§)
      For variable-length data types, the code for scanning non-leaf index pages applied the wrong comparison function, leading to wrong results and potentially crashes.

    • In contrib/dblink and contrib/postgres_fdw, ensure that a user-mapping setting for use_scram_passthrough overrides one for a foreign server (Matheus Alcantara) (§)
      Previously the precedence went the other way, but that is inconsistent with the behavior of other foreign-table options.

    • Reject setting use_scram_passthrough on contrib/dblink foreign-data wrappers (Matheus Alcantara) (§)
      This option is only meaningful on foreign servers and user mappings, but dblink incorrectly allowed it at the FDW level as well (and then ignored it).

    • Fix unguarded recursion and loops in contrib/hstore_plperl, contrib/jsonb_plperl, and contrib/jsonb_plpython (Aleksander Alekseev) (§)
      Prevent stack overflow when dealing with deeply nested jsonb values, and allow interruption of the infinite loop caused when attempting to dereference circular chains of Perl object references.

    • Fix missed release of statistics catcache entry in contrib/intarray (Man Zeng) (§)
      This oversight led to warnings like “resource was not closed: cache pg_statistic”.

    • In contrib/ltree, fix integer overflow in comparisons (Ayush Tiwari) (§)
      ltree values containing more than about 14,653 labels resulted in wrong comparison answers due to overflow. If a btree index contains such values, it is probably corrupt and should be reindexed after installing this update.

    • In contrib/pgcrypto, avoid double-free crash after encountering an error while using an OSSLCipher object (Yuelin Wang) (§)

    • Fix out-of-bounds access in contrib/pg_prewarm's autoprewarm worker (Matheus Alcantara) (§)
      The code tried to fetch a value from one past the end of an array, risking a segfault.

    • Fix array overrun in contrib/pg_surgery's heap_force_kill and heap_force_freeze functions (Michael Paquier) (§)
      Attempting to change a TID whose offset number equals MaxHeapTuplesPerPage wrote one byte past the end of the allocated array, potentially crashing the server.

    • In contrib/pg_surgery, avoid infinite loop with TID arrays having more than 64K elements (Andrey Rachitskiy) (§)

    • Avoid NULL-pointer dereference in contrib/refint's check_foreign_key() (Ayush Tiwari) (§)
      In the on-update-cascade case, a null value of a referenced column led to a crash. This is an oversight in the fix for CVE-2026-6637, but the code that was there before that wasn't really right either.

    • Fix contrib/seg to print segments with ~ certainty indicators correctly (Ewan Young) (§)
      Due to a typo, seg_out() did not print a ~ certainty indicator attached to a segment's upper boundary. Worse, if the lower boundary had ~ while the upper boundary had no indicator, the upper boundary was not printed at all, incorrectly converting the value into an open interval.

    • Fix crash with namespace nodes in contrib/xml2's xpath_nodeset() function (Andrey Chernyy, Michael Paquier) (§)

    • Support building PostgreSQL with OpenSSL 4 (Daniel Gustafsson) (§)

    • Update time zone data files to tzdata release 2026c (Tom Lane) (§)
      Alberta (America/Edmonton) will be on year-round UTC-06 (effectively, permanent DST) beginning in November 2026. This release assumes that their TZ abbreviation will be CST from that time forward. That seems likely to change, but it's unclear what new abbreviation will be used.
      Morocco (Africa/Casablanca) will move to permanent UTC+00, without daylight saving time transitions, on 2026-09-20.

    Original source
  • Jul 16, 2026
    • Date parsed from source:
      Jul 16, 2026
    • First seen by Releasebot:
      Jul 16, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 19 Beta 2 Released!

    Postgresql releases PostgreSQL 19 Beta 2, bringing fresh feature previews and a set of bug fixes ahead of general availability. The update improves vacuum, logical decoding, temporal tables, property graphs, pg_dumpall, and other areas while inviting the community to test workloads and report issues.

    Upgrading to PostgreSQL 19 Beta 2

    To upgrade to PostgreSQL 19 Beta 2 from an earlier version of PostgreSQL, you will need to use a strategy similar to upgrading between major versions of PostgreSQL (e.g. pg_upgrade or pg_dump/pg_restore). For more information, please visit the documentation section on upgrading.

    Changes Since Beta 1

    Fixes and changes in PostgreSQL 19 Beta 2 include:

    • Fix a regression in vacuumdb --analyze-in-stages for partitioned tables.
    • Fix servicefile to show correct file after fallback to system file.
    • Fix tuple deformation optimization for virtual generated columns.
    • Allow pg_createsubscriber to accept duplicate publication names.
    • Fix REPACK worker not being cleaned up on a FATAL exit.
    • Several fixes for the new FOR PORTION OF temporal table syntax.
    • Fix race condition when logical decoding activation is concurrently interrupted.
    • Disallow negative values for max_retention_duration.
    • Fix md5_password_warnings for role and database settings.
    • Several fixes for the new SQL/PGQ property graph feature.
    • Fix autovacuum's multixact-age score calculation, which could become infinite.
    • Revert non-text output formats for pg_dumpall.
    • Fix locking for ALTER DOMAIN ... VALIDATE CONSTRAINT.
    • Fix how postgres_fdw handles imported foreign-table statistics.

    Please see the release notes for a complete list of new and changed features:
    https://www.postgresql.org/docs/19/release-19.html

    Testing for Bugs & Compatibility

    The stability of each PostgreSQL release greatly depends on you, the community, to test the upcoming version with your workloads and testing tools to find bugs and regressions before the general availability of PostgreSQL 19. As this is a Beta, minor changes to database behaviors, feature details, and APIs are still possible. Your feedback and testing will help determine the final tweaks on the new features, so please test in the near future. The quality of user testing helps determine when we can make a final release.

    A list of open issues is publicly available in the PostgreSQL wiki. You can report bugs using this form on the PostgreSQL website:
    https://www.postgresql.org/account/submitbug/

    Beta Schedule

    This is the second beta release of version 19. The PostgreSQL Project will release additional betas as required for testing, followed by one or more release candidates, until the final release around September/October 2026. For further information please see the Beta Testing page.

    Links

    • Download
    • Beta Testing Information
    • PostgreSQL 19 Beta Release Notes
    • PostgreSQL 19 Open Issues
    • Submit a Bug
    • Donate
    Original source
  • Jun 4, 2026
    • Date parsed from source:
      Jun 4, 2026
    • First seen by Releasebot:
      Jun 4, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 19 Beta 1 Released!

    Postgresql releases the first beta of PostgreSQL 19, previewing major performance, developer experience, security, monitoring, and logical replication improvements ahead of general availability. It also invites users to test the new release and report issues.

    The PostgreSQL Global Development Group announces that the first beta release of PostgreSQL 19 is now available for download. This release contains PostgreSQL 19 feature previews ahead of general availability, though some details of the release can change during the beta period.

    You can find information about all of the PostgreSQL 19 features and changes in the release notes:
    https://www.postgresql.org/docs/19/release-19.html

    In the spirit of the open source PostgreSQL community, we strongly encourage you to test the new features of PostgreSQL 19 on your systems to help us eliminate bugs and other issues. While we do not advise you to run beta versions in production environments, we encourage you to find ways to run your typical application workloads against this beta release.

    Your testing and feedback help the community ensure that PostgreSQL 19 upholds our standards of delivering a stable, reliable release of the world's most advanced open source relational database. Please read more about our beta testing process and how you can contribute:
    https://www.postgresql.org/developer/beta/

    PostgreSQL 19 Feature Highlights

    Below are some of the feature highlights that are planned for PostgreSQL 19. This list is not exhaustive; for the full list of planned features, please see the release notes.

    Performance

    PostgreSQL 19 builds on the asynchronous I/O subsystem introduced in PostgreSQL 18. In this release, io_method=worker now automatically scales the number of I/O workers based on the new io_min_workers and io_max_workers settings.

    This release also introduces the pg_plan_advice extension, which lets users stabilize and control planner decisions, along with pg_stash_advice to apply advice automatically using query identifiers.

    This release brings improvements to vacuum and maintenance operations. Autovacuum can now use parallel workers, which can be configured with the new autovacuum_max_parallel_workers setting, and a new autovacuum scoring system helps prioritize tables to vacuum. PostgreSQL 19 further enhances vacuum with a new strategy that can automatically reduce future vacuuming work by marking pages as visible while they're being queried. Additionally, this release adds the new REPACK command and its nonblocking CONCURRENTLY option, which allow tables to be rebuilt with less operational overhead.

    PostgreSQL 19 shows up to 2x better performance on inserts when foreign key checks are present. Additionally, this release improves several areas of the query planner and executor, including new anti-join optimizations, broader use of incremental sorts, eager aggregation that speeds up row processing, faster reads from storage during parallel sequential scans, and simplification of IS DISTINCT FROM and IS NOT DISTINCT FROM to plain <> and = operators when the inputs are not nullable. There are also improvements for LISTEN/NOTIFY scalability that impact multi-channel workloads.

    Developer Experience

    PostgreSQL 19 introduces support for SQL/PGQ, letting users execute property graph queries using SQL standard syntax. This release also expands temporal query capabilities with UPDATE and DELETE support for the FOR PORTION OF clause, complementing the temporal constraint support added in PostgreSQL 18. This release also adds ALTER TABLE ... MERGE PARTITIONS and ALTER TABLE ... SPLIT PARTITIONS to make it easier to reorganize partitioned tables in place. There is now also support for returning rows that conflict during an upsert operation using INSERT ... ON CONFLICT DO SELECT ... RETURNING.

    PostgreSQL 19 introduces the new GROUP BY ALL syntax, making it easy to add all non-aggregate and non-window output columns as part of the grouping. This release extends string processing capabilities in jsonpath with the addition of lower(), upper(), initcap(), replace(), split_part(), and the trim() family of functions.

    PostgreSQL 19 makes it easier to adopt "read-your-writes" query patterns when working with replicas using the new WAIT FOR LSN command. This lets a session wait until changes up to a specific log position (LSN) have been replayed on the replica before executing a SELECT query.

    PostgreSQL 19 also adds new SQL functions to retrieve the DDL statements needed to recreate roles, tablespaces, and databases, simplifying scripting and migration tasks. Additionally, the random() function now works with date and timestamp types, and PL/Python now supports event triggers.

    Security Features

    PostgreSQL 19 adds server-side support for Server Name Indication (SNI) through a new pg_hosts.conf file, allowing a single PostgreSQL server to present different TLS certificates based on the hostname requested by the client. There is also a new password_expiration_warning_threshold setting (defaulting to 7 days) to warn users in advance of upcoming password expirations.

    Further to the ongoing deprecation efforts of md5 authentication, this release issues a warning to the client after a successful md5 authentication. This is controllable via the new md5_password_warnings setting.

    Monitoring and Observability

    PostgreSQL 19 introduces the pg_stat_lock view, which reports per-lock-type statistics, and pg_stat_recovery which provides detailed visibility into the state of recovery operations. A stats_reset column is now available across many statistics views to show when counters were last cleared. The pg_stat_progress_vacuum and pg_stat_progress_analyze views now include a started_by column that reports the initiator of the operation, and pg_stat_progress_vacuum also has a mode column that reports how vacuum is operating.

    This release also allows log_min_messages levels to be specified per process type, giving operators finer control over what each part of the system logs. Additionally, WAL full page write byte counts are now reported in VACUUM and ANALYZE log output, helping identify maintenance operations that generate large amounts of WAL. Additionally, EXPLAIN ANALYZE now supports surfacing asynchronous I/O (AIO) statistics through its IO option, providing better visibility into how queries are using the AIO subsystem.

    Logical Replication and Query Federation

    In PostgreSQL 19, logical replication now replicates sequence values, simplifying tasks like online upgrades. Additionally, the new CREATE PUBLICATION ... EXCEPT syntax allows you to publish all tables in a database except for a specified set, while CREATE SUBSCRIPTION ... SERVER allows subscriptions to be defined using a foreign server, simplifying credential management.

    PostgreSQL 19 makes it possible to enable logical replication without restarting a server. Logical replication can now be enabled on demand even when wal_level is set to replica, and the new read-only effective_wal_level parameter reports the WAL level currently in effect. This reduces the need to commit upfront to a higher WAL level for clusters that may only occasionally need it, and avoids disrupting an active workload.

    The PostgreSQL foreign data wrapper, postgres_fdw, used for query federation, includes several performance improvements, including pushing down array operations to the remote server, and retrieving and using statistics from foreign tables to support better local query planning.

    Other Highlights

    The PostgreSQL 19 beta period includes a temporary "grease mode" to try to find protocol compatibility problems in the wider ecosystem. This wiki page contains information on how the campaign works:
    https://wiki.postgresql.org/wiki/Grease

    PostgreSQL 19 allows data checksums to be enabled or disabled online, without requiring a cluster restart or reinitialization.

    There are several notable changes to be aware of in PostgreSQL 19. Just-in-time compilation (JIT) is now disabled by default, and the default_toast_compression setting now defaults to lz4, providing better default compression and decompression performance. Support for RADIUS authentication is now removed. Additionally, the vacuumdb --analyze-only command by default analyzes partitioned tables.

    Additional Features

    Many other new features and improvements have been added to PostgreSQL 19. Many of these may also be helpful for your use cases. Please see the release notes for a complete list of new and changed features:
    https://www.postgresql.org/docs/19/release-19.html

    Testing for Bugs & Compatibility

    The stability of each PostgreSQL release greatly depends on you, the community, to test the upcoming version with your workloads and testing tools to find bugs and regressions before the general availability of PostgreSQL 19. As this is a Beta, minor changes to database behaviors, feature details, and APIs are still possible. Your feedback and testing will help determine the final tweaks on the new features, so please test in the near future. The quality of user testing helps determine when we can make a final release.

    A list of open issues is publicly available in the PostgreSQL wiki. You can report bugs using this form on the PostgreSQL website:
    https://www.postgresql.org/account/submitbug/

    Beta Schedule

    This is the first beta release of version 19. The PostgreSQL Project will release additional betas as required for testing, followed by one or more release candidates, until the final release around September/October 2026. For further information please see the Beta Testing page.

    Links

    • Download
    • Beta Testing Information
    • PostgreSQL 19 Beta Release Notes
    • PostgreSQL 19 Open Issues
    • Submit a Bug
    • Donate
    Original source
  • May 14, 2026
    • Date parsed from source:
      May 14, 2026
    • First seen by Releasebot:
      Jul 4, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 18.4

    Postgresql releases a broad security and stability update with fixes for authentication, replication, backups, planner behavior, generated columns, and dump and restore tools, plus improved crash protection, query correctness, and updated time zone data.

    This release contains a variety of fixes from 18.3. For information about new features in major release 18, see Section E.5.

    A dump/restore is not required for those running 18.X. However, if you are upgrading from a version earlier than 18.2, see Section E.3.

    Fixes

    • Prevent unbounded recursion while processing startup packets (Michael Paquier) §
      A malicious client could crash the connected backend by alternating rejected SSL and GSS encryption requests indefinitely.
      The PostgreSQL Project thanks Calif.io (in collaboration with Claude and Anthropic Research) for reporting this problem. (CVE-2026-6479)

    • Fix assorted integer overflows in memory-allocation calculations (Tom Lane, Nathan Bossart, Heikki Linnakangas) § § § § § § § § §
      Various places were incautious about the possibility of integer overflow in calculations of how much memory to allocate. Overflow would lead to allocating a too-small buffer which the caller would then write past the end of. This would at least trigger server crashes, and probably could be exploited for arbitrary code execution. In many but by no means all cases, the hazard exists only in 32-bit builds.
      The PostgreSQL Project thanks Xint Code, Bruce Dang, Sven Klemm, and Pavel Kohout for reporting these problems. (CVE-2026-6473)

    • Properly quote subscription names in pg_createsubscriber (Nathan Bossart) §
      The given subscription name was inserted into SQL commands without quoting, so that SQL injection could be achieved in the (perhaps unlikely) case that the subscription name comes from an untrusted source.
      The PostgreSQL Project thanks Yu Kunpeng for reporting this problem. (CVE-2026-6476)

    • Properly quote object names in logical replication origin checks (Pavel Kohout) §
      ALTER SUBSCRIPTION ... REFRESH PUBLICATION interpolated schema and relation names into SQL commands without quoting them, allowing execution of arbitrary SQL on the publisher.
      The PostgreSQL Project thanks Pavel Kohout for reporting this problem. (CVE-2026-6638)

    • Reject over-length options in ts_headline() (Michael Paquier) §
      The StartSel, StopSel, and FragmentDelimiter strings must not exceed 32Kb in length, but this was not checked for. An over-length value would typically crash the server.
      The PostgreSQL Project thanks Xint Code for reporting this problem. (CVE-2026-6473)

    • Detect faulty input when restoring attribute MCV statistics (Michael Paquier) §
      The statistics restore functions were insufficiently careful about validating most-common-value statistics, and would accept values that could crash the planner later on.
      The PostgreSQL Project thanks Jeroen Gui for reporting this problem. (CVE-2026-6575)

    • Guard against malicious time zone names in timeofday() and pg_strftime() (Tom Lane) § §
      A crafted time zone setting could pass % sequences to snprintf(), potentially causing crashes or disclosure of server memory. Another path to similar results was to overflow the limited-size output buffer used by pg_strftime().
      The PostgreSQL Project thanks Xint Code for reporting this problem. (CVE-2026-6474)

    • When creating a multirange type, ensure the user has CREATE privilege on the schema specified for the multirange type (Jelte Fennema-Nio) §
      The multirange type can be put into a different schema than its parent range type, but we neglected to apply the required privilege check when doing so.
      The PostgreSQL Project thanks Jelte Fennema-Nio for reporting this problem. (CVE-2026-6472)

    • Use timing-safe string comparisons in authentication code (Michael Paquier) §
      Use timingsafe_bcmp() instead of memcpy() or strcmp() when checking passwords, hashes, etc. It is not known whether the data dependency of those functions is usefully exploitable in any of these places, but in the interests of safety, replace them.
      The PostgreSQL Project thanks Joe Conway for reporting this problem. (CVE-2026-6478)

    • Mark PQfn() as unsafe, and avoid using it within libpq (Nathan Bossart) §
      For a non-integral result type, PQfn() is not passed the size of the output buffer, so it cannot check that the data returned by the server will fit. A malicious server could therefore overwrite client memory. This is unfixable without an API change, so mark the function as deprecated. Internally to libpq, use a variant version that can apply the missing check.
      The PostgreSQL Project thanks Yu Kunpeng and Martin Heistermann for reporting this problem. (CVE-2026-6477)

    • Prevent path traversal in pg_basebackup and pg_rewind (Michael Paquier) §
      These applications failed to validate output file paths read from their input, so that a malicious source could overwrite any file writable by these applications. Constrain where data can be written by rejecting paths that are absolute or contain parent-directory references.
      The PostgreSQL Project thanks XlabAI Team of Tencent Xuanwu Lab and Valery Gubanov for reporting this problem. (CVE-2026-6475)

    • Guard against field overflow within contrib/intarray's query_int type and contrib/ltree's ltxtquery type (Tom Lane) § §
      Parsing of these query structures did not check for overflow of 16-bit fields, so that construction of an invalid query tree was possible. This can crash the server when executing the query.
      The PostgreSQL Project thanks Xint Code for reporting this problem. (CVE-2026-6473)

    • Guard against overly long values of contrib/ltree's lquery type (Michael Paquier) §
      Values with more than 64K items caused internal overflows, potentially resulting in stack smashes or wrong answers.
      The PostgreSQL Project thanks Vergissmeinnicht, A1ex, and Jihe Wang for reporting this problem. (CVE-2026-6473)

    • Prevent SQL injection and buffer overruns in contrib/spi (Nathan Bossart) §
      check_foreign_key() was insufficiently careful about quoting key values, and also used fixed-length buffers for constructing queries. While this module is only meant as example code, it still shouldn't contain such dangerous errors.
      The PostgreSQL Project thanks Nikolay Samokhvalov for reporting this problem. (CVE-2026-6637)

    • Check for nondeterministic collations before assuming that an equality condition on a collatable type implies uniqueness (Richard Guo) § § § § §
      Numerous planner optimizations assume that, for example, at most one table row can satisfy WHERE x = 'abc' if there is a unique index on x. However this conclusion is unsafe in general if the index and the WHERE clause have different collations attached. It is safe when both collations are deterministic, because that property essentially requires that equality of two strings means bitwise equality. But nondeterministic collations don't act that way, so that optimizing on the assumption of unique matches can give wrong query answers if either the WHERE clause or the index has a nondeterministic collation.

    • Fix incomplete removal of relation references in RestrictInfo structs during join removal (Tom Lane) §
      This oversight has been shown to result in planner failures such as unexpected “FULL JOIN is only supported with merge-joinable or hash-joinable join conditions” errors. It may also have caused failure to consider valid plans in other cases.

    • Improve planner's matching of partition key columns to sub-query outputs (Richard Guo) §
      Strip no-op PlaceHolderVars from operands before comparing them to partition keys. This change enables partition pruning to succeed in some cases where it previously failed to recognize that a partition need not be scanned.

    • Fix self-join removal to handle join clauses that are bare boolean columns, e.g. ON t1.boolcol (Andrei Lepikhov, Tender Wang, Alexander Korotkov) §
      Previously such a case led to a “no relation entry for relid N” error.

    • Fix UPDATE/DELETE ... WHERE CURRENT OF to work on tables with virtual generated columns (Satyanarayana Narlapuram, Dean Rasheed) §

    • Fix expansion of virtual generated columns in EXCLUDED column references in INSERT ... ON CONFLICT (Satyanarayana Narlapuram, Dean Rasheed) §

    • Fix incorrect handling of NEW generated columns in rule actions and rule qualifications (Richard Guo, Dean Rasheed) §
      Previously, such column references would produce NULL in INSERT cases, or be equivalent to the OLD value in UPDATE cases.

    • Fix spurious “indexes on virtual generated columns are not supported” errors (Robert Haas) §
      Creation of an expression index could sometimes incorrectly report this error.

    • Fix spurious “generated columns are not supported in COPY FROM WHERE conditions” errors (Tom Lane) §
      Use of a system column in a COPY FROM WHERE condition could sometimes incorrectly report this error.

    • Correctly report a serialization failure when MERGE encounters a concurrently-updated tuple in repeatable-read or serializable mode (Tender Wang) §
      Previously, such cases behaved the same as in lower isolation levels.

    • Fix CREATE TABLE ... LIKE ... INCLUDING STATISTICS for cases where the source table has dropped column(s) (Julien Tachoires) §
      In such cases, extended statistics objects could be copied incorrectly, or the command could give an incorrect error.

    • Allow ALTER INDEX ... ATTACH PARTITION to mark the parent index valid if appropriate (Sami Imseih) §
      There are edge cases in which a partitioned index might remain marked as invalid even when all its leaf indexes are valid. This change provides a mechanism whereby a user can correct such a situation without resorting to manual catalog updates.

    • Fix ALTER TABLE ... SET NOT NULL to invoke object-access hook functions only after completing the catalog change (Artur Zakirov) §

    • Fix ALTER FOREIGN DATA WRAPPER to not drop the wrapper object's dependency on its handler function (Jeff Davis) §

    • Fix loss of deferrability of foreign-key triggers (Yasuo Honda) §
      Previously, a foreign key defined as DEFERRABLE INITIALLY DEFERRED would behave as NOT DEFERRABLE after being set to NOT ENFORCED status and then back to ENFORCED.
      If you have a foreign key with this problem, it can be repaired (after installing this update) by again setting it to NOT ENFORCED and then back to ENFORCED.

    • Fix WITHOUT OVERLAPS to allow domains (Jian He) §
      UNIQUE/PRIMARY KEY ... WITHOUT OVERLAPS requires the no-overlap column to be a range or multirange, but it should allow a domain over such a type too.

    • Disallow making a composite type be a member of itself via a multirange (Heikki Linnakangas) §
      We already forbade such cases when the intermediate type is a domain, array, composite type, or range; but multiranges were overlooked.

    • Fix datum-image comparisons to be insensitive to sign-extension variations (David Rowley) §
      This fixes some situations that previously led to “could not find memoization table entry” errors or wrong query results.

    • Fix incorrect logic for hashed IN / NOT IN with non-strict equality operator (Chengpeng Yan) §
      The previous coding could crash or give wrong answers. All built-in data types have strict equality operators, so that this issue could only arise with an extension data type.

    • Truncate overly-long locale-specific numeric symbols in to_char() (Tom Lane) §
      If a locale specified a currency symbol, thousands separator, or decimal or sign symbol more than 8 bytes long, a buffer overrun was possible. No such locales exist in the real world, and it's impractical for an unprivileged attacker to install a malicious locale definition underneath a Postgres server; but for safety's sake check for overlength symbols and truncate if needed.

    • Prevent buffer overruns when parsing an affix file for an Ispell dictionary (Tom Lane) § §
      A corrupt or malicious affix file could crash the server. This is not considered a security issue because text search configuration files are presumed trustworthy, but it still seems worth fixing.

    • Guard against integer overflow in calculations of frame start and end positions for window aggregates (Richard Guo) §
      Very large user-specified offsets (close to INT64_MAX) could result in errors or incorrect query results.

    • Fix array_agg_array_combine() to combine the arrays' null bitmaps correctly (Dmytro Astapov) §
      This mistake resulted in sometimes-incorrect output from parallelized array_agg(anyarray) calculations.

    • Retry sync_file_range() if it returns error code EINTR (DaeMyung Kang) §

    • Fix incorrect behavior of pg_stat_reset_single_table_counters() on a shared catalog (Chao Li) §
      Such cases had a side-effect of resetting the current database's stat_reset_timestamp, which was unintended.

    • Update activity statistics when a parallel apply worker is idle (Zhijie Hou) §
      Previously, statistics from a recently-completed transaction might go unreported for long intervals, particularly if the workload is light.

    • Fix “no relation entry for relid 0” failure while estimating array lengths in set operations (Tender Wang) §

    • Fix buffer overread when pglz_decompress() receives corrupt input (Andrew Dunstan) §
      It was possible to read a few bytes past the end of the input, which in very unlucky cases might cause a crash.

    • Fix incremental JSON parser's handling of numeric tokens that cross input buffer boundaries (Andrew Dunstan) §
      It was possible to accept an incorrectly-formatted number, leading to failures later.

    • Prevent bloating relation visibility maps during restore of an incremental backup (Robert Haas) §
      Restore could append many blocks of zeroes to a visibility map, due to incorrect computation of the expected file length. This does not result in data corruption, but it could waste a substantial amount of disk space.

    • Use C collation, not the database's default collation, in catalog cache lookups on text columns (Jeff Davis) §
      This avoids failures in edge cases such as physical replication startup, where there is no identified database so that a default collation cannot be determined.

    • Prevent stuck slotsync worker processes from blocking promotion of a standby server (Nisha Moond, Ajin Cherian) § § §
      A worker process that was vainly waiting for a response from the primary would delay promotion for an unreasonable amount of time.

    • Fix excessive log output from idle slotsync worker processes (Zhijie Hou) §

    • Ensure that tuplestore data structures are internally consistent even after an error (Tom Lane) §
      The code was previously careless about this, which is fine most of the time but is problematic for the tuplestore backing a WITH HOLD cursor. In v15 and before this leads to easily-reproducible crashes; later branches are not known to be vulnerable, but it seems best to preserve consistency in all.

    • Make the pg_aios system view's pid column show NULL not 0 when an entry has no owning process (ChangAo Chen) §

    • Fix premature NULL lag reporting in pg_stat_replication (Shinya Kato) §
      The lag columns frequently read as NULL even while replication activity was happening.

    • Fix under-allocation of shared memory used for parallel btree index scans (Siddharth Kothari) §
      In edge cases this could result in a server crash.

    • Avoid rare flush failure when working with non-WAL-logged GiST indexes (Tomas Vondra) §
      A non-logged GiST index could nonetheless sometimes produce “xlog flush request n/nnnn is not satisfied” errors, due to incorrect selection of a “fake LSN” to represent an insertion point.

    • Fix underestimate of required size of DSA page maps for odd-size segments (Paul Bunn) §
      This miscalculation led to out-of-bounds accesses and hence server crashes.

    • Fix indexing of oldest-multixact arrays in shared memory (Yura Sokolov) § §
      This mistake could cause a prepared-but-not-yet-committed transaction's row locks to appear invisible to other sessions, or other visibility issues for the results of such a transaction. With a very small max_connections setting, memory stomps were also possible.

    • Fix array overrun when too many EXPLAIN extension options are installed (Joel Jacobson) §

    • Fix possible server crash when processing extended statistics on expressions of extension data types (Michael Paquier) §
      NULL pointer dereferences were possible if the data type's typanalyze function does not compute any useful statistics. No in-core typanalyze function behaves that way, but extensions could.

    • Correctly display join alias Vars that are used in GROUP BY (Tom Lane) §
      In views containing queries like SELECT ... t1 LEFT JOIN t2 USING (x) GROUP BY x, the GROUP BY clause could be displayed incorrectly by deparsing, leading to dump/restore failures. Failures occurred only if t1.x and t2.x were not of identical data types and t1.x was the side that required an implicit coercion.

    • Fix minor memory leaks in ICU-based string processing (Jeff Davis) §

    • If the startup process fails, properly shut down other child processes before exiting the postmaster (Ayush Tiwari) §
      The handling of this situation relied on a long-obsolete assumption that no other postmaster children exist while the startup process is running, so that immediate postmaster exit is acceptable. Orphaned children would eventually notice the postmaster's death and exit on their own, but a cleaner shutdown procedure is desirable.

    • Fix race condition between WAL replay of checkpoints and multixact ID creations (Heikki Linnakangas) §
      A standby server following WAL from a primary of an older minor version could get into a crash-and-restart loop complaining about “could not access status of transaction”.

    • Prevent indefinite wait in shutdown of a walsender process (Anthonin Bonnefoy) § §
      At shutdown of a cluster that is publishing logical replication data, the walsender waits for all pending WAL to be written out. But it did not correctly request that to happen, so that in some cases this could become an indefinite wait.

    • Ensure that changes to tables' free space maps are persisted during recovery (Alexey Makhmutov) §
      Previously, while WAL replay did update the free space map while replaying operations that should change it, the map page buffer did not get marked dirty if checksums are enabled, so that the changes might never get written out. On a standby server, over time this would result in a map wildly at variance with the table's actual contents. While the map is only used as a hint, this condition could cause significant performance degradation for some period of time after the standby server is promoted to be active, until most of the map has been repaired by updates.

    • Fix crashes in some ecpg functions when called without any established connection (Shruthi Gowda) §

    • Harden tar-file parsing logic against archives it can't handle (Tom Lane) §
      The tar-file reading code used in pg_basebackup and pg_verifybackup failed to verify that the input is a tar file at all, let alone that it fits into the subset of valid tar files that we can handle. This isn't a problem for the normal scenario where the input file was generated by PostgreSQL code, but it can be an issue if the input has been generated by some other tar program.

    • Fix assorted bugs in backup decompression and tar-parsing code (Andrew Dunstan, Tom Lane, Chao Li) § § §
      The decompression and tar-file reading code used in pg_basebackup and pg_verifybackup mishandled tar-file padding data, could corrupt LZ4-compressed data in edge cases, failed to check for some unusual error conditions, failed to exit after compression/decompression errors (leading to cascading error reports), and leaked memory.

    • In pg_dump, preserve NO INHERIT property of NOT NULL constraints (Jian He) §
      Some cases missed printing the NO INHERIT clause.

    • In pg_dumpall, don't skip role GRANTs with dangling grantor OIDs (Tom Lane) §
      Instead, handle such cases by emitting GRANT without any GRANTED BY clause, as we did before v16. This avoids losing the grant in foreseeable cases, since pre-v16 servers didn't prevent dropping the grantor role. Continue to emit a warning about the missing grantor, but only if the source server is v16 or later.

    • In pg_upgrade, take care to use the correct protocol version when connecting to older source servers (Jacob Champion) §
      This could be problematic when attempting to upgrade from a pre-2018 server.

    • In contrib/basic_archive, allow the archive directory to be missing at startup (Nathan Bossart) §
      Previously, the setting of basic_archive.archive_directory was rejected if it didn't point to an existing directory. This is undesirable because archiving will be stuck indefinitely, even if the directory appears later.

    • Fix contrib/ltree to cope when case-folding changes a string's byte length (Jeff Davis) § §
      Previously, lquery patterns specifying case-insensitive matching might fail to match labels they should match.

    • Fix mis-structured output from contrib/pg_overexplain's RANGE_TABLE option (Satyanarayana Narlapuram) §
      Some fields were misplaced in JSON, YAML, and XML formats, resulting in structurally invalid output.

    • In contrib/pg_stat_statements, don't leak memory if an error occurs while parsing the pgss_query_texts.stat file (Heikki Linnakangas) §

    • In contrib/postgres_fdw, avoid crash due to premature cleanup of a failed connection (Etsuro Fujita) §
      If a remote connection fails abort cleanup, we can't use it any longer. But delay closing the connection object until end of transaction, because there might still be references to it within data structures such as open cursors.

    • Update time zone data files to tzdata release 2026b (Tom Lane) §
      British Columbia (America/Vancouver) will be on year-round UTC-07 (effectively, permanent DST) beginning in November 2026. This release assumes that their TZ abbreviation will be MST from that time forward. That seems likely to change, but it's unclear what new abbreviation will be used. Also a historical correction for Moldova: they have followed EU DST transition times since 2022.

    Original source
  • May 14, 2026
    • Date parsed from source:
      May 14, 2026
    • First seen by Releasebot:
      Jul 4, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 17.10

    Postgresql releases a broad maintenance update packed with security fixes, crash protections, query planner corrections, replication and backup improvements, plus updated tzdata 2026b for time zone changes and historical corrections.

    This release contains a variety of fixes from 17.9. For information about new features in major release 17, see Section E.11.

    A dump/restore is not required for those running 17.X. However, if you are upgrading from a version earlier than 17.6, see Section E.5.

    Fixes and security issues

    • Prevent unbounded recursion while processing startup packets (Michael Paquier) § §
      A malicious client could crash the connected backend by alternating rejected SSL and GSS encryption requests indefinitely.
      The PostgreSQL Project thanks Calif.io (in collaboration with Claude and Anthropic Research) for reporting this problem. (CVE-2026-6479)

    • Fix assorted integer overflows in memory-allocation calculations (Tom Lane, Nathan Bossart, Heikki Linnakangas) § § § § § § § § § §
      Various places were incautious about the possibility of integer overflow in calculations of how much memory to allocate. Overflow would lead to allocating a too-small buffer which the caller would then write past the end of. This would at least trigger server crashes, and probably could be exploited for arbitrary code execution. In many but by no means all cases, the hazard exists only in 32-bit builds.
      The PostgreSQL Project thanks Xint Code, Bruce Dang, Sven Klemm, and Pavel Kohout for reporting these problems. (CVE-2026-6473)

    • Properly quote subscription names in pg_createsubscriber (Nathan Bossart) §
      The given subscription name was inserted into SQL commands without quoting, so that SQL injection could be achieved in the (perhaps unlikely) case that the subscription name comes from an untrusted source.
      The PostgreSQL Project thanks Yu Kunpeng for reporting this problem. (CVE-2026-6476)

    • Properly quote object names in logical replication origin checks (Pavel Kohout) §
      ALTER SUBSCRIPTION ... REFRESH PUBLICATION interpolated schema and relation names into SQL commands without quoting them, allowing execution of arbitrary SQL on the publisher.
      The PostgreSQL Project thanks Pavel Kohout for reporting this problem. (CVE-2026-6638)

    • Reject over-length options in ts_headline() (Michael Paquier) §
      The StartSel, StopSel, and FragmentDelimiter strings must not exceed 32Kb in length, but this was not checked for. An over-length value would typically crash the server.
      The PostgreSQL Project thanks Xint Code for reporting this problem. (CVE-2026-6473)

    • Guard against malicious time zone names in timeofday() and pg_strftime() (Tom Lane) § §
      A crafted time zone setting could pass % sequences to snprintf(), potentially causing crashes or disclosure of server memory. Another path to similar results was to overflow the limited-size output buffer used by pg_strftime().
      The PostgreSQL Project thanks Xint Code for reporting this problem. (CVE-2026-6474)

    • When creating a multirange type, ensure the user has CREATE privilege on the schema specified for the multirange type (Jelte Fennema-Nio) §
      The multirange type can be put into a different schema than its parent range type, but we neglected to apply the required privilege check when doing so.
      The PostgreSQL Project thanks Jelte Fennema-Nio for reporting this problem. (CVE-2026-6472)

    • Use timing-safe string comparisons in authentication code (Michael Paquier) § §
      Use timingsafe_bcmp() instead of memcpy() or strcmp() when checking passwords, hashes, etc. It is not known whether the data dependency of those functions is usefully exploitable in any of these places, but in the interests of safety, replace them.
      The PostgreSQL Project thanks Joe Conway for reporting this problem. (CVE-2026-6478)

    • Mark PQfn() as unsafe, and avoid using it within libpq (Nathan Bossart) §
      For a non-integral result type, PQfn() is not passed the size of the output buffer, so it cannot check that the data returned by the server will fit. A malicious server could therefore overwrite client memory. This is unfixable without an API change, so mark the function as deprecated. Internally to libpq, use a variant version that can apply the missing check.
      The PostgreSQL Project thanks Yu Kunpeng and Martin Heistermann for reporting this problem. (CVE-2026-6477)

    • Prevent path traversal in pg_basebackup and pg_rewind (Michael Paquier) §
      These applications failed to validate output file paths read from their input, so that a malicious source could overwrite any file writable by these applications. Constrain where data can be written by rejecting paths that are absolute or contain parent-directory references.
      The PostgreSQL Project thanks XlabAI Team of Tencent Xuanwu Lab and Valery Gubanov for reporting this problem. (CVE-2026-6475)

    • Guard against field overflow within contrib/intarray's query_int type and contrib/ltree's ltxtquery type (Tom Lane) § §
      Parsing of these query structures did not check for overflow of 16-bit fields, so that construction of an invalid query tree was possible. This can crash the server when executing the query.
      The PostgreSQL Project thanks Xint Code for reporting this problem. (CVE-2026-6473)

    • Guard against overly long values of contrib/ltree's lquery type (Michael Paquier) §
      Values with more than 64K items caused internal overflows, potentially resulting in stack smashes or wrong answers.
      The PostgreSQL Project thanks Vergissmeinnicht, A1ex, and Jihe Wang for reporting this problem. (CVE-2026-6473)

    • Prevent SQL injection and buffer overruns in contrib/spi (Nathan Bossart) §
      check_foreign_key() was insufficiently careful about quoting key values, and also used fixed-length buffers for constructing queries. While this module is only meant as example code, it still shouldn't contain such dangerous errors.
      The PostgreSQL Project thanks Nikolay Samokhvalov for reporting this problem. (CVE-2026-6637)

    • Check for nondeterministic collations before assuming that an equality condition on a collatable type implies uniqueness (Richard Guo) § §
      Numerous planner optimizations assume that, for example, at most one table row can satisfy WHERE x = 'abc' if there is a unique index on x. However this conclusion is unsafe in general if the index and the WHERE clause have different collations attached. It is safe when both collations are deterministic, because that property essentially requires that equality of two strings means bitwise equality. But nondeterministic collations don't act that way, so that optimizing on the assumption of unique matches can give wrong query answers if either the WHERE clause or the index has a nondeterministic collation.

    • Fix incomplete removal of relation references in RestrictInfo structs during join removal (Tom Lane) § §
      This oversight has been shown to result in planner failures such as unexpected “FULL JOIN is only supported with merge-joinable or hash-joinable join conditions” errors. It may also have caused failure to consider valid plans in other cases.

    • Fix incorrect handling of NEW generated columns in rule actions and rule qualifications (Richard Guo, Dean Rasheed) §
      Previously, such column references would produce NULL in INSERT cases, or be equivalent to the OLD value in UPDATE cases.

    • Fix spurious “generated columns are not supported in COPY FROM WHERE conditions” errors (Tom Lane) §
      Use of a system column in a COPY FROM WHERE condition could sometimes incorrectly report this error.

    • Correctly report a serialization failure when MERGE encounters a concurrently-updated tuple in repeatable-read or serializable mode (Tender Wang) §
      Previously, such cases behaved the same as in lower isolation levels.

    • Fix CREATE TABLE ... LIKE ... INCLUDING STATISTICS for cases where the source table has dropped column(s) (Julien Tachoires) §
      In such cases, extended statistics objects could be copied incorrectly, or the command could give an incorrect error.

    • Allow ALTER INDEX ... ATTACH PARTITION to mark the parent index valid if appropriate (Sami Imseih) §
      There are edge cases in which a partitioned index might remain marked as invalid even when all its leaf indexes are valid. This change provides a mechanism whereby a user can correct such a situation without resorting to manual catalog updates.

    • Fix ALTER FOREIGN DATA WRAPPER to not drop the wrapper object's dependency on its handler function (Jeff Davis) §

    • Disallow making a composite type be a member of itself via a multirange (Heikki Linnakangas) §
      We already forbade such cases when the intermediate type is a domain, array, composite type, or range; but multiranges were overlooked.

    • Fix datum-image comparisons to be insensitive to sign-extension variations (David Rowley) §
      This fixes some situations that previously led to “could not find memoization table entry” errors or wrong query results.

    • Fix incorrect logic for hashed IN / NOT IN with non-strict equality operator (Chengpeng Yan) §
      The previous coding could crash or give wrong answers. All built-in data types have strict equality operators, so that this issue could only arise with an extension data type.

    • Truncate overly-long locale-specific numeric symbols in to_char() (Tom Lane) §
      If a locale specified a currency symbol, thousands separator, or decimal or sign symbol more than 8 bytes long, a buffer overrun was possible. No such locales exist in the real world, and it's impractical for an unprivileged attacker to install a malicious locale definition underneath a Postgres server; but for safety's sake check for overlength symbols and truncate if needed.

    • Prevent buffer overruns when parsing an affix file for an Ispell dictionary (Tom Lane) § §
      A corrupt or malicious affix file could crash the server. This is not considered a security issue because text search configuration files are presumed trustworthy, but it still seems worth fixing.

    • Guard against integer overflow in calculations of frame start and end positions for window aggregates (Richard Guo) §
      Very large user-specified offsets (close to INT64_MAX) could result in errors or incorrect query results.

    • Fix array_agg_array_combine() to combine the arrays' null bitmaps correctly (Dmytro Astapov) §
      This mistake resulted in sometimes-incorrect output from parallelized array_agg(anyarray) calculations.

    • Retry sync_file_range() if it returns error code EINTR (DaeMyung Kang) §

    • Fix incorrect behavior of pg_stat_reset_single_table_counters() on a shared catalog (Chao Li) §
      Such cases had a side-effect of resetting the current database's stat_reset_timestamp, which was unintended.

    • Update activity statistics when a parallel apply worker is idle (Zhijie Hou) §
      Previously, statistics from a recently-completed transaction might go unreported for long intervals, particularly if the workload is light.

    • Fix “no relation entry for relid 0” failure while estimating array lengths in set operations (Tender Wang) §

    • Fix buffer overread when pglz_decompress() receives corrupt input (Andrew Dunstan) §
      It was possible to read a few bytes past the end of the input, which in very unlucky cases might cause a crash.

    • Fix incremental JSON parser's handling of numeric tokens that cross input buffer boundaries (Andrew Dunstan) §
      It was possible to accept an incorrectly-formatted number, leading to failures later.

    • Prevent bloating relation visibility maps during restore of an incremental backup (Robert Haas) §
      Restore could append many blocks of zeroes to a visibility map, due to incorrect computation of the expected file length. This does not result in data corruption, but it could waste a substantial amount of disk space.

    • Use C collation, not the database's default collation, in catalog cache lookups on text columns (Jeff Davis) §
      This avoids failures in edge cases such as physical replication startup, where there is no identified database so that a default collation cannot be determined.

    • Prevent stuck slotsync worker processes from blocking promotion of a standby server (Nisha Moond, Ajin Cherian) § § §
      A worker process that was vainly waiting for a response from the primary would delay promotion for an unreasonable amount of time.

    • Fix excessive log output from idle slotsync worker processes (Zhijie Hou) §

    • Ensure that tuplestore data structures are internally consistent even after an error (Tom Lane) §
      The code was previously careless about this, which is fine most of the time but is problematic for the tuplestore backing a WITH HOLD cursor. In v15 and before this leads to easily-reproducible crashes; later branches are not known to be vulnerable, but it seems best to preserve consistency in all.

    • Fix premature NULL lag reporting in pg_stat_replication (Shinya Kato) §
      The lag columns frequently read as NULL even while replication activity was happening.

    • Avoid rare flush failure when working with non-WAL-logged GiST indexes (Tomas Vondra) §
      A non-logged GiST index could nonetheless sometimes produce “xlog flush request n/nnnn is not satisfied” errors, due to incorrect selection of a “fake LSN” to represent an insertion point.

    • Fix underestimate of required size of DSA page maps for odd-size segments (Paul Bunn) §
      This miscalculation led to out-of-bounds accesses and hence server crashes.

    • Fix indexing of oldest-multixact arrays in shared memory (Yura Sokolov) § §
      This mistake could cause a prepared-but-not-yet-committed transaction's row locks to appear invisible to other sessions, or other visibility issues for the results of such a transaction. With a very small max_connections setting, memory stomps were also possible.

    • Fix possible server crash when processing extended statistics on expressions of extension data types (Michael Paquier) §
      NULL pointer dereferences were possible if the data type's typanalyze function does not compute any useful statistics. No in-core typanalyze function behaves that way, but extensions could.

    • Fix minor memory leaks in ICU-based string processing (Jeff Davis) §

    • If the startup process fails, properly shut down other child processes before exiting the postmaster (Ayush Tiwari) §
      The handling of this situation relied on a long-obsolete assumption that no other postmaster children exist while the startup process is running, so that immediate postmaster exit is acceptable. Orphaned children would eventually notice the postmaster's death and exit on their own, but a cleaner shutdown procedure is desirable.

    • Fix race condition between WAL replay of checkpoints and multixact ID creations (Heikki Linnakangas) §
      A standby server following WAL from a primary of an older minor version could get into a crash-and-restart loop complaining about “could not access status of transaction”.

    • Prevent indefinite wait in shutdown of a walsender process (Anthonin Bonnefoy) § §
      At shutdown of a cluster that is publishing logical replication data, the walsender waits for all pending WAL to be written out. But it did not correctly request that to happen, so that in some cases this could become an indefinite wait.

    • Ensure that changes to tables' free space maps are persisted during recovery (Alexey Makhmutov) §
      Previously, while WAL replay did update the free space map while replaying operations that should change it, the map page buffer did not get marked dirty if checksums are enabled, so that the changes might never get written out. On a standby server, over time this would result in a map wildly at variance with the table's actual contents. While the map is only used as a hint, this condition could cause significant performance degradation for some period of time after the standby server is promoted to be active, until most of the map has been repaired by updates.

    • Fix crashes in some ecpg functions when called without any established connection (Shruthi Gowda) §

    • Fix assorted bugs in backup decompression and tar-parsing code (Andrew Dunstan, Tom Lane, Chao Li) § § §
      The decompression and tar-file reading code used in pg_basebackup and pg_verifybackup mishandled tar-file padding data, could corrupt LZ4-compressed data in edge cases, failed to check for some unusual error conditions, failed to exit after compression/decompression errors (leading to cascading error reports), and leaked memory.

    • In pg_dumpall, don't skip role GRANTs with dangling grantor OIDs (Tom Lane) §
      Instead, handle such cases by emitting GRANT without any GRANTED BY clause, as we did before v16. This avoids losing the grant in foreseeable cases, since pre-v16 servers didn't prevent dropping the grantor role. Continue to emit a warning about the missing grantor, but only if the source server is v16 or later.

    • In pg_upgrade, take care to use the correct protocol version when connecting to older source servers (Jacob Champion) §
      This could be problematic when attempting to upgrade from a pre-2018 server.

    • In contrib/basic_archive, allow the archive directory to be missing at startup (Nathan Bossart) §
      Previously, the setting of basic_archive.archive_directory was rejected if it didn't point to an existing directory. This is undesirable because archiving will be stuck indefinitely, even if the directory appears later.

    • Fix contrib/ltree to cope when case-folding changes a string's byte length (Jeff Davis) §
      Previously, lquery patterns specifying case-insensitive matching might fail to match labels they should match.

    • In contrib/pg_stat_statements, don't leak memory if an error occurs while parsing the pgss_query_texts.stat file (Heikki Linnakangas) §

    • In contrib/postgres_fdw, avoid crash due to premature cleanup of a failed connection (Etsuro Fujita) §
      If a remote connection fails abort cleanup, we can't use it any longer. But delay closing the connection object until end of transaction, because there might still be references to it within data structures such as open cursors.

    • Update time zone data files to tzdata release 2026b (Tom Lane) §
      British Columbia (America/Vancouver) will be on year-round UTC-07 (effectively, permanent DST) beginning in November 2026. This release assumes that their TZ abbreviation will be MST from that time forward. That seems likely to change, but it's unclear what new abbreviation will be used. Also a historical correction for Moldova: they have followed EU DST transition times since 2022.

    Original source
  • May 14, 2026
    • Date parsed from source:
      May 14, 2026
    • First seen by Releasebot:
      May 15, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 18.4, 17.10, 16.14, 15.18, and 14.23 Released!

    Postgresql releases cumulative updates for all supported versions, including 18.4 and 17.10, with fixes for 11 security vulnerabilities, over 60 bugs, and refreshed tzdata for 2026b. It also improves stability, backup, replication, and planner behavior.

    The PostgreSQL Global Development Group has released an update to all supported versions of PostgreSQL, including 18.4, 17.10, 16.14, 15.18, and 14.23.

    This release fixes 11 security vulnerabilities and over 60 bugs reported over the last several months.

    For the full list of changes, please review the release notes.

    PostgreSQL 14 will stop receiving fixes on November 12, 2026. If you are running PostgreSQL 14 in a production environment, we suggest that you make plans to upgrade to a newer, supported version of PostgreSQL. Please see our versioning policy for more information.

    Security Issues

    CVE-2026-6472: PostgreSQL CREATE TYPE does not check multirange schema CREATE privilege

    CVSS v3.1 Base Score: 5.4

    Supported, Vulnerable Versions: 14 - 18.

    Missing authorization in PostgreSQL CREATE TYPE allows an object creator to hijack other queries that use search_path to find user-defined types, including extension-defined types. That is to say, the victim will execute arbitrary SQL functions of the attacker's choice. Versions before PostgreSQL 18.4, 17.10, 16.14, 15.18, and 14.23 are affected.

    The PostgreSQL project thanks Jelte Fennema-Nio for reporting this problem.

    CVE-2026-6473: PostgreSQL server undersizes allocations, via integer wraparound

    CVSS v3.1 Base Score: 8.8

    Supported, Vulnerable Versions: 14 - 18.

    Integer wraparound in multiple PostgreSQL server features allows an application input provider to cause the server to undersize an allocation and write out-of-bounds. This results in a segmentation fault. Versions before PostgreSQL 18.4, 17.10, 16.14, 15.18, and 14.23 are affected.

    The PostgreSQL project thanks Anemone, A1ex, Xint Code, Jihe Wang, Jingzhou Fu, Pavel Kohout, Petr Simecek, www.aisle.com, Bruce Dang of Calif.io, and Sven Klemm for reporting this problem.

    CVE-2026-6474: PostgreSQL timeofday() can disclose portions of server memory

    CVSS v3.1 Base Score: 4.3

    Supported, Vulnerable Versions: 14 - 18.

    Externally-controlled format string in PostgreSQL timeofday() function allows an attacker to retrieve portions of server memory, via crafted timezone zones. Versions before PostgreSQL 18.4, 17.10, 16.14, 15.18, and 14.23 are affected.

    The PostgreSQL project thanks Xint Code for reporting this problem.

    CVE-2026-6475: PostgreSQL pg_basebackup and pg_rewind can overwrite unrelated files of origin superuser choice

    CVSS v3.1 Base Score: 8.8

    Supported, Vulnerable Versions: 14 - 18.

    Symlink following in PostgreSQL pg_basebackup plain format and in pg_rewind allows an origin superuser to overwrite local files, e.g. /var/lib/postgres/.bashrc, that hijack the operating system account. It will remain the case that starting the server after these commands implicitly trusts the origin superuser, due to features like shared_preload_libraries. Hence, the attack has practical implications only if one takes relevant action between these commands and server start, like moving the files to a different VM or snapshotting the VM. Versions before PostgreSQL 18.4, 17.10, 16.14, 15.18, and 14.23 are affected.

    The PostgreSQL project thanks Valery Gubanov, XlabAI Team of Tencent Xuanwu Lab, Atuin Automated Vulnerability Discovery Engine, Zhanpeng Liu (pkugenuine(at)gmail(dot)com), Guannan Wang (wgnbuaa(at)gmail(dot)com), and Guancheng Li (lgcpku(at)gmail(dot)com) for reporting this problem.

    CVE-2026-6476: PostgreSQL pg_createsubscriber allows SQL injection via subscription name

    CVSS v3.1 Base Score: 7.2

    Supported, Vulnerable Versions: 17 - 18.

    SQL injection in PostgreSQL pg_createsubscriber allows an attacker with pg_create_subscription rights to execute arbitrary SQL as a superuser. The attack takes effect when pg_createsubscriber next runs. Within major versions 17 and 18, minor versions before PostgreSQL 18.4 and 17.10 are affected. Versions before PostgreSQL 17 are unaffected.

    The PostgreSQL project thanks Yu Kunpeng for reporting this problem.

    CVE-2026-6477: PostgreSQL libpq lo_* functions let server superuser overwrite client stack memory

    CVSS v3.1 Base Score: 8.8

    Supported, Vulnerable Versions: 14 - 18.

    Use of inherently dangerous function PQfn(..., result_is_int=0, ...) in PostgreSQL libpq lo_export(), lo_read(), lo_lseek64(), and lo_tell64() functions allows the server superuser to overwrite a client stack buffer with an arbitrarily-large response. Like gets(), PQfn(..., result_is_int=0, ...) stores arbitrary-length, server-determined data into a buffer of unspecified size. Because both the \lo_export command in psql and pg_dump call lo_read(), the server superuser can overwrite pg_dump or psql stack memory. Versions before PostgreSQL 18.4, 17.10, 16.14, 15.18, and 14.23 are affected.

    The PostgreSQL project thanks Yu Kunpeng and Martin Heistermann for reporting this problem.

    CVE-2026-6478: PostgreSQL discloses MD5-hashed passwords via covert timing channel

    CVSS v3.1 Base Score: 6.5

    Supported, Vulnerable Versions: 14 - 18.

    Covert timing channel in comparison of MD5-hashed password in PostgreSQL authentication allows an attacker to recover user credentials sufficient to authenticate. This does not affect scram-sha-256 passwords, the default in all supported releases. However, current databases may have MD5-hashed passwords originating in upgrades from PostgreSQL 13 or earlier. Versions before PostgreSQL 18.4, 17.10, 16.14, 15.18, and 14.23 are affected.

    The PostgreSQL project thanks Joe Conway for reporting this problem.

    CVE-2026-6479: PostgreSQL SSL/GSS init causes denial of service, via uncontrolled recursion

    CVSS v3.1 Base Score: 7.5

    Supported, Vulnerable Versions: 14 - 18.

    Uncontrolled recursion in PostgreSQL SSL and GSS negotiation allows an attacker able to connect to a PostgreSQL AF_UNIX socket to achieve sustained denial of service. If SSL and GSS are both disabled, an attacker can do the same via access to a PostgreSQL TCP socket. Versions before PostgreSQL 18.4, 17.10, 16.14, 15.18, and 14.23 are affected.

    The PostgreSQL project thanks Calif.io in collaboration with Claude and Anthropic Research for reporting this problem.

    CVE-2026-6575: PostgreSQL pg_restore_attribute_stats accepts values that cause query planning to read past end of stats array

    CVSS v3.1 Base Score: 4.3

    Supported, Vulnerable Versions: 18.

    Buffer over-read in PostgreSQL function pg_restore_attribute_stats() accepts array values of unmatched length, which causes query planning to read past end of one array. This allows a table maintainer to infer memory values past that array end. Within major version 18, minor versions before PostgreSQL 18.4 are affected. Versions before PostgreSQL 18 are unaffected.

    The PostgreSQL project thanks Jeroen Gui for reporting this problem.

    CVE-2026-6637: PostgreSQL refint allows stack buffer overflow and SQL injection

    CVSS v3.1 Base Score: 8.8

    Supported, Vulnerable Versions: 14 - 18.

    Stack buffer overflow in PostgreSQL module refint allows an unprivileged database user to execute arbitrary code as the operating system user running the database. A distinct attack is possible if the application declares a user-controlled column as a refint cascade primary key and facilitates user-controlled updates to that column. In that case, a SQL injection allows a primary key update value provider to execute arbitrary SQL as the database user performing the primary key update. Versions before PostgreSQL 18.4, 17.10, 16.14, 15.18, and 14.23 are affected.

    The PostgreSQL project thanks Nikolay Samokhvalov for reporting this problem.

    CVE-2026-6638: PostgreSQL REFRESH PUBLICATION allows SQL injection via table name

    CVSS v3.1 Base Score: 3.7

    Supported, Vulnerable Versions: 16 - 18.

    SQL injection in PostgreSQL logical replication ALTER SUBSCRIPTION ... REFRESH PUBLICATION allows a subscriber table creator to execute arbitrary SQL with the subscription's publication-side credentials. The attack takes effect at the next REFRESH PUBLICATION. Within major versions 16, 17, and 18, minor versions before PostgreSQL 18.4, 17.10, and 16.14 are affected. Versions before PostgreSQL 16 are unaffected.

    The PostgreSQL project thanks Pavel Kohout, Aisle Research for reporting this problem.

    Bug Fixes and Improvements

    This update fixes over 60 bugs that were reported in the last several months. The issues listed below affect PostgreSQL 18. Some of these issues may also affect other supported versions of PostgreSQL.

    • Fix queries that could return incorrect results when using a nondeterministic collation over a unique index.
    • Fix loss of deferrability of foreign-key triggers. Previously, a foreign key defined as DEFERRABLE INITIALLY DEFERRED would behave as NOT DEFERRABLE after being set to NOT ENFORCED status and then back to ENFORCED. If you have a foreign key with this problem, after installing this update you can fix it by setting it to NOT ENFORCED and then back to ENFORCED.
    • Improve the planner's ability to apply partition pruning to more cases.
    • Fix self-join removal to handle join clauses that are only boolean columns, for example, ON t1.boolcol.
    • Several fixes around virtual generated columns, including ensuring INSERT ... ON CONFLICT works when EXCLUDED references a virtual generated column.
    • Report a serialization failure when MERGE encounters a concurrently-updated tuple in "repeatable read" or "serializable" isolation modes.
    • Fix CREATE TABLE ... LIKE ... INCLUDING STATISTICS for cases where the source table had one or more dropped columns.
    • Fix WITHOUT OVERLAPS to allow domains.
    • Disallow making a composite type be a member of itself via a multirange.
    • Fix sometimes-incorrect results when array_agg(anyarray) executes in parallel.
    • Prevent bloating during restore of an incremental backup.
    • Prevent stuck logical replication slot synchronization worker processes from blocking promotion of a standby server.
    • Make the pg_aios system view pid column show NULL instead of 0 when an entry has no owning process.
    • Fix cases where pg_stat_replication shows NULL lag even while replication is active.
    • Correctly display JOIN alias variables that are used in GROUP BY.
    • If the startup process fails, properly shut down other child processes before exiting the postmaster.
    • Fix race condition that could cause a standby server following WAL from a primary of an older minor version to get into a crash-and-restart loop.
    • Prevent indefinite wait in shutdown of a walsender process when logical replication is actively publishing data.
    • Ensure that free space map changes are persisted during recovery. This could have performance ramifications on a standby server after promotion.
    • Fix assorted bugs in backup decompression and tar-parsing code used in pg_basebackup and pg_verifybackup.
    • Ensure pg_dumpall doesn't skip role grants with dangling grantor OIDs, restoring the behavior before PostgreSQL 16. Emits a warning about missing grantor if the source server is PostgreSQL 16 or later.
    • Fix pg_upgrade to use the correct protocol version when connecting to older source servers.
    • Fix output in pg_overexplain when using the RANGE_TABLE option.
    • Fix postgres_fdw crash due to premature cleanup of a failed connection.

    This release also updates time zone data files to tzdata release 2026b, in which British Columbia (America/Vancouver) will be on year-round UTC-07 (effectively, permanent DST) beginning in November 2026. This release assumes that their TZ abbreviation will be MST from that time forward (though this could change). There is also a historical correction for Moldova, which has used EU DST transition times since 2022.

    Updating

    All PostgreSQL update releases are cumulative. As with other minor releases, users are not required to dump and reload their database or use pg_upgrade in order to apply this update release; you may simply stop PostgreSQL and update its binaries.

    Users who have skipped one or more update releases may need to run additional post-update steps; please see the release notes from earlier versions for details.

    For more details, please see the release notes.

    Links

    • Download
    • Release Notes
    • Security
    • Versioning Policy
    • Submit a Bug
    • Donate

    If you have corrections or suggestions for this release announcement, please send them to the [email protected] public mailing list.

    Original source
  • Feb 26, 2026
    • Date parsed from source:
      Feb 26, 2026
    • First seen by Releasebot:
      Jul 4, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 18.3

    Postgresql fixes a set of 18.3 issues across WAL replay, JSON, trigram search, statistics views, PL/pgSQL, hstore, and constraint handling, improving correctness, stability, and compatibility for existing 18.x users.

    This release contains a small number of fixes from 18.2. For information about new features in major release 18, see Section E.5.

    A dump/restore is not required for those running 18.X.

    However, if you are upgrading from a version earlier than 18.2, see Section E.3.

    Fix failure after replaying a multixid truncation record from WAL that was generated by an older minor version (Heikki Linnakangas)

    Erroneous logic for coping with the way that previous versions handled multixid wraparound led to replay failure, with messages like “could not access status of transaction”. A typical scenario in which this could occur is a standby server of the latest minor version consuming WAL from a primary server of an older version.

    Avoid incorrect complaint of invalid encoding when substring() is applied to “toasted” data (Noah Misch)

    The fix for CVE-2026-2006 was too aggressive and could raise an error about an incomplete character in cases that are actually valid.

    Fix oversight in the fix for CVE-2026-2007 (Zsolt Parragi)

    If the “bounds” array needed to be expanded, because the input contained more trigrams than the initial guess, generate_trgm_only didn't return the modified array pointer to its caller. That would lead to incorrect output from strict_word_similarity() and related functions, or in rare cases a crash. The faulty code is reached if the input string becomes longer when it's converted to lower case. The only known instances of that occur when an ICU locale is used with certain single-byte encodings.

    Fix the volatility marking of json_strip_nulls() and jsonb_strip_nulls() (Andrew Dunstan)

    These functions have always been considered immutable, but refactoring in version 18 accidentally marked them stable instead. That prevents their use in index expressions and could cause unnecessary repeat evaluations in queries. This fix corrects the marking in newly-initialized database clusters (including clusters that are pg_upgrade'd to 18.3 or later). However it will not help existing clusters made using 18.0 through 18.2.

    If this mistake affects your usage of these functions, the recommended fix for an existing cluster is a manual catalog update. As superuser, perform UPDATE pg_catalog.pg_proc SET provolatile = 'i' WHERE oid IN ('3261','3262'); in each affected database. Update template0 and template1 as well, so that databases made in future will have the fix.

    Fix computation of the set of potentially-nulling outer joins for the output of a LATERAL UNION ALL subquery (Richard Guo)

    This error could lead to skipping NOT NULL tests in the mistaken belief that they were unnecessary, resulting in wrong query output.

    Avoid name collisions between user-written constraints and automatically-named NOT NULL constraints (Laurenz Albe)

    As of version 18, NOT NULL constraints have full-fledged pg_constraint entries, and therefore require names. The logic for choosing a name for an unnamed NOT NULL constraint failed to avoid conflicts with user-written constraints elsewhere in the same CREATE TABLE statement.

    Fix pg_stat_get_backend_wait_event() and pg_stat_get_backend_wait_event_type() to report values for auxiliary processes (Heikki Linnakangas)

    Previously these functions returned NULL for auxiliary processes, but that's inconsistent with the pg_stat_activity view.

    Fix casting a composite-type variable to a domain type when returning its value from a PL/pgSQL function (Tom Lane)

    If the variable's value is NULL, a “cache lookup failed for type 0” error resulted.

    Fix potential null pointer dereference in contrib/hstore's binary input function (Michael Paquier)

    hstore's receive function crashed on input containing duplicate keys. hstore values generated by Postgres would never contain duplicate keys, so this mistake has gone unnoticed. The crash could be provoked by malicious or corrupted data.

    Original source
  • Feb 26, 2026
    • Date parsed from source:
      Feb 26, 2026
    • First seen by Releasebot:
      Jul 4, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 17.9

    Postgresql fixes a set of 17.8 issues, improving WAL replay reliability, query correctness, pg_stat reporting for auxiliary processes, PL/pgSQL domain casting, and hstore input safety. It also corrects an overly strict substring() encoding check.

    This release contains a small number of fixes from 17.8. For information about new features in major release 17, see Section E.11.

    A dump/restore is not required for those running 17.X.

    However, if you are upgrading from a version earlier than 17.6, see Section E.5.

    Fix failure after replaying a multixid truncation record from WAL that was generated by an older minor version (Heikki Linnakangas)

    Erroneous logic for coping with the way that previous versions handled multixid wraparound led to replay failure, with messages like “could not access status of transaction”. A typical scenario in which this could occur is a standby server of the latest minor version consuming WAL from a primary server of an older version.

    Avoid incorrect complaint of invalid encoding when substring() is applied to “toasted” data (Noah Misch)

    The fix for CVE-2026-2006 was too aggressive and could raise an error about an incomplete character in cases that are actually valid.

    Fix computation of the set of potentially-nulling outer joins for the output of a LATERAL UNION ALL subquery (Richard Guo)

    This error could lead to skipping NOT NULL tests in the mistaken belief that they were unnecessary, resulting in wrong query output.

    Fix pg_stat_get_backend_wait_event() and pg_stat_get_backend_wait_event_type() to report values for auxiliary processes (Heikki Linnakangas)

    Previously these functions returned NULL for auxiliary processes, but that's inconsistent with the pg_stat_activity view.

    Fix casting a composite-type variable to a domain type when returning its value from a PL/pgSQL function (Tom Lane)

    If the variable's value is NULL, a “cache lookup failed for type 0” error resulted.

    Fix potential null pointer dereference in contrib/hstore's binary input function (Michael Paquier)

    hstore's receive function crashed on input containing duplicate keys. hstore values generated by Postgres would never contain duplicate keys, so this mistake has gone unnoticed. The crash could be provoked by malicious or corrupted data.

    Original source
  • Feb 26, 2026
    • Date parsed from source:
      Feb 26, 2026
    • First seen by Releasebot:
      May 1, 2026
    Postgresql logo

    Postgresql

    PostgreSQL 18.3, 17.9, 16.13, 15.17, and 14.22 Released!

    Postgresql releases an out-of-cycle update for all supported versions, fixing several regressions, query and function bugs, standby errors, and crash issues. It also restores json_strip_nulls and jsonb_strip_nulls immutability for indexing and includes post-update steps for PostgreSQL 18.0 to 18.2 users.

    The PostgreSQL Global Development Group has released an update to all supported versions of PostgreSQL, including 18.3, 17.9, 16.13, 15.17, and 14.22. This is an out-of-cycle release that fixes several regressions reported after the last update release.

    For the full list of changes, please review the release notes.

    Bug Fixes and Improvements

    This update fixes several bugs that were reported since the previous release. The issues listed below affect PostgreSQL 18. Some of these issues may also affect other supported versions of PostgreSQL.

    • Fix issue where a standby would halt and return an error "could not access status of transaction".
    • Fix error where the substring() function would raise an error "invalid byte sequence for encoding" on non-ASCII text values if the source of that value is a database column. This was due to a change introduced for the fix to CVE-2026-2006.
    • Fix for the strict_word_similarity function in pg_trgm that could lead to incorrect output or crashes. This was due to an oversight in the fix for CVE-2026-2007.
    • Fix function volatility for json_strip_nulls() and jsonb_strip_nulls() to be immutable, like previous releases, allowing for them to be used in indexes. If you previously upgraded to PostgreSQL 18.0 through 18.2, see the additional steps in the "Updating" section.
    • Fix for NOT NULL tests in LATERAL UNION ALL subquery that could lead to wrong query output.
    • Avoid NOT NULL constraints from generating name conflicts with user-written constraints.
    • Fix pg_stat_get_backend_wait_event() and pg_stat_get_backend_wait_event_type() to report values for auxiliary processes, similar to pg_stat_activity.
    • Fix casting a composite-type variable to a domain type when returning its value from a PL/pgSQL function.
    • Fix the hstore binary input function to avoid crashes on input with duplicate keys.

    Updating

    All PostgreSQL update releases are cumulative. As with other minor releases, users are not required to dump and reload their database or use pg_upgrade in order to apply this update release; you may simply shutdown PostgreSQL and update its binaries.

    If you previously upgraded to PostgreSQL 18.0, 18.1 or 18.2, you need to execute the following SQL as a PostgreSQL superuser in all of your databases to make the json_strip_nulls() and jsonb_strip_nulls() functions immutable:

    UPDATE pg_catalog.pg_proc SET provolatile = 'i' WHERE oid IN ('3261','3262');
    

    You should also execute this command in the template0 and template1 databases so future databases you create in your PostgreSQL cluster have the correct function volatility setting. Please see the documentation on template databases for more information.

    Users who have skipped one or more update releases may need to run additional post-update steps; please see the release notes from earlier versions for details.

    For more details, please see the release notes.

    Links

    • Download
    • Release Notes
    • Security
    • Versioning Policy
    • Submit a Bug
    • Donate

    If you have corrections or suggestions for this release announcement, please send them to the [email protected] public mailing list.

    Original source
  • Feb 19, 2026
    • Date parsed from source:
      Feb 19, 2026
    • First seen by Releasebot:
      May 5, 2026
    Postgresql logo

    Postgresql

    apt.postgresql.org: changelogs, build logs and Ubuntu releases resolute and plucky

    Postgresql adds automatic changelog retrieval on apt.postgresql.org and stores package build logs as .build.xz files in the pool directory, while also preparing Ubuntu 26.04 resolute packages and moving Ubuntu 25.04 plucky to the archive.

    News from apt.postgresql.org

    Changelogs

    apt.postgresql.org now has changelog files in a place where apt can retrieve them automatically, for example

    apt changelog postgresql-18

    will download the file and display it in a pager. Mind that the files are only present yet for packages updated since last week, the rest will follow over time.

    Build logs

    Likewise, package build logs are now also stored along with the packages in .build.xz files in the pool directory. (There is no automated download tool for them, though.)

    Ubuntu releases resolute and plucky

    Work on the upcoming Ubuntu 26.04 "resolute" release has started and packages are available on apt.postgresql.org.

    The Ubuntu 25.04 "plucky" release has reached its end of life and has been moved to apt-archive.postgresql.org.

    Christoph

    Original source
Releasebot

Curated by the Releasebot team

Releasebot is an aggregator of official product update announcements from hundreds of software vendors and thousands of sources.

Our editorial process involves the manual review and audit of release notes procured with the help of automated systems.