Was ist UPSERT (INSERT ON CONFLICT)?

Question

IT Interview Practice · 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.

Warum es wichtig ist

ON CONFLICT DO UPDATE — einfügen oder aktualisieren

ON CONFLICT DO NOTHING — einfügen oder überspringen

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

Warum es wichtig ist

Ähnliche Fragen