Was ist UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** bedeutet "einfügen, oder aktualisieren, falls es bereits existiert." PostgreSQL implementiert dies mit **`INSERT ... ON CONFLICT`** — füge eine Zeile ein, aber falls dies gegen eine Unique-Constraint verstoßen würde, aktualisiere stattdessen die existierende Zeile (oder mache nichts). Es löst das häufige "einfügen-oder-aktualisieren"-Bedürfnis atomar.

## Warum es wichtig ist

```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 — einfügen oder aktualisieren

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

Wenn das Einfügen gegen die `email` Unique-Constraint verstoßen würde, aktualisiert Postgres stattdessen die existierende Zeile. **`EXCLUDED`** bezieht sich auf die Werte, die du einfügen wolltest, und du kannst auch die existierende Zeile (`users.login_count`) referenzieren — was Logik wie das Erhöhen eines Zählers ermöglicht.

## ON CONFLICT DO NOTHING — einfügen oder überspringen

```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` überspringt konfliktverursachende Zeilen stillschweigend — nützlich für "einfügen, falls nicht vorhanden" ohne Fehler.

## Ein häufiger realer Anwendungsfall: Zähler und idempotente Einfügungen

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

## Warum es wichtig ist

UPSERT (`INSERT ... ON CONFLICT`) ist eine wichtige, praktisch wertvolle PostgreSQL-Funktion, die das sehr häufige "einfügen-oder-aktualisieren"-Bedürfnis sauber und **sicher** löst, daher ist das Verständnis dafür nützlich für echte Datenvorgänge.

Das Bedürfnis — eine Zeile einfügen, die möglicherweise bereits existiert (durch einen Unique-Schlüssel) — entsteht ständig (Upserting von Datensätzen, Zähler, idempotente Einfügungen, Datensynchronisierung), und die naiven Alternativen sind problematisch: Ein einfaches INSERT schlägt mit einem Fehler fehl, falls die Zeile existiert, und der Check-dann-Einfügen-Ansatz (SELECT dann INSERT-oder-UPDATE) hat eine **Race Condition** (eine andere gleichzeitige Transaktion könnte zwischen deinem Check und deinem Einfügen einfügen, was zu Fehlern oder verlorenen Updates führt). `ON CONFLICT` löst dies **atomar in einer einzelnen Anweisung** — eliminiert die Race Condition, was der Schlüssel zum Korrektheitsvorteil für nebenläufige Anwendungen ist.

Das Verständnis beider Formen — **`DO UPDATE`** (einfügen oder aktualisieren, mit `EXCLUDED`, das auf die versuchten Werte verweist und die Fähigkeit, die existierende Zeile für Logik wie das Erhöhen von Zählern zu referenzieren) und **`DO NOTHING`** (einfügen oder stillschweigend überspringen) — deckt die häufigen Muster ab (Upserting von Datensätzen, idempotente Einfügungen, Verwaltung von Zählern/Aggregaten).

Da Einfügen-oder-Aktualisieren eine häufige Operation ist und es korrekt und sicher zu tun (atomar, ohne Race Conditions) für Datenintegrität in nebenläufigen Anwendungen zählt, ist das Verständnis von UPSERT — was es löst, der Atomarität/Race-Condition-Vorteil und die DO UPDATE/DO NOTHING-Formen — wertvoll, häufig angewendetes PostgreSQL-Wissen, das eine saubere, sichere Lösung für ein häufiges Bedürfnis bietet, das sonst fehleranfällig ist, was es zu einer praktischen, wichtigen Funktion für echte Anwendungen macht.