UPSERT (INSERT ON CONFLICT) అంటే ఏమిటి?

Question

Accepted Answer

**UPSERT** అంటే "insert చేయండి, లేదా అది ఇప్పటికే ఉనికిలో ఉంటే update చేయండి." PostgreSQL ఇందుకు **`INSERT ... ON CONFLICT`** తో ఆచరణ చేస్తుంది — ఒక row insert చేయండి, కానీ అది unique constraint ను ఉల్లంఘిస్తే, బదులుగా existing row ని update చేయండి (లేదా ఏమీ చేయవద్దు). ఇది సాధారణ "insert-or-update" అవసరాన్ని అణువుగా నిర్వహిస్తుంది.

## 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 — insert లేదా update

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

ఒకవేళ inserting `email` unique constraint పై conflict చేస్తే, Postgres existing row ని update చేస్తుంది. **`EXCLUDED`** మీరు insert చేయడానికి ప్రయత్నించిన విలువలను సూచిస్తుంది, మరియు మీరు existing row (`users.login_count`) ను కూడా reference చేయవచ్చు — counter increment చేసే తరహా logic ను సక్షమం చేస్తుంది.

## ON CONFLICT DO NOTHING — insert లేదా skip

```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` conflict చేసే rows ను నిశ్చల్యముగా skip చేస్తుంది — "present చేయకపోతే insert" కోసం ఉపయోగకరంగా ఉంటుంది.

## సాధారణ నిజ ఉపయోగ: counters మరియు idempotent inserts

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

## ఇది ఎందుకు ముఖ్యమైనది

UPSERT (`INSERT ... ON CONFLICT`) ఒక ముఖ్యమైన, ఆచరణాత్మకంగా-విలువైన PostgreSQL feature ఇది చాలా సాధారణమైన "insert-or-update" అవసరాన్ని శుద్ధిగా మరియు **సురక్షితంగా** పరిష్కరిస్తుంది, కాబట్టి దీనిని అర్థం చేసుకోవడం నిజ-ప్రపంచ డేటా కార్యకలాపాలకు ఉపయోగకరంగా ఉంటుంది.

అవసరం — ఒక row insert చేయడం ఇది ఇప్పటికే ఉనికిలో ఉండవచ్చు (unique key ద్వారా) — నిరంతరం తలెత్తుతుంది (upserting records, counters, idempotent inserts, syncing data), మరియు నిష్కపట కవితలు సమస్యాత్మకమైనవి: సాధారణ INSERT row ఉనికిలో ఉంటే error తో విఫలమవుతుంది, మరియు check-then-insert approach (SELECT ఆపై INSERT-or-UPDATE) ఒక **race condition** కలిగి ఉంది (మరొక సమకాలీన transaction మీ check మరియు మీ insert మధ్య insert చేయవచ్చు, errors లేదా lost updates కు కారణమవుతుంది). `ON CONFLICT` ఇందుకు **ఒక statement లో అణువుగా** పరిష్కరిస్తుంది — race condition ను తొలగిస్తుంది, ఇది సమకాలీన applications కోసం దాని కీ correctness benefit.

రెండు రూపాలను అర్థం చేసుకోవడం — **`DO UPDATE`** (insert లేదా update, `EXCLUDED` attempted విలువలను reference చేస్తూ మరియు counters increment చేసే తరహా logic కోసం existing row ని reference చేయగల సామర్థ్యం) మరియు **`DO NOTHING`** (insert లేదా silently skip) — సాధారణ patterns (upserting records, idempotent inserts, maintaining counters/aggregates) ని కవర్ చేస్తుంది.

insert-or-update ఒక frequent operation ఐనప్పటికీ దీనిని సరిగ్గా మరియు సురక్షితంగా (అణువుగా, race conditions లేకుండా) చేయడం సమకాలీన applications లో డేటా integrity కోసం ముఖ్యమైనది, UPSERT ని అర్థం చేసుకోవడం — ఇది ఏమి పరిష్కరిస్తుంది, atomicity/race-condition benefit, మరియు DO UPDATE/DO NOTHING రూపాలు — విలువైన, frequently-applied PostgreSQL జ్ఞానం ఇది సాధారణ అవసరానికి ఒక శుద్ధ, సురక్షిత solution ను అందిస్తుంది ఇది లేకుంటే error-prone, ఇది నిజ applications కోసం ఆచరణాత్మక, ముఖ్యమైన feature ను చేస్తుంది.