Mi az UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** azt jelenti, hogy "szúrj be, vagy frissítsd, ha már létezik." A PostgreSQL ezt az **`INSERT ... ON CONFLICT`** utasítással valósítja meg — szúrj be egy sort, de ha ez megsértene egy egyedi korlátot, akkor frissítsd a meglévő sort (vagy ne csinálj semmit). Atomiasan kezel az általános "beszúrás vagy frissítés" igényt.

## Az a probléma, amelyet az UPSERT megold

```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 — beszúrás vagy frissítés

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

Ha a beszúrás konfliktusban lenne az `email` egyedi korláttal, a Postgres frissíti a meglévő sort. Az **`EXCLUDED`** a beszúrni próbált értékekre hivatkozik, és a meglévő sorra is hivatkozhatsz (`users.login_count`) — így olyan logika engedélyezhető, mint egy számláló inkrementálása.

## ON CONFLICT DO NOTHING — beszúrás vagy kihagyás

```sql
INSERT INTO users (email, name) VALUES ('ann@x.com', 'Ann')
ON CONFLICT (email) DO NOTHING;      -- if it exists, just skip (no error)
```

A `DO NOTHING` csendesen kihagyja az ütköző sorokat — hasznos "beszúrás, ha nincs jelen" esetre hibák nélkül.

## Egy gyakori valós felhasználás: számlálók és idempotens beszúrások

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

## Miért számít

Az UPSERT (`INSERT ... ON CONFLICT`) egy fontos, gyakorlatban értékes PostgreSQL funkció, amely tisztán és **biztonságosan** oldja meg a nagyon gyakori "beszúrás vagy frissítés" igényt, ezért a megértése hasznos a valós adatműveletekhez.

Az igény — olyan sor beszúrása, amely már létezhet (egyedi kulcs alapján) — folyamatosan felmerül (rekordok frissítése, számlálók, idempotens beszúrások, adatok szinkronizálása), és az egyedi alternatívák problematikusak: egy sima INSERT hibával meghiúsul, ha a sor létezik, és az ellenőrzés-majd-beszúrás megközelítés (SELECT majd INSERT vagy UPDATE) **verseny-feltételnek** van kitéve (egy másik egyidejű tranzakció az ellenőrzés és a beszúrás között beszúrhat, hibákat vagy elveszett frissítéseket okozva). Az `ON CONFLICT` ezt **atomiasan egyetlen utasítással** oldja meg — kiküszöbölve a verseny-feltételt, amely a fő helyességi előnye az egyidejű alkalmazások számára.

mindkét forma megértése — az **`DO UPDATE`** (beszúrás vagy frissítés, az `EXCLUDED` a megkísérelt értékekre hivatkozik és képesség a meglévő sorra való hivatkozásra olyan logikához, mint számlálók inkrementálása) és a **`DO NOTHING`** (beszúrás vagy csend megmaradása) — magában foglalja az általános mintákat (rekordok frissítése, idempotens beszúrások, számlálók/összesítések fenntartása).

Mivel a beszúrás-vagy-frissítés gyakori művelet, és helyesen és biztonságosan (atomiasan, verseny-feltételek nélkül) végzése fontos az adatintegritás számára az egyidejű alkalmazásokban, az UPSERT megértése — amit megold, az atomicitás/verseny-feltétel előnye és a DO UPDATE/DO NOTHING formák — értékes, gyakran alkalmazott PostgreSQL ismeret, amely tiszta, biztonságos megoldást nyújt egy olyan gyakori igényre, amely egyébként hibalehetőséges, így egy praktikus, fontos funkció a valós alkalmazások számára.