Kaj je UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** pomeni »vstavi ali posodobi, če že obstaja«. PostgreSQL to izvaja z **`INSERT ... ON CONFLICT`** — vstaviš vrstico, vendar če bi kršila omejitev edinstvenosti, namesto tega posodobiš obstoječo vrstico (ali ne narediš ničesar). Atomsko obravnava pogosto potrebo »vstavi ali posodobi«.

## Problem, ki ga UPSERT rešuje

```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 — vstavi ali posodobi

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

Če bi vstavljanje spodletelo na omejitvi edinstvenosti `email`, PostgreSQL posodobi obstoječo vrstico. **`EXCLUDED`** se nanaša na vrednosti, ki ste jih poskušali vstaviti, in lahko referencirate tudi obstoječo vrstico (`users.login_count`) — kar omogoča logiko, kot je povečanje števca.

## ON CONFLICT DO NOTHING — vstavi ali preskoči

```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` tiho preskoči konfliktne vrstice — koristno za »vstavi, če ne obstaja« brez napak.

## Pogosta praktična uporaba: števci in idempotentne vstavljanja

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

## Zakaj je to pomembno

UPSERT (`INSERT ... ON CONFLICT`) je pomembna, praktično dragocena PostgreSQL funkcionalnost, ki čisto rešuje zelo pogosto potrebo »vstavi ali posodobi** in to **varno**, zato je razumevanje te funkcionalnosti koristno za pravi podatkovne operacije.

Potrebnost — vstavljanje vrstice, ki morda že obstaja (po ključu edinstvenosti) — se pojavljja nenehno (upsert zapisov, števci, idempotentna vstavljanja, sinhronizacija podatkov), in preproste alternative so problematične: navadno INSERT spodleti z napako, če vrstica obstaja, in pristop preveri-nato-vstavi (SELECT nato INSERT-ali-UPDATE) ima **tekmovalno stanje** (druga sočasna transakcija bi lahko vstavila med vašo prevero in vstavitvijo, kar povzroči napake ali izgubljene posodobitve). `ON CONFLICT` to rešuje **atomsko v enojni izjavi** — kar izključuje tekmovalno stanje, kar je njegova ključna prednost za pravilnost v sočasnih aplikacijah.

Razumevanje obeh oblik — **`DO UPDATE`** (vstavi ali posodobi, z `EXCLUDED` referencirajočim poskušane vrednosti in možnostjo referencianja obstoječe vrstice za logiko, kot je povečanje števca) in **`DO NOTHING`** (vstavi ali tiho preskoči) — pokriva običajne vzorce (upsert zapisov, idempotentna vstavljanja, vzdrževanje števcev/agregatov).

Ker je vstavi-ali-posodobi pogosta operacija in jo pravilno in varno izvedti (atomsko, brez tekmovalnih stanj) je važno za celovitost podatkov v sočasnih aplikacijah, je razumevanje UPSERT — kaj rešuje, korist atomskosti/tekmovalnega stanja in oblike DO UPDATE/DO NOTHING — dragoceno, pogosto uporabljeno PostgreSQL znanje, ki zagotavlja čisto, varno rešitev pogosti potrebi, ki je sicer dovzetna za napake, zato je važna, praktična značilnost za prave aplikacije.