Hvad er UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** betyder "indsæt, eller opdater hvis det allerede findes." PostgreSQL implementerer dette med **`INSERT ... ON CONFLICT`** — indsæt en række, men hvis det ville krænke en unik constraint, opdater i stedet den eksisterende række (eller gør ingenting). Det håndterer det almindelige "indsæt-eller-opdater"-behov atomart.

## Problemet UPSERT løser

```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 — indsæt eller opdater

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

Hvis indsættelse ville være i konflikt med `email` unik constraint, opdaterer Postgres den eksisterende række i stedet. **`EXCLUDED`** refererer til de værdier, du forsøgte at indsætte, og du kan også referere den eksisterende række (`users.login_count`) — hvilket gør det muligt at have logik som f.eks. at øge en tæller.

## ON CONFLICT DO NOTHING — indsæt eller spring over

```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` springer stille over konflikterende rækker — brugbart til "indsæt hvis ikke til stede" uden fejl.

## Et almindeligt praktisk eksempel: tællere og idempotente indsættelser

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

## Hvorfor det betyder noget

UPSERT (`INSERT ... ON CONFLICT`) er en vigtig, praktisk-værdifuld PostgreSQL-funktion, der løser det meget almindelige "indsæt-eller-opdater"-behov på en ren og **sikker** måde, så forståelsen af det er nyttig til data-operationer i den virkelige verden.

Behovet — at indsætte en række, der måske allerede findes (efter en unik nøgle) — opstår konstant (opserting af poster, tællere, idempotente indsættelser, synkronisering af data), og de naive alternativer er problematiske: en almindelig INSERT fejler med en fejl, hvis rækken findes, og check-then-insert-tilgangen (SELECT derefter INSERT-eller-UPDATE) har en **race condition** (en anden samtidig transaktion kunne indsætte mellem dit tjek og din indsættelse, hvilket forårsager fejl eller tabte opdateringer). `ON CONFLICT` løser dette **atomart i en enkelt statement** — eliminerer race condition, hvilket er dets vigtigste korrekthedfordel for samtidige applikationer.

Forståelse af begge former — **`DO UPDATE`** (indsæt eller opdater, med `EXCLUDED` der refererer til de forsøgte værdier og muligheden for at referere den eksisterende række til logik som at øge tællere) og **`DO NOTHING`** (indsæt eller spring over stille) — dækker de almindelige mønstre (upserting af poster, idempotente indsættelser, vedligeholdelse af tællere/aggregater).

Da indsæt-eller-opdater er en hyppig operation, og gør det korrekt og sikkert (atomart, uden race conditions) betyder noget for dataintegritet i samtidige applikationer, forståelse af UPSERT — hvad det løser, atomicitets-/race-condition-fordelen og DO UPDATE/DO NOTHING-formerne — er værdifuld, hyppigt anvendt PostgreSQL-viden, der giver en ren, sikker løsning til et almindeligt behov, som ellers er fejlbehæftet, hvilket gør det til en praktisk, vigtig funktion til rigtige applikationer.