Kas yra UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** reiškia „įterpti arba atnaujinti, jei jau egzistuoja“. PostgreSQL tai įgyvendina su **`INSERT ... ON CONFLICT`** — įterpiama eilutė, bet jei tai pažeistų unikalumo apribojimą (unique constraint), vietoj to atnaujinama esama eilutė (arba nedaroma nieko). Taip atomiškai patenkinamas dažnas „įterpti arba atnaujinti“ poreikis.

## Problema, kurią sprendžia UPSERT

```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 — įterpti arba atnaujinti

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

Jei įterpimas sukeltų konfliktą su `email` unikalumo apribojimu, Postgres vietoj to atnaujina esamą eilutę. **`EXCLUDED`** nurodo reikšmes, kurias bandėte įterpti, o jūs taip pat galite remtis esama eilute (`users.login_count`) — tai leidžia tokią logiką kaip skaitiklio didinimas.

## ON CONFLICT DO NOTHING — įterpti arba praleisti

```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` tyliai praleidžia konfliktuojančias eilutes — naudinga „įterpti, jei dar nėra“ be klaidų.

## Dažnas realus panaudojimas: skaitikliai ir idempotentiniai įterpimai

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

## Kodėl tai svarbu

UPSERT (`INSERT ... ON CONFLICT`) yra svarbi, praktiškai vertinga PostgreSQL funkcija, kuri švariai ir **saugiai** sprendžia labai dažną „įterpti arba atnaujinti“ poreikį, todėl jos supratimas naudingas realioms duomenų operacijoms.

Poreikis — įterpti eilutę, kuri galbūt jau egzistuoja (pagal unikalų raktą) — kyla nuolat (įrašų upsert'inimas, skaitikliai, idempotentiniai įterpimai, duomenų sinchronizavimas), o naivūs alternatyvūs sprendimai yra problemiški: paprastas INSERT nepavyksta su klaida, jei eilutė egzistuoja, o patikrinti-tada-įterpti būdas (SELECT, tada INSERT arba UPDATE) turi **lenktynių sąlygą** (race condition) (kita lygiagreti transakcija gali įterpti tarp jūsų patikrinimo ir įterpimo, sukeldama klaidas arba prarastus atnaujinimus). `ON CONFLICT` tai išsprendžia **atomiškai viename sakinyje** — pašalindamas lenktynių sąlygą, o tai yra jo pagrindinis korektiškumo privalumas lygiagretiems taikymams.

Abiejų formų supratimas — **`DO UPDATE`** (įterpti arba atnaujinti, kai `EXCLUDED` nurodo bandytas reikšmes, o galimybė remtis esama eilute leidžia tokią logiką kaip skaitiklių didinimas) ir **`DO NOTHING`** (įterpti arba tyliai praleisti) — apima dažnus šablonus (įrašų upsert'inimas, idempotentiniai įterpimai, skaitiklių/agregatų palaikymas).

Kadangi įterpti-arba-atnaujinti yra dažna operacija, o jos atlikimas teisingai ir saugiai (atomiškai, be lenktynių sąlygų) yra svarbus duomenų vientisumui lygiagrečiuose taikymuose, UPSERT supratimas — ką jis sprendžia, atomiškumo/lenktynių sąlygos privalumą ir DO UPDATE/DO NOTHING formas — yra vertingos, dažnai taikomos PostgreSQL žinios, suteikiančios švarų, saugų sprendimą dažnam poreikiui, kuris kitaip yra linkęs į klaidas, todėl tai praktiška, svarbi funkcija realiems taikymams.