Co je UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** znamená "vlož, nebo aktualizuj, pokud již existuje." PostgreSQL to implementuje pomocí **`INSERT ... ON CONFLICT`** — vloží řádek, ale pokud by porušil unique constraint, místo toho aktualizuje existující řádek (nebo neudělá nic). Atomicky řeší běžnou potřebu "vlož nebo aktualizuj".

## Problém, který UPSERT řeší

```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 — vlož nebo aktualizuj

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

Pokud by vložení způsobilo konflikt na unique constraintu `email`, Postgres místo toho aktualizuje existující řádek. **`EXCLUDED`** odkazuje na hodnoty, které jste se pokusili vložit, a můžete odkazovat i na existující řádek (`users.login_count`) — což umožňuje logiku jako inkrementaci čítače.

## ON CONFLICT DO NOTHING — vlož nebo přeskoč

```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` tiše přeskočí konfliktní řádky — užitečné pro "vlož, pokud ještě neexistuje" bez chyb.

## Časté reálné využití: čítače a idempotentní vkládání

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

## Proč je to důležité

UPSERT (`INSERT ... ON CONFLICT`) je důležitá a prakticky cenná funkce PostgreSQL, která čistě a **bezpečně** řeší velmi běžnou potřebu "vlož nebo aktualizuj", takže porozumět jí je užitečné pro reálné datové operace.

Tato potřeba — vložit řádek, který už možná existuje (podle unique klíče) — vzniká neustále (upsertování záznamů, čítače, idempotentní vkládání, synchronizace dat) a naivní alternativy jsou problematické: prosté INSERT selže s chybou, pokud řádek existuje, a přístup check-then-insert (SELECT a poté INSERT-nebo-UPDATE) má **race condition** (jiná souběžná transakce by mohla vložit záznam mezi vaši kontrolou a vložením, což způsobí chyby nebo ztracené aktualizace). `ON CONFLICT` to řeší **atomicky v jediném příkazu** — eliminuje race condition, což je jeho klíčový přínos pro správnost v souběžných aplikacích.

Porozumění oběma formám — **`DO UPDATE`** (vlož nebo aktualizuj, s `EXCLUDED` odkazujícím na pokoušené hodnoty a možností odkazovat na existující řádek pro logiku jako inkrementace čítačů) a **`DO NOTHING`** (vlož nebo tiše přeskoč) — pokrývá běžné vzory (upsertování záznamů, idempotentní vkládání, údržba čítačů/agregací).

Protože vkládání-nebo-aktualizace je častá operace a dělat ji správně a bezpečně (atomicky, bez race conditions) je důležité pro integritu dat v souběžných aplikacích, porozumění UPSERTu — co řeší, přínos atomicity/eliminace race condition a formám DO UPDATE/DO NOTHING — je cenná, často využívaná znalost PostgreSQL, která poskytuje čisté a bezpečné řešení běžné potřeby, jež je jinak náchylná k chybám, což z ní činí praktickou a důležitou funkci pro reálné aplikace.