Vad är UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** betyder "infoga, eller uppdatera om det redan finns". PostgreSQL implementerar detta med **`INSERT ... ON CONFLICT`** — infoga en rad, men om det skulle bryta mot en unik constraint, uppdatera istället den befintliga raden (eller gör ingenting). Det hanterar det vanliga "infoga-eller-uppdatera"-behovet atomärt.

## Problemet som 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 — infoga eller uppdatera

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

Om infogning skulle hamna i konflikt med `email` unik constraint, uppdaterar Postgres den befintliga raden istället. **`EXCLUDED`** refererar till värdena du försökte infoga, och du kan också referera till den befintliga raden (`users.login_count`) — vilket möjliggör logik som att öka en räknare.

## ON CONFLICT DO NOTHING — infoga eller hoppa över

```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` hoppar tyst över raderna i konflikt — användbart för "infoga om den inte finns" utan fel.

## Ett vanligt verkligt användningsfall: räknare och idempotenta infogningar

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

## Varför det är viktigt

UPSERT (`INSERT ... ON CONFLICT`) är en viktig, praktisk PostgreSQL-funktion som löser det mycket vanliga "infoga-eller-uppdatera"-behovet rent och **säkert**, så att förstå det är användbart för verklig dataoperationer.

Behovet — att infoga en rad som kanske redan finns (enligt en unik nyckel) — uppstår ständigt (upserta poster, räknare, idempotenta infogningar, synkronisera data), och de naiva alternativen är problematiska: en vanlig INSERT misslyckas med ett fel om raden redan finns, och check-then-insert-metoden (SELECT sedan INSERT-eller-UPDATE) har en **race condition** (en annan samtidig transaktion kunde infoga mellan din kontroll och din infogning, vilket orsakar fel eller förlorade uppdateringar). `ON CONFLICT` löser detta **atomärt i ett enda uttalande** — vilket eliminerar race condition, vilket är dess nyckelrättighetsfördel för samtidiga applikationer.

Att förstå båda formerna — **`DO UPDATE`** (infoga eller uppdatera, med `EXCLUDED` som refererar till försökta värden och möjligheten att referera till den befintliga raden för logik som att öka räknare) och **`DO NOTHING`** (infoga eller hoppa över tyst) — täcker de vanliga mönstren (upserta poster, idempotenta infogningar, underhålla räknare/aggregat).

Eftersom infoga-eller-uppdatera är en ofta förekommande operation och att göra det korrekt och säkert (atomärt, utan race conditions) är viktigt för dataintegritet i samtidiga applikationer, är förståelse för UPSERT — vad det löser, atomiciteten/race-condition-fördelen, och DO UPDATE/DO NOTHING-formerna — värdefull, ofta använd PostgreSQL-kunskap som ger en ren, säker lösning på ett vanligt behov som annars är felbenäget, vilket gör det till en praktisk, viktig funktion för verkliga applikationer.