Back to All Articles
Databases

PostgreSQL 14 Reaches End of Life on 12 November 2026: A Tested pg_upgrade Runbook for 17 and 18

PostgreSQL 14 ships its final community release on 12 November 2026. Here is a production-tested pg_upgrade runbook from real 14.24 binaries to 17.11 and 18.6—exposing the hidden search_path and replication slot traps that pass --check, optimizer statistic differences, PG 18 checksum defaults, and a preflight SQL script.

Pathubs Engineering
Pathubs Engineering
Database & Systems Architecture
Published Nov 10, 2026Updated Nov 10, 202610 min read
Technical 3D illustration representing PostgreSQL 14 database migration via pg_upgrade into PostgreSQL 17 and 18 clusters, showing B-tree query plans and checksum shields.

TL;DR & Executive Overview

  • The Deadline: PostgreSQL 14's final community minor release is scheduled for 12 November 2026, coinciding with the standard quarterly update cycle. Following this release, version 14 receives zero security patches or data-corruption bug fixes. Running instances do not halt, but they run unpatched.
  • The Target Version: Migrate to PostgreSQL 17 or PostgreSQL 18. Upgrading to 15 or 16 merely shifts the maintenance cliff to November 2027 or November 2028.
  • Real Binary Verification: Rather than simulating older clusters, we executed live pg_upgrade runs directly from genuine PostgreSQL 14.24 binaries into 17.11 and 18.6 and documented the exact runtime failures.
  • What `--check` Misses:

* Functional indexes built on SQL functions referencing unqualified tables (search_path) pass `--check` ("Clusters are compatible") and then abort the real upgrade on both 17 and 18. * Logical replication slots pass `--check` and silently disappear during cutover. * On PostgreSQL 17, optimizer statistics do not carry over; the planner fell back to sequential table scans until ANALYZE ran. PostgreSQL 18 carries statistics across automatically.

  • The PostgreSQL 18 Checksum Gate: initdb in PostgreSQL 18 enables data_checksums by default. Default PostgreSQL 14 clusters have checksums disabled, causing pg_upgrade to abort immediately unless you align checksum settings ahead of time.

---

What End of Life Does (and Does Not) Mean

The PostgreSQL Global Development Group maintains each major version for five years from its initial release date. PostgreSQL 14 debuted on 30 September 2021. As of November 2026, the branch stands at 14.24 (released 13 August 2026). On 12 November 2026, the PostgreSQL community issues the final minor update for branch 14 alongside quarterly patches for newer supported versions.

Nothing crashes on November 12. Your services continue executing transactions without interruption. However, any remote code execution flaw, privilege escalation vulnerability, or silent B-tree/heap data-corruption defect discovered on November 13 or later will never receive an upstream patch for PostgreSQL 14.

Community EOL vs. Managed Cloud Extended Support Clocks

Cloud providers decouple their commercial lifecycle clocks from community support deadlines. Note that the dates below derive from third-party summaries of provider schedules; always verify timelines directly in your AWS, Azure, or GCP billing consoles before finalizing change windows.

text
┌─────────────────────────────────────────────────────────────────────────────────────────────────┐
│                    POSTGRESQL 14 SUPPORT DEADLINES (AS OF 10 NOV 2026)                          │
├───────────────────────────────────┬─────────────────┬───────────────────────────────────────────┤
│ PLATFORM / PROVIDER               │ KEY DATE        │ LIFECYCLE IMPACT                          │
├───────────────────────────────────┼─────────────────┼───────────────────────────────────────────┤
│ PostgreSQL Community              │ 12 Nov 2026     │ Final minor release; zero further fixes   │
│ Azure Database for PostgreSQL     │ 11 Dec 2026     │ Standard support ends; Extended billing   │
│                                   │                 │ begins 12 Dec 2026                        │
│ Google Cloud SQL                  │ 1 Feb 2027      │ Target date for Extended Support rollover │
│ Amazon RDS for PostgreSQL         │ 28 Feb 2027     │ Standard support ends; Extended billing   │
│                                   │                 │ begins 1 Mar 2027                         │
└───────────────────────────────────┴─────────────────┴───────────────────────────────────────────┘

---

Choosing Your Target: PostgreSQL 17, 18, or 19?

  • Skip 15 and 16: Community support terminates in November 2027 (version 15) and November 2028 (version 16). Migrating there guarantees repeating this upgrade engineering effort within 12 to 24 months.
  • PostgreSQL 17 (Supported until Nov 2029): Two years of production field hardening. Leaves data checksums disabled by default, reducing migration friction for older clusters, though it drops optimizer statistics during pg_upgrade.
  • PostgreSQL 18 (Supported until Nov 2030): Carries optimizer statistics natively across pg_upgrade, drastically mitigating post-cutover query performance cliffs. Introduces default-enabled data_checksums and runtime deprecation warnings when provisioning MD5 password hashes.
  • PostgreSQL 19: Remains in release-candidate (RC) status as of November 10, 2026, with third-party summaries of the RC1 announcement noting General Availability targeted around November 19—one full week *after* version 14 hits EOL. Verify current status on postgresql.org, but migrating production workloads to 17 or 18 immediately is the predictable engineering path.

---

Testing Rig and Reproducible Methodology

Every behavior documented in this runbook comes from live upgrade executions on a clean sandbox environment:

  • Binaries: Genuine conda-forge builds of PostgreSQL 14.24, PostgreSQL 17.11, and PostgreSQL 18.6 on Ubuntu 24.04.
  • Compute: 1 vCPU, 3 GB RAM sandbox (timings serve strictly to illustrate mode variances, not production benchmarks).
  • Seeded Cluster: Initialized via pgbench -i -s 30 (3,000,000 rows in pgbench_accounts, ~858 MB total cluster footprint), enriched with pg_stat_statements, pg_trgm, an active logical replication slot, and a role using a legacy md5 password hash.
  • Method: Each test cloned the identical 14.24 base cluster, ran pg_upgrade --check, performed the actual cutover, and inspected catalogs, query plans, and storage states post-boot.

---

What `pg_upgrade --check` Catches vs. What It Misses

Do not mistake a green pg_upgrade --check run for a guaranteed cutover. Several breaking schema patterns pass pre-check verification cleanly only to crash mid-restore or cause silent metadata loss.

text
┌──────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│                         PG_UPGRADE --CHECK REALITY MATRIX (FROM 14.24)                                   │
├────────────────────────────────────────┬──────────────────────────────┬──────────────────────────────────┤
│ CONDITION IN 14.24 SOURCE CLUSTER      │ PG_UPGRADE --CHECK RESULT    │ ACTUAL UPGRADE & REMEDIATION     │
├────────────────────────────────────────┼──────────────────────────────┼──────────────────────────────────┤
│ Default 14 cluster -> Default 18 initdb│ FAILS: Data checksum mismatch│ Aborted before cutover. Run      │
│                                        │                              │ initdb --no-data-checksums OR    │
│                                        │                              │ enable checksums on 14 first.    │
├────────────────────────────────────────┼──────────────────────────────┼──────────────────────────────────┤
│ User table column of type regproc/reg* │ FAILS: reg* data types found │ Drop or alter column type before │
│                                        │                              │ upgrading.                       │
├────────────────────────────────────────┼──────────────────────────────┼──────────────────────────────────┤
│ Uncommitted prepared transaction       │ FAILS: Prepared xacts exist  │ Run COMMIT/ROLLBACK PREPARED.    │
├────────────────────────────────────────┼──────────────────────────────┼──────────────────────────────────┤
│ adminpack extension installed (to 17+) │ FAILS: Missing shared library│ Execute DROP EXTENSION adminpack;│
├────────────────────────────────────────┼──────────────────────────────┼──────────────────────────────────┤
│ **Index on SQL function relying on     │ **PASSES**                   │ **FAILS REAL UPGRADE ON 17 & 18**│
│ **search_path (unqualified tables)**   │ ("Clusters are compatible")  │ Fix: ALTER FUNCTION ...          │
│                                        │                              │ SET search_path = ...            │
├────────────────────────────────────────┼──────────────────────────────┼──────────────────────────────────┤
│ **Logical replication slot present**   │ **PASSES**                   │ **SUCCEEDS, SLOT IS GONE**       │
│                                        │ ("Clusters are compatible")  │ Recreate slot & resync downstream│
└────────────────────────────────────────┴──────────────────────────────┴──────────────────────────────────┘
mermaid
flowchart TD
    A["PG 14.24 Cluster"] --> B["Run pg_upgrade --check"]
    B --> C{"Checksum / reg* / adminpack"}
    C -->|Fail| D["Aborts Early: Safe Fix Before Window"]
    C -->|"Pass: Clusters compatible"| E["Start Real pg_upgrade Cutover"]
    E --> F{"Index Function Uses search_path?"}
    F -->|Yes| G["CRASH DURING RESTORE: relation does not exist"]
    F -->|No| H{"Logical Replication Slots Present?"}
    H -->|Yes| I["SILENT LOSS: Upgrade Succeeds, Slots Erased"]
    H -->|No| J["Successful Cutover"]
    J --> K{"Target Version?"}
    K -->|PG 17| L["Optimizer Stats Missing: Seq Scans Until ANALYZE"]
    K -->|PG 18| M["Optimizer Stats Retained: Index Scans Active"]

    classDef fail fill:#c62828,stroke:#b71c1c,color:#fff;
    classDef warn fill:#ef6c00,stroke:#e65100,color:#fff;
    classDef safe fill:#2e7d32,stroke:#1b5e20,color:#fff;
    classDef info fill:#1565c0,stroke:#0d47a1,color:#fff;

    class G,D fail;
    class I,L warn;
    class M safe;
    class A,B,C,E,F,H,J,K info;

---

Deep Dive 1: The `search_path` Function Index Failure

On PostgreSQL 14, an IMMUTABLE SQL function can omit explicit schema qualifiers and rely on the caller's session search_path, even when backed by an index:

sql
CREATE SCHEMA app;
SET search_path = app, public;

CREATE TABLE rates (code text PRIMARY KEY, factor numeric);

CREATE FUNCTION to_usd(amount numeric, cur text) RETURNS numeric
  LANGUAGE sql IMMUTABLE
  AS $$ SELECT amount * factor FROM rates WHERE code = cur $$;

CREATE TABLE orders (id int, amount numeric, cur text);
CREATE INDEX orders_usd ON orders (to_usd(amount, cur));

On PostgreSQL 14.24, this index builds cleanly. When running pg_upgrade --check targeting 17.11 and 18.6, both versions report "Clusters are compatible".

However, when the actual upgrade executes the "Restoring database schemas in the new cluster" phase, pg_restore fails and halts the upgrade:

text
pg_restore: error: could not execute query: ERROR:  relation "rates" does not exist
CONTEXT:  SQL function "to_usd" during inlining

Root Cause and Remediation

Starting in PostgreSQL 17, maintenance operations—including CREATE INDEX and schema restore tasks—execute helper functions inside a locked-down, safe search_path to close privilege-escalation vectors. Any inlineable function lacking an explicit schema qualification fails to resolve its underlying relation.

*(Note: Running --copy mode ensured the source 14.24 cluster remained untouched and booted cleanly with all 3,000,000 rows intact after the crash.)*

To fix the issue before running pg_upgrade, pin the function's search path directly in its definition:

sql
ALTER FUNCTION app.to_usd(numeric, text) SET search_path = app;

Once applied, the exact same upgrade succeeded on both 17.11 and 18.6 with orders_usd present and active.

---

Deep Dive 2: Silent Loss of Logical Replication Slots

If your PostgreSQL 14 cluster pushes Change Data Capture (CDC) streams or powers logical subscribers via logical replication slots, expect silent truncation.

When testing a 14.24 cluster containing an active logical slot, pg_upgrade --check printed "Clusters are compatible" with zero warnings. After upgrading to both 17.11 and 18.6, querying pg_replication_slots returned zero rows.

While modern PostgreSQL versions support migrating logical slots during upgrades, PostgreSQL 14 predates the WAL slot-state mechanics required for automatic carry-over. You must treat slot reconstruction and subscriber resynchronization as explicit tasks in your cutover plan.

---

Optimizer Statistics: Why PG 18 Beats PG 17 Post-Cutover

Historically, pg_upgrade discarded optimizer statistics, forcing DBAs to schedule aggressive ANALYZE runs immediately post-cutover before exposing traffic. PostgreSQL 18 changes this behavior completely.

We executed ANALYZE across the 14.24 source cluster before running upgrades. Immediately after starting the upgraded clusters (prior to running post-upgrade ANALYZE), we measured catalog stats and ran EXPLAIN for WHERE aid < 1000 (which matches exactly 999 rows):

text
┌─────────────────────────────────────────────────────────────────────────────────────────────────┐
│                   OPTIMIZER STATISTICS IMMEDIATELY AFTER PG_UPGRADE                             │
├────────────────────────────────────────┬───────────────────────────┬────────────────────────────┤
│ METRIC (BEFORE POST-UPGRADE ANALYZE)   │ POSTGRESQL 17.11          │ POSTGRESQL 18.6            │
├────────────────────────────────────────┼───────────────────────────┼────────────────────────────┤
│ Rows in pg_stats (user tables)         │ 0                         │ 11                         │
│ pg_class.reltuples (pgbench_accounts)  │ -1 (unknown)              │ 2,999,974                  │
│ Execution Plan: WHERE aid < 1000       │ Seq Scan (Full Table)     │ Index Scan                 │
│ Planner Row Estimate (Actual: 999)     │ 344,267 rows (~350x off)  │ 1,065 rows (Accurate)      │
└────────────────────────────────────────┴───────────────────────────┴────────────────────────────┘

On PostgreSQL 17, the blind planner fell back to a sequential scan with an estimate off by roughly 350x. Never route production traffic to a freshly upgraded PG 17 cluster until the initial stage of `vacuumdb --analyze-in-stages` finishes.

On PostgreSQL 18, pg_upgrade carries statistics forward cleanly and prints targeted follow-up commands upon completion:

bash
# On PostgreSQL 18 (--missing-stats-only fills minor gaps safely):
vacuumdb --all --analyze-in-stages --missing-stats-only
vacuumdb --all --analyze-only

# On PostgreSQL 17 (run staged analysis before taking load):
vacuumdb --all --analyze-in-stages

---

Post-Upgrade Operational Details: Extensions, MD5, and Checksums

1. Extension Updates

pg_upgrade moves extension definitions across binary versions, leaving extensions pinned at their legacy schema versions. In our tests, pg_stat_statements stayed at 1.9 even though 17.11 shipped 1.11 and 18.6 shipped 1.12 (while pg_trgm remained current at 1.6). Identify and upgrade outdated extensions post-cutover:

sql
SELECT name, installed_version, default_version
  FROM pg_available_extensions
 WHERE installed_version IS NOT NULL
   AND installed_version IS DISTINCT FROM default_version;

ALTER EXTENSION pg_stat_statements UPDATE;

2. MD5 Password Hashes on PostgreSQL 18

Legacy roles configured with md5 hashes survive the upgrade intact and authenticate cleanly over md5 rules in pg_hba.conf on 18.6 without triggering runtime login failures. However, modifying or creating any new MD5 credential immediately raises a deprecation warning:

text
WARNING:  setting an MD5-encrypted password
DETAIL:  MD5 password support is deprecated and will be removed in a future release of PostgreSQL.

Because MD5 authentication is slated for complete removal in future major versions, treat this migration window as your trigger to rotate roles to scram-sha-256.

3. Handling the PostgreSQL 18 Default Checksum Requirement

Because initdb in PG 18 activates data_checksums by default while PG 14 clusters leave them off by default, pg_upgrade --check fails immediately. You have two verified paths forward:

  • Option A (Keep Checksums Disabled): Initialize the new PG 18 cluster using initdb --no-data-checksums. The upgrade runs smoothly and preserves data_checksums = off.
  • Option B (Enable Checksums Beforehand): Cleanly shut down the source 14 cluster and execute pg_checksums --enable using the PG 14 binary. On our 858 MB cluster, pg_checksums scanned 60,571 blocks in 0.9 seconds. Allocate downtime proportionally for multi-terabyte clusters, as the server must remain offline throughout checksum generation.

*(Note: PostgreSQL 17 retains checksums off by default, skipping this collision altogether.)*

---

When operating with --link, pg_upgrade creates hard links between old and new data files to avoid duplicating terabytes of storage. To protect against accidental split-brain writes, pg_upgrade intentionally renders the old cluster unbootable by renaming global/pg_control to global/pg_control.old.

We verified the exact rollback safety boundary on a 14-to-17 --link upgrade:

  1. Following pg_upgrade --link, global/ contained pg_control.old and no pg_control. Attempting to boot PG 14 failed immediately.
  2. Prior to starting the new PG 17 cluster, renaming pg_control.old back to pg_control allowed the source PG 14.24 server to start cleanly and return all 3,000,000 records.

> [!CAUTION]

> One-Way Door Warning: Once you start the newly upgraded cluster in --link mode, PostgreSQL immediately modifies shared linked data blocks. We did not verify rolling back after the new cluster starts. Always take a verified snapshot or physical backup before executing --link.

---

Observed Execution Timings (Sandbox Reference)

Single-run metrics observed on the 858 MB cluster (1 vCPU, 3 GB RAM). Use these solely to understand relative overhead between --copy, --link, and --swap (introduced in 18), not as production SLA estimates:

text
┌────────────────────────────────────────────────────────────────────────┐
│              TEST CLUSTER OPERATION TIMINGS (858 MB / 1 vCPU)          │
├───────────────────────────────────────────────────────────┬────────────┤
│ OPERATION                                                 │ DURATION   │
├───────────────────────────────────────────────────────────┼────────────┤
│ pg_upgrade --copy (14.24 -> 17.11)                        │ 3.4 s      │
│ pg_upgrade --link (14.24 -> 17.11)                        │ 2.3 s      │
│ pg_upgrade --copy (14.24 -> 18.6)                         │ 3.2 s      │
│ pg_upgrade --link (14.24 -> 18.6)                         │ 2.3 s      │
│ pg_upgrade --swap (14.24 -> 18.6)                         │ 2.2 s      │
│ vacuumdb --analyze-in-stages (PG 17)                      │ 0.5–0.7 s  │
│ vacuumdb --analyze-in-stages --missing-stats-only (PG 18) │ 0.1 s      │
│ pg_checksums --enable (PG 14, 60,571 blocks)              │ 0.9 s      │
└───────────────────────────────────────────────────────────┴────────────┘

---

Automated Preflight Script (`preflight_pg14.sql`)

Execute this diagnostic SQL script as a superuser across every single database in your PostgreSQL 14 cluster prior to scheduling your maintenance window. We verified this script against both a broken cluster (successfully flagging all 7 rows) and a remediated cluster (returning clean statuses):

sql
-- preflight_pg14.sql: run in EVERY database of the old cluster as a superuser:
--   psql -U postgres -d <db> -f preflight_pg14.sql
SELECT 'data checksums' AS check, current_setting('data_checksums') AS detail
UNION ALL
SELECT 'prepared transactions (block pg_upgrade)', count(*)::text FROM pg_prepared_xacts
UNION ALL
SELECT 'logical slots (NOT carried over)',
       coalesce(string_agg(slot_name, ', '), 'none')
  FROM pg_replication_slots WHERE slot_type = 'logical'
UNION ALL
SELECT 'reg* columns (block pg_upgrade)',
       coalesce(string_agg(c.oid::regclass || '.' || a.attname || ' ' || format_type(a.atttypid, NULL), ', '), 'none')
  FROM pg_attribute a
  JOIN pg_class c ON c.oid = a.attrelid
  JOIN pg_namespace n ON n.oid = c.relnamespace
 WHERE a.attnum > 0 AND NOT a.attisdropped AND c.relkind IN ('r', 'm')
   AND n.nspname NOT IN ('pg_catalog', 'information_schema')
   AND a.atttypid IN ('regproc'::regtype, 'regprocedure'::regtype, 'regoper'::regtype,
                      'regoperator'::regtype, 'regconfig'::regtype, 'regdictionary'::regtype)
UNION ALL
SELECT 'index functions without SET search_path (break restore on 17+)',
       coalesce(string_agg(DISTINCT i.indexrelid::regclass || ' -> ' || p.oid::regprocedure, '; '), 'none')
  FROM pg_index i
  JOIN pg_depend d ON d.classid = 'pg_class'::regclass AND d.objid = i.indexrelid
                  AND d.refclassid = 'pg_proc'::regclass
  JOIN pg_proc p ON p.oid = d.refobjid
  JOIN pg_language l ON l.oid = p.prolang
 WHERE l.lanname IN ('sql', 'plpgsql')
   AND NOT EXISTS (SELECT 1 FROM unnest(p.proconfig) cfg WHERE cfg LIKE 'search_path=%')
UNION ALL
SELECT 'adminpack installed (removed in 17)',
       CASE WHEN EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'adminpack') THEN 'YES' ELSE 'no' END
UNION ALL
SELECT 'roles with md5 password hashes',
       coalesce(string_agg(rolname, ', '), 'none')
  FROM pg_authid WHERE rolpassword LIKE 'md5%';

*(Script Limitation: The search_path query captures SQL and PL/pgSQL functions bound directly to indexes. Inspect functions in other languages and functions inside materialized views manually.)*

---

Step-by-Step Tested `pg_upgrade` Runbook

Replace directory placeholders with paths matching your host architecture:

  1. Rehearse Full Upgrade on Production Restore: Because search_path failures survive --check silently, never treat --check as an integration test. Execute a full end-to-end upgrade on a restored copy of production.
  2. Audit Every Database: Execute preflight_pg14.sql across every database in the cluster and remediate every finding (uncommitted xacts, reg* types, adminpack, unqualified index functions).
  3. Select Checksum Strategy (If Target Is 18):

`bash # Strategy A: Keep checksums disabled initdb -D /var/lib/postgresql/18/data --no-data-checksums

# Strategy B: Enable checksums offline using PG 14 binary before upgrading pg_checksums --enable -D /var/lib/postgresql/14/data `

  1. Stop Old Server Cleanly, Run Check, Execute Cutover:

`bash pg_upgrade -b /usr/lib/postgresql/14/bin -B /usr/lib/postgresql/18/bin \ -d /var/lib/postgresql/14/data -D /var/lib/postgresql/18/data --check

pg_upgrade -b /usr/lib/postgresql/14/bin -B /usr/lib/postgresql/18/bin \ -d /var/lib/postgresql/14/data -D /var/lib/postgresql/18/data --link `

  1. Boot New Cluster & Rebuild Optimizer Stats:

`bash # On PostgreSQL 18: vacuumdb --all --analyze-in-stages --missing-stats-only vacuumdb --all --analyze-only

# On PostgreSQL 17: vacuumdb --all --analyze-in-stages `

  1. Upgrade Extensions & Re-Establish Replication: Run ALTER EXTENSION ... UPDATE; for outdated extensions, recreate dropped logical replication slots, and resynchronize logical subscribers.
  2. Schedule MD5-to-SCRAM Rotation: Update password_encryption = scram-sha-256 and rotate passwords for all legacy accounts listed in the final row of the preflight output.

---

Boundaries: What Was Not Tested

To maintain strict transparency for production operations, the following areas lie outside the verified scope of this runbook:

  • Cloud Provider In-Place Upgrades: Automated console upgrades on AWS RDS, Google Cloud SQL, and Azure Flexible Server implement bespoke orchestration wrappers with provider-specific locks and storage mechanics.
  • Physical Standbys & Replicas: Resyncing streaming physical replicas via rsync after --link upgrades was not tested here.
  • Intervening Release-Note Behavioral Changes: Major behavioral shifts across 15, 16, and 17 do not halt pg_upgrade but alter runtime permissions and observability—specifically the public schema CREATE restriction (PG 15), stricter CREATEROLE delegation semantics (PG 16), and renamed monitoring columns in pg_stat_bgwriter and pg_stat_statements (PG 17). Review the migration notes for every major jump you cross.
  • PostgreSQL 19 & Raw Query Run Times: PG 19 binaries were not evaluated, and execution checks focused on query plans and row-count estimates rather than elapsed execution wall-clock latency.

---

Discrepancies Across External Sources

text
┌──────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│                                 SOURCE DISCREPANCIES & INTERPRETATION                                    │
├──────────────────────────────┬───────────────────────────────────────┬───────────────────────────────────┤
│ QUESTION                     │ CONFLICTING CLAIMS                    │ OPERATIONAL GUIDANCE              │
├──────────────────────────────┼───────────────────────────────────────┼───────────────────────────────────┤
│ AWS RDS Extended Support Cost│ One summary quotes ~$0.100/vCPU-hr;   │ Confirm direct AWS pricing table  │
│                              │ another claims no rate published yet. │ in your specific region console.  │
├──────────────────────────────┼───────────────────────────────────────┼───────────────────────────────────┤
│ PostgreSQL 19 GA Release     │ One blog mentions October 2026;       │ Rely exclusively on postgresql.org│
│                              │ RC1 summary targets 19 November 2026. │ official release announcements.   │
├──────────────────────────────┼───────────────────────────────────────┼───────────────────────────────────┤
│ Current PG 14 Minor Release  │ Static snapshots show older minors;   │ Test verified on genuine 14.24.   │
│                              │ official repo ships 14.24.            │ Pull latest minor before cutover. │
└──────────────────────────────┴───────────────────────────────────────┴───────────────────────────────────┘

---

Sources & Official Documentation

Frequently Asked Questions

What happens if we do not upgrade PostgreSQL 14 before 12 November 2026?

Your existing database instances continue running without interruption. However, 12 November 2026 marks the final scheduled community minor release for version 14. Any security vulnerability or silent data-corruption bug discovered after that date will not receive an upstream community fix.

Why did pg_upgrade --check pass when an index function depended on search_path, only for the real upgrade to crash?

pg_upgrade --check only validates high-level binary catalog headers and extension library compatibility. Starting in PostgreSQL 17, maintenance tasks like CREATE INDEX execute inline SQL functions under a restricted safe search_path. If your indexed SQL function omits schema prefixes and lacks SET search_path = schema, pg_restore crashes during schema replay with relation does not exist.

Should we upgrade PostgreSQL 14 to version 17 or version 18?

Both are strong targets compared to 15 or 16. PostgreSQL 17 is supported until November 2029 and keeps data checksums off by default, avoiding checksum alignment steps. PostgreSQL 18 is supported until November 2030 and is the only version whose pg_upgrade carries optimizer statistics over automatically, preventing immediate post-cutover Sequential Scan regressions.

Does pg_upgrade from PostgreSQL 14 preserve logical replication slots?

No. PostgreSQL 14 predates the slot-migration WAL mechanics supported by modern pg_upgrade versions. pg_upgrade --check reports Clusters are compatible, yet after the real cutover pg_replication_slots will be completely empty. Plan to recreate logical slots and resync subscribers during your cutover window.

Can we roll back after running pg_upgrade --link?

You can roll back by renaming global/pg_control.old back to global/pg_control ONLY IF you have not started the newly upgraded PostgreSQL 17 or 18 cluster yet. Once the new cluster starts in --link mode, it mutates shared hard-linked blocks, making rollback impossible without restoring a backup.