Wat is UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** betekent "invoegen, of bijwerken als het al bestaat." PostgreSQL implementeert dit met **`INSERT ... ON CONFLICT`** — voeg een rij in, maar als dit een unique constraint zou schenden, werk dan in plaats daarvan de bestaande rij bij (of doe niets). Het handelt de veelvoorkomende "insert-or-update"-behoefte atomisch af.

## Het probleem dat UPSERT oplost

```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 — invoegen of bijwerken

```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
```

Als invoegen zou conflicteren met de unique constraint op `email`, werkt Postgres in plaats daarvan de bestaande rij bij. **`EXCLUDED`** verwijst naar de waarden die je probeerde in te voegen, en je kunt ook naar de bestaande rij verwijzen (`users.login_count`) — wat logica zoals het ophogen van een teller mogelijk maakt.

## ON CONFLICT DO NOTHING — invoegen of overslaan

```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` slaat conflicterende rijen stilletjes over — handig voor "invoegen als nog niet aanwezig" zonder fouten.

## Een veelvoorkomend praktijkgebruik: tellers en idempotente inserts

```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;
```

## Waarom het belangrijk is

UPSERT (`INSERT ... ON CONFLICT`) is een belangrijke, praktisch waardevolle PostgreSQL-feature die de zeer veelvoorkomende "insert-or-update"-behoefte op een nette en **veilige** manier oplost, dus het begrijpen ervan is nuttig voor data-operaties in de praktijk.

De behoefte — het invoegen van een rij die mogelijk al bestaat (op basis van een unique key) — komt voortdurend voor (records upserten, tellers, idempotente inserts, data synchroniseren), en de naïeve alternatieven zijn problematisch: een gewone INSERT mislukt met een fout als de rij bestaat, en de check-then-insert-aanpak (SELECT gevolgd door INSERT-or-UPDATE) heeft een **race condition** (een andere gelijktijdige transactie kan invoegen tussen je check en je insert, wat fouten of verloren updates veroorzaakt). `ON CONFLICT` lost dit **atomisch op in één enkele statement** — waarmee de race condition wordt geëlimineerd, wat het belangrijkste correctheidsvoordeel is voor gelijktijdige applicaties.

Het begrijpen van beide vormen — **`DO UPDATE`** (invoegen of bijwerken, waarbij `EXCLUDED` verwijst naar de gepoogde waarden en met de mogelijkheid om naar de bestaande rij te verwijzen voor logica zoals het ophogen van tellers) en **`DO NOTHING`** (invoegen of stilletjes overslaan) — dekt de veelvoorkomende patronen (records upserten, idempotente inserts, tellers/aggregaten bijhouden).

Aangezien insert-or-update een veelvoorkomende operatie is en het correct en veilig uitvoeren ervan (atomisch, zonder race conditions) van belang is voor data-integriteit in gelijktijdige applicaties, is het begrijpen van UPSERT — wat het oplost, het atomiciteit-/race-conditionvoordeel, en de DO UPDATE/DO NOTHING-vormen — waardevolle, vaak toegepaste PostgreSQL-kennis die een nette, veilige oplossing biedt voor een veelvoorkomende behoefte die anders foutgevoelig is, waardoor het een praktische, belangrijke feature is voor echte applicaties.