# Ce que la version 19 de PostgreSQL change dans le code de vos applications

> PostgreSQL 19 est sorti le 19 novembre 2026. Dans des notes de version faites surtout pour les administrateurs, cinq nouveautés changent le quotidien d'un développeur d'application : ON CONFLICT DO SELECT, la commande WAIT, l'export JSON de COPY, REPACK et des optimisations gratuites. Et quelques changements à connaître avant de lancer pg_upgrade.


*Ou : Comment arrêter de mettre à jour une ligne dans le seul but de pouvoir la relire*

Le jeudi 19 novembre 2026, le PostgreSQL Global Development Group a publié PostgreSQL 19, la nouvelle version majeure du serveur de base de données libre. La date venait de l'annonce de la première version candidate, le 15 octobre : sortie prévue le 19 novembre, « unless an issue is discovered that requires a delay », sauf problème découvert d'ici là[^1]. Le calendrier initial visait le 29 octobre[^2] ; l'équipe de publication a préféré attendre la mise à jour des branches stables du 12 novembre pour intégrer ses nombreux correctifs, d'où une seconde version candidate ce jour-là[^3]. Le résumé officiel met en avant une commande REPACK, un module pour orienter le planificateur, la réplication logique des séquences et un autovacuum parallèle[^4]. Pour qui écrit du SQL dans une application Django ou Go, la liste utile est plus courte, et plus concrète.

Les notes de version d'une version majeure ressemblent au registre d'une grande bibliothèque : des centaines de lignes, presque toutes destinées au personnel. Le lecteur, lui, cherche trois ou quatre fiches qui changent sa façon d'emprunter. Les voici.

## Les nouveautés de PostgreSQL 19 pour les développeurs : SQL, réplication, JSON et maintenance
{.subtitle}

### ON CONFLICT DO SELECT : le get-or-create en une seule requête

Le besoin est banal : insérer une étiquette ou une clé d'idempotence si elle n'existe pas, et récupérer la ligne dans tous les cas. Jusqu'ici, `INSERT ... ON CONFLICT DO NOTHING RETURNING *` ne renvoyait rien pour les lignes déjà présentes, puisque la documentation précise que seules les lignes insérées, mises à jour ou sélectionnées sont renvoyées[^5]. Il fallait donc une seconde requête `SELECT`, avec la fenêtre de concurrence que cela suppose, ou l'astuce répandue d'un `DO UPDATE` factice, qui réécrit une colonne avec sa propre valeur. Cette astuce fonctionne. Elle crée aussi une nouvelle version de la ligne, déclenche les triggers de mise à jour et laisse du travail à l'autovacuum, le tout pour lire une donnée qui n'avait pas changé.

PostgreSQL 19 ajoute une troisième action, `DO SELECT`, que la documentation décrit elle-même comme un « get or create » : l'issue est atomique, soit une insertion, soit une sélection[^5]. L'exemple officiel :

```sql
-- Insère le distributeur s'il est nouveau, sinon renvoie la ligne existante
INSERT INTO distributors (did, dname) VALUES (11, 'Global Electronics')
    ON CONFLICT (did) DO SELECT
    RETURNING *;
```

Deux variantes méritent l'attention. La première filtre la ligne renvoyée avec un `WHERE` qui compare l'existant (`d`) et la proposition (`EXCLUDED`) ; la seconde verrouille la ligne existante, comme un `SELECT ... FOR UPDATE` :

```sql
-- Ne renvoie la ligne existante que si son nom diffère
INSERT INTO distributors AS d (did, dname) VALUES (12, 'Micro Devices Inc')
    ON CONFLICT (did) DO SELECT WHERE d.dname != EXCLUDED.dname
    RETURNING *;

-- Insère, ou renvoie et verrouille la ligne existante
INSERT INTO distributors (did, dname) VALUES (13, 'Advanced Systems')
    ON CONFLICT (did) DO SELECT FOR UPDATE
    RETURNING *;
```

Les règles du jeu sont strictes : `RETURNING` est obligatoire, la cible du conflit aussi, et la variante `FOR UPDATE` exige le droit `UPDATE` sur au moins une colonne en plus du droit `SELECT`[^5]. Côté ORM, la documentation de Django rappelle que `get_or_create()` n'est atomique que si la base impose l'unicité des champs recherchés[^6] ; la contrainte reste indispensable, mais la base sait désormais tout faire en un aller-retour.

### WAIT FOR LSN : relire ses propres écritures sur une réplique

Voici la nouveauté qui m'intéresse le plus. L'application écrit sur le serveur principal, puis relit sur une réplique asynchrone pour le soulager. Si la réplique a quelques millisecondes de retard, l'utilisateur qui vient d'enregistrer son profil voit l'ancienne version. Les contournements habituels consistent à relire sur le principal pendant un moment, ou à espérer.

La nouvelle commande `WAIT` attend qu'une position du journal des transactions (le LSN) soit atteinte sur la réplique avant de rendre la main. Les notes de version la présentent comme le support de la cohérence « read-your-writes » sur les serveurs secondaires[^4]. L'exemple de la documentation, d'abord sur le principal :

```sql
-- Sur le principal : écrire, puis noter la position atteinte
UPDATE movie SET genre = 'Dramatic' WHERE genre = 'Drama';
SELECT pg_current_wal_insert_lsn();
-- 0/0306EE20
```

Puis sur la réplique, avec la position transmise par l'application :

```sql
-- Sur la réplique : attendre que cette position soit rejouée
WAIT FOR LSN '0/0306EE20';
-- status : success
SELECT * FROM movie WHERE genre = 'Drama';
-- 0 ligne : la modification est bien visible
```

Le mode par défaut, `standby_replay`, attend que les changements soient appliqués. Les options `TIMEOUT` et `NO_THROW` transforment l'erreur de délai dépassé en un statut `timeout` que l'application peut traiter, par exemple en se rabattant sur le principal[^7] :

```sql
WAIT FOR LSN '0/0306EE20' WITH (TIMEOUT '100ms', NO_THROW);
```

Les limites sont écrites noir sur blanc. Le LSN doit être conservé côté application ou côté pooler de connexions ; `WAIT` doit être une commande de premier niveau, jamais dans une fonction, une procédure ou un bloc `DO` ; et il faut l'émettre avant toute instruction qui prend des verrous, faute de quoi le serveur peut la refuser[^7]. Autrement dit, PostgreSQL fournit le guichet, pas le carnet où noter son numéro.

> **DevOps Dave :** Super, je mets `WAIT FOR LSN` dans une fonction PL/pgSQL et on n'en parle plus.
>
> **Security Sarah :** La documentation l'interdit.
>
> **DevOps Dave :** Alors dans un middleware, juste après la première requête de la transaction.
>
> **Security Sarah :** Avant, Dave. Avant la première requête.

### Le JSON devient un format de sortie de COPY

`COPY TO` sait maintenant écrire du JSON, une ligne par objet, ou un seul tableau avec l'option `FORCE_ARRAY`[^8]. L'exemple officiel :

```sql
COPY (SELECT * FROM (VALUES(1),(2)) val(id)) TO STDOUT (FORMAT JSON, FORCE_ARRAY);
```

```json
[
 {"id":1}
,{"id":2}
]
```

Pour un export vers un autre service, plus besoin d'un script qui relit tout pour le sérialiser. Deux détails : le format JSON n'existe qu'en sortie, et un `NULL` SQL comme un `null` JSON stocké dans une colonne `jsonb` sortent tous deux en `null`, sans distinction possible[^8]. En sens inverse, `COPY FROM` gagne l'option `ON_ERROR set_null`, qui remplace une valeur invalide par `NULL` au lieu d'interrompre la commande ou d'écarter la ligne entière[^8].

Le langage jsonpath reçoit huit méthodes de chaînes : `ltrim()`, `rtrim()`, `btrim()`, `lower()`, `upper()`, `initcap()`, `replace()` et `split_part()`, immuables comme leurs équivalents SQL[^4]. Deux exemples de la documentation[^9] :

```sql
SELECT jsonb_path_query('"TOM"', '$.lower()');                  -- "tom"
SELECT jsonb_path_query('"abc,def,ghi,jkl"', '$.split_part(",", 3)');  -- "ghi"
```

Dans le même esprit, le type `uuid` se convertit désormais vers et depuis `bytea`, ce qui ouvre `encode()` et `decode()` aux identifiants[^10]. Si vous avez déjà pesé [le choix d'un UUID v7 en clé primaire](/blog/uuid-v7-go-cle-primaire-postgresql/), voici de quoi le raccourcir dans une URL :

```sql
SELECT encode('1ea3d64c-bc40-4cc3-84bb-6b11ee31e5c2'::uuid::bytea, 'base64');
SELECT decode('HqPWTLxATMOEu2sR7jHlwg==', 'base64')::uuid;
```

Le nouveau format `base64url` de `encode()`, sans `+`, `/` ni `=`, se colle tel quel dans une adresse[^11].

### REPACK (CONCURRENTLY) : récupérer l'espace sans bloquer la table

`VACUUM` rend réutilisable l'espace des lignes mortes sans le restituer au système. Pour le restituer, il fallait `VACUUM FULL` ou `CLUSTER`, qui posent un verrou exclusif pendant toute la réécriture : ni lecture ni écriture. PostgreSQL 19 les unifie sous `REPACK`, garde les anciennes pour la compatibilité, et ajoute surtout l'option `CONCURRENTLY`[^12] :

```sql
-- Réécriture simple
REPACK employees;

-- Réécriture concurrente, dans l'ordre de l'index de regroupement déjà défini
REPACK (CONCURRENTLY) employees USING INDEX;
```

En mode concurrent, l'essentiel du travail se fait sous un verrou qui laisse passer lectures et écritures ; les changements survenus pendant la copie sont captés par décodage logique, et le verrou exclusif n'intervient qu'à la fin, pour échanger les fichiers. La documentation est franche sur le prix : la commande n'est pas sûre au sens MVCC, et une transaction dont l'instantané précède le début de l'opération verra la table vide après coup ; il faut assez de disque pour une copie de la table et de ses index ; l'opération échoue au-delà d'environ 104 millions de lignes modifiées pendant son exécution ; et elle refuse les tables partitionnées, non journalisées ou sans clé primaire ni identité de réplique[^12]. Pas un geste à automatiser sans réfléchir, donc, mais le cœur de PostgreSQL fait enfin ce que des extensions externes faisaient jusqu'ici.

### Des optimisations qui ne demandent aucune ligne de code

Le reste de la liste profite à l'application sans qu'elle le sache. Une sélection, tirée des notes de version[^4] :

| Changement | Ce que cela change pour l'application |
|---|---|
| `NOT IN` converti en anti-jointure quand aucun `NULL` n'est possible | Les vieilles requêtes `NOT IN (SELECT ...)` peuvent changer de plan, en mieux |
| Vérifications de clés étrangères plus rapides | Insertions et mises à jour moins chères sur les tables liées |
| `NOTIFY` ne réveille plus que les sessions à l'écoute | `LISTEN`/`NOTIFY` coûte moins cher avec beaucoup de connexions |
| Compression TOAST par défaut en `lz4` au lieu de `pglz` | Grandes valeurs `text` et `jsonb` compressées par une méthode plus efficace, selon le projet |
| JIT désactivé par défaut | Moins de surprises sur les requêtes courtes ; à réactiver pour l'analytique lourde |
| `IGNORE NULLS` pour `lag()`, `lead()`, `first_value()`, `last_value()` et `nth_value()` | Plus besoin de sous-requête pour « la dernière valeur non nulle » |

Le JIT mérite une phrase de plus : il était activé par défaut et déclenché selon les coûts estimés par le planificateur, une estimation que le projet juge maintenant peu fiable[^4]. Les bases très analytiques devront le rallumer elles-mêmes.

### Avant de migrer : version majeure, pg_upgrade et tests

PostgreSQL 19 est une version majeure : le format de stockage interne peut changer, et passer de la 18 à la 19 demande `pg_dumpall`, `pg_upgrade` ou la réplication logique, pas un simple remplacement des binaires[^4]. La documentation propose `pg_upgrade --check` pour vérifier la compatibilité des deux clusters sans rien modifier, même avec l'ancien serveur en marche[^13]. Depuis la 18, `pg_upgrade` conserve la plupart des statistiques du planificateur ; il reste à lancer `vacuumdb` comme il l'indique à la fin[^13].

La section « Migration to Version 19 » des notes de version contient les changements qui peuvent casser une application[^4] :

| Changement | Risque |
|---|---|
| `standard_conforming_strings` toujours activé | Les dumps faits avec un `pg_dump` antérieur à la 19 et ce paramètre désactivé ne se rechargent pas correctement |
| Avertissement après chaque authentification par mot de passe MD5 | Rappel que MD5 est déprécié depuis la 18 ; désactivable avec `md5_password_warnings` |
| `json_array()` sur une requête sans résultat renvoie `[]` au lieu de `NULL` | Code applicatif qui testait `NULL` |
| `max_locks_per_transaction` passe de 64 à 128, avec une nouvelle allocation | Une valeur personnalisée doit être doublée pour garder la même capacité |
| Recherche plein texte et `pg_trgm` suivent le fournisseur de locale de la base | Index à reconstruire après `pg_upgrade` si la locale n'est pas libc |

Si vous avez testé les préversions : la RC 2 a retiré l'usage de `JSON_ARRAY()` et `JSON_OBJECT()` sur des tableaux, types composites ou intervalles dans les index d'expression, colonnes générées et clés de partition. Les objets créés ainsi doivent être supprimés ou redéfinis avant la mise à niveau, sinon `pg_dump` et `pg_upgrade` échoueront à les recréer[^3].

Reste ce que personne ne fera à votre place : passer votre suite de tests sur la nouvelle version. La documentation conseille d'installer l'ancienne et la nouvelle côte à côte et de tester les applications clientes avant de basculer[^13]. Une suite de [tests d'intégration qui lancent un vrai PostgreSQL](/blog/tests-integration-testcontainers-go/) dans un conteneur rend l'exercice presque gratuit : changer l'étiquette de l'image, relancer, lire ce qui casse. Rien ne presse non plus : le projet maintient chaque version majeure cinq ans[^14], et c'est la 14, pas la 18, qui a reçu sa dernière mise à jour le 12 novembre 2026[^3].

---

Pendant des années, pour relire une ligne qui existait déjà, on l'a réécrite, parce que c'était la façon la plus simple de la faire sortir du `RETURNING`. PostgreSQL 19 ajoute la façon évidente, et une autre pour attendre qu'une réplique ait rattrapé le principal au lieu de l'espérer. La première ne figure même pas dans le résumé officiel ; la seconde y arrive en avant-dernière ligne. Les fiches qui changent le code d'une application se trouvent rarement en tête du registre.

---

[^1]: L'[annonce de PostgreSQL 19 RC 1](https://www.postgresql.org/about/news/postgresql-19-rc-1-released-3409/), publiée le 15 octobre 2026, avec la date prévue et le calendrier.

[^2]: Le [message de Jonathan S. Katz sur la liste pgsql-hackers](https://www.postgresql.org/message-id/915517c4-d0ee-49f9-bbeb-c683ef2b9d3f%40postgresql.org), le 28 septembre 2026, fixait la RC 1 au 15 octobre et la sortie au jeudi 29 octobre 2026, sauf problème important.

[^3]: L'[annonce du 12 novembre 2026](https://www.postgresql.org/about/news/postgresql-187-1712-1616-1520-1425-and-19-rc-2-released-3442/) : versions 18.7, 17.12, 16.16, 15.20 et 14.25, et PostgreSQL 19 RC 2.

[^4]: Les [notes de version de PostgreSQL 19](https://www.postgresql.org/docs/19/release-19.html), consultées dans leur état du 9 octobre 2026.

[^5]: La [documentation de la commande INSERT](https://www.postgresql.org/docs/19/sql-insert.html) de PostgreSQL 19, section « ON CONFLICT Clause » et exemples. Elle précise aussi que, sur le chemin `DO SELECT`, les valeurs `NEW` renvoyées sont identiques aux valeurs `OLD`, puisque rien n'est modifié.

[^6]: La [référence de l'API QuerySet de Django](https://docs.djangoproject.com/en/6.1/ref/models/querysets/#get-or-create), section `get_or_create()` : sans contrainte d'unicité sur les champs recherchés, des appels concurrents peuvent insérer plusieurs lignes identiques.

[^7]: La [documentation de la commande WAIT](https://www.postgresql.org/docs/19/sql-wait.html) décrit ses quatre modes et ses restrictions. Si la réplique est promue pendant l'attente, le statut renvoyé est `not in recovery`.

[^8]: La [documentation de la commande COPY](https://www.postgresql.org/docs/19/sql-copy.html), options `FORMAT`, `FORCE_ARRAY` et `ON_ERROR`.

[^9]: La [page des fonctions JSON](https://www.postgresql.org/docs/19/functions-json.html) de PostgreSQL 19, tableau des méthodes jsonpath.

[^10]: La [page du type UUID](https://www.postgresql.org/docs/19/datatype-uuid.html) de PostgreSQL 19, dont sont tirés les deux exemples de conversion.

[^11]: La [page des fonctions sur les chaînes binaires](https://www.postgresql.org/docs/19/functions-binarystring.html) : `base64url` y suit la RFC 4648, section 5.

[^12]: La [documentation de la commande REPACK](https://www.postgresql.org/docs/19/sql-repack.html), en particulier la section « Notes on Concurrent Operation » et son avertissement sur la sécurité MVCC.

[^13]: La section [« Upgrading a PostgreSQL Cluster »](https://www.postgresql.org/docs/19/upgrading.html) et la [documentation de pg_upgrade](https://www.postgresql.org/docs/19/pgupgrade.html).

[^14]: La [politique de versions du projet](https://www.postgresql.org/support/versioning/) : une version majeure par an environ, cinq ans de maintenance chacune.



