Što je UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** znači "umetnuti, ili ažurirati ako već postoji." PostgreSQL to implementira s **`INSERT ... ON CONFLICT`** — umetni red, ali ako bi narušio ograničenje jedinstvnosti, umjesto toga ažuriraj postojeći red (ili ne radi ništa). To rješava česta potreba "umetnuti-ili-ažurirati" atomski.

## Problem koji UPSERT rješava

```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 — umetnuti ili ažurirati

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

Ako bi umetanje došlo do konflikta na ograničenju jedinstvnosti `email`, Postgres ažurira postojeći red umjesto toga. **`EXCLUDED`** se odnosi na vrijednosti koje ste pokušali umetnuti, a možete referencirati i postojeći red (`users.login_count`) — omogućavajući logiku kao što je inkrementiranje brojača.

## ON CONFLICT DO NOTHING — umetnuti ili preskočiti

```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 preskače konfliktne redove — korisno za "umetnuti ako nije prisutan" bez grešaka.

## Česta praktična primjena: brojači i idempotentne umetanja

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

## Zašto je važno

UPSERT (`INSERT ... ON CONFLICT`) je važna, praktično vrijedna PostgreSQL značajka koja čisto i **sigurno** rješava vrlo česta potreba "umetnuti-ili-ažurirati", pa je razumijevanje toga korisno za pravi rad s podacima.

Potrebom — umetanja reda koji možda već postoji (prema jedinstvenom ključu) — dolazi stalno (ažuriranje zapisa, brojači, idempotentne umetanja, sinkronizacija podataka), a naivne alternative su problematične: obična INSERT neće raditi ako red postoji, a pristup provjera-pa-umetnite (SELECT pa INSERT-ili-AŽURIRAJ) ima **utrku na vrijeme** (druga konkurentna transakcija mogla bi umetnuti između vaše provjere i vašeg umetanja, uzrokujući greške ili izgubljene ažuriranja). `ON CONFLICT` to rješava **atomski u jednoj naredbi** — eliminirajući utrku na vrijeme, što je njegova ključna korist ispravnosti za konkurentne aplikacije.

Razumijevanje oba oblika — **`DO UPDATE`** (umetnuti ili ažurirati, s `EXCLUDED` koja referencira pokušane vrijednosti i mogućnost referenciranja postojećeg reda za logiku kao što je inkrementiranje brojača) i **`DO NOTHING`** (umetnuti ili preskočiti tiho) — pokriva česte obrasce (ažuriranje zapisa, idempotentne umetanja, održavanje brojača/agregata).

Budući da je umetnuti-ili-ažurirati česta operacija i da ju ispravno i sigurno činiti (atomski, bez utrka na vrijeme) važno je za integritet podataka u konkurentnim aplikacijama, razumijevanje UPSERT-a — što rješava, korist atomske/utrke na vrijeme, i oblici DO UPDATE/DO NOTHING — je vrijedna, često primjenjiva PostgreSQL znanja koja pruža čisto, sigurno rješenje za česte potrebe koje su inače sklone greškama, što je prakničnu, važnu značajku za prave aplikacije.