Hva er UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** betyr «sett inn, eller oppdater hvis det allerede finnes». PostgreSQL implementerer dette med **`INSERT ... ON CONFLICT`** — sett inn en rad, men hvis det ville bryte en unik constraint, oppdater den eksisterende raden i stedet (eller gjør ingenting). Det håndterer det vanlige «sett-inn-eller-oppdater»-behovet atomært.

## 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 — sett inn eller oppdater

```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 innsetting ville kollidere med `email` unik constraint, oppdaterer Postgres den eksisterende raden i stedet. **`EXCLUDED`** refererer til verdiene du forsøkte å sette inn, og du kan også referere til den eksisterende raden (`users.login_count`) — noe som muliggjør logikk som å øke en teller.

## ON CONFLICT DO NOTHING — sett inn eller hopp 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` hopper stilig over kolliderende rader — nyttig for «sett inn hvis ikke til stede» uten feil.

## Et vanlig brukstilfelle: tellere og idempotente innsettinger

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

UPSERT (`INSERT ... ON CONFLICT`) er en viktig, praktisk verdifull PostgreSQL-funksjon som løser det svært vanlige «sett-inn-eller-oppdater»-behovet på en ren og **sikker** måte, så å forstå det er nyttig for virkelige datapperasjoner.

Behovet — å sette inn en rad som kanskje allerede finnes (etter en unik nøkkel) — oppstår konstant (oppdatering av oppføringer, tellere, idempotente innsettinger, synkronisering av data), og de naive alternativene er problematiske: en vanlig INSERT mislykkes med en feil hvis raden finnes, og check-så-sett-inn-tilnærmingen (SELECT så INSERT-eller-UPDATE) har en **race condition** (en annen samtidig transaksjon kunne sett inn mellom sjekken og innsettingen din, noe som forårsaker feil eller tapte oppdateringer). `ON CONFLICT` løser dette **atomært i en enkelt setning** — eliminerer race condition, som er dens viktigste korrektighetsfordel for samtidige applikasjoner.

Å forstå begge former — **`DO UPDATE`** (sett inn eller oppdater, med `EXCLUDED` som refererer til forsøkte verdier og evnen til å referere til den eksisterende raden for logikk som å øke tellere) og **`DO NOTHING`** (sett inn eller hopp over stille) — dekker de vanlige mønstrene (oppdatering av oppføringer, idempotente innsettinger, vedlikehold av tellere/aggregater).

Siden sett-inn-eller-oppdater er en hyppig operasjon og å gjøre det riktig og sikkert (atomært, uten race conditions) er viktig for dataintegritet i samtidige applikasjoner, er forståelse av UPSERT — hva det løser, atomisitets-/race-condition-fordelen, og DO UPDATE/DO NOTHING-formene — verdifull, hyppig brukt PostgreSQL-kunnskap som gir en ren, sikker løsning på et vanlig behov som ellers er fejlmettet, noe som gjør det til en praktisk, viktig funksjon for virkelige applikasjoner.