Qu'est-ce qu'UPSERT (INSERT ON CONFLICT) ?

Question

Accepted Answer

**UPSERT** signifie « insérer, ou mettre à jour si cela existe déjà ». PostgreSQL implémente ceci avec **`INSERT ... ON CONFLICT`** — insérer une ligne, mais si elle viole une contrainte d'unicité, mettre à jour la ligne existante à la place (ou ne rien faire). Cela gère le besoin courant « insérer-ou-mettre-à-jour » de manière atomique.

## Le problème qu'UPSERT résout

```text
You want to insert a row, but it might already exist (by a unique key):
  ❌ a plain INSERT fails with a unique-violation error if it exists
  ❌ check-then-insert (SELECT, then INSERT or UPDATE) has a RACE CONDITION
     (another transaction could insert between your check and insert)
→ ON CONFLICT does it atomically in ONE statement (no race condition)
```

## ON CONFLICT DO UPDATE — insérer ou mettre à jour

```sql
INSERT INTO users (email, name, login_count)
VALUES ('ann@x.com', 'Ann', 1)
ON CONFLICT (email)                  -- if a row with this email already exists...
DO UPDATE SET                        -- ...UPDATE it instead
  name = EXCLUDED.name,              -- EXCLUDED = the values you tried to insert
  login_count = users.login_count + 1;  -- can reference the existing row too
```

Si l'insertion entrerait en conflit sur la contrainte d'unicité `email`, Postgres met à jour la ligne existante à la place. **`EXCLUDED`** fait référence aux valeurs que vous avez tenté d'insérer, et vous pouvez aussi référencer la ligne existante (`users.login_count`) — permettant une logique comme incrémenter un compteur.

## ON CONFLICT DO NOTHING — insérer ou sauter

```sql
INSERT INTO users (email, name) VALUES ('ann@x.com', 'Ann')
ON CONFLICT (email) DO NOTHING;      -- if it exists, just skip (no error)
```

`DO NOTHING` saute silencieusement les lignes en conflit — utile pour « insérer si absent » sans erreurs.

## Un cas d'usage courant : compteurs et insertions idempotentes

```sql
-- track page views — insert on first view, increment on subsequent
INSERT INTO page_views (page_id, views) VALUES (5, 1)
ON CONFLICT (page_id) DO UPDATE SET views = page_views.views + 1;
```

## Pourquoi c'est important

UPSERT (`INSERT ... ON CONFLICT`) est une fonctionnalité PostgreSQL importante et pratiquement précieuse qui résout le besoin très courant « insérer-ou-mettre-à-jour » de manière propre et **sûre**, donc la comprendre est utile pour les opérations de données réelles.

Le besoin — insérer une ligne qui pourrait déjà exister (selon une clé d'unicité) — surgit constamment (upserter des enregistrements, compteurs, insertions idempotentes, synchroniser des données), et les alternatives naïves sont problématiques : une simple INSERT échoue avec une erreur si la ligne existe, et l'approche « vérifier-puis-insérer » (SELECT puis INSERT-ou-UPDATE) a une **condition de concurrence** (une autre transaction concurrente pourrait insérer entre votre vérification et votre insertion, causant des erreurs ou des mises à jour perdues). `ON CONFLICT` résout cela **de manière atomique dans une seule instruction** — éliminant la condition de concurrence, qui est son avantage clé de correction pour les applications concurrentes.

Comprendre les deux formes — **`DO UPDATE`** (insérer ou mettre à jour, avec `EXCLUDED` référençant les valeurs tentées et la capacité de référencer la ligne existante pour une logique comme incrémenter des compteurs) et **`DO NOTHING`** (insérer ou sauter silencieusement) — couvre les motifs courants (upserter des enregistrements, insertions idempotentes, maintenir des compteurs/agrégats).

Puisque insérer-ou-mettre-à-jour est une opération fréquente et le faire correctement et sûrement (de manière atomique, sans conditions de concurrence) importe pour l'intégrité des données dans les applications concurrentes, comprendre UPSERT — ce qu'il résout, l'avantage atomicité/absence de conditions de concurrence, et les formes DO UPDATE/DO NOTHING — est une connaissance PostgreSQL précieuse et fréquemment appliquée qui fournit une solution propre et sûre à un besoin courant qui serait autrement sujet à erreurs, en faisant une fonctionnalité pratique et importante pour les applications réelles.