UPSERT (INSERT ON CONFLICT) શું છે?

Question

Accepted Answer

**UPSERT** એટલે "insert કરો, અથવા જો તે પહેલેથી અસ્તિત્વમાં હોય તો update કરો." PostgreSQL આને **`INSERT ... ON CONFLICT`** વડે અમલમાં મૂકે છે — એક row insert કરો, પરંતુ જો તે unique constraint નું ઉલ્લંઘન કરે છે તો તેના બદલે હાલની row ને update કરો (અથવા કશું કરશો નહીં). તે સામાન્ય "insert-or-update" જરૂરિયાત ને atomically હેન્ડલ કરે છે.

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

જો insert કરવાથી `email` unique constraint પર તકરાર થાય તો, Postgres તેના બદલે હાલની row ને update કરે છે. **`EXCLUDED`** તમે insert કરવાનો પ્રયાસ કર્યો તે મૂલ્યોનો સંદર્ભ આપે છે, અને તમે હાલની row (`users.login_count`) ને પણ સંદર્ભિત કરી શકો છો — આનાથી counter increment કરવા જેવી logic શક્ય બને છે.

## ON CONFLICT DO NOTHING — insert અથવા છોડી દો

```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` તકરાર અને rows ને ચૂપચાપ છોડી દે છે — "જો હાજર ન હોય તો insert કરો" માટે ઉપયોગી, કોઈ error વિના.

## એક સામાન્ય વાસ્તવિક ઉપયોગ: 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" જરૂરિયાત ને સ્વચ્છતાથી અને **સુરક્ષિતરીતે** સુલજાવે છે, તેથી તેને સમજવું વાસ્તવિક ડેટા operations માટે ઉપયોગી છે.

જરૂરિયાત — એક row insert કરવી જે સંભવતઃ પહેલેથી અસ્તિત્વમાં હોય (unique key દ્વારા) — ક્રમાગત ઊભી થાય છે (upsert કરવું records, counters, idempotent inserts, data sync કરવું), અને સાદા વિકલ્પો સમસ્યારૂપ છે: સાદું INSERT જો row અસ્તિત્વમાં હોય તો error થાય છે, અને check-then-insert approach (SELECT પછી INSERT-or-UPDATE) માં **race condition** છે (બીજું concurrent transaction તમારી check અને તમારા insert વચ્ચે insert કરી શકે છે, errors અથવા lost updates કારણ બનાવે છે). `ON CONFLICT` આને **એક જ statement માં atomically** સુલજાવે છે — race condition ને નાબૂદ કરે છે, જે concurrent applications માટે તેનો મુખ્ય correctness લાભ છે.

બંને forms ને સમજવું — **`DO UPDATE`** (insert અથવા update, `EXCLUDED` વડે attempted values ને reference કરવા અને existing row (`users.login_count`) ને counters increment કરવા જેવી logic માટે reference કરવાની ક્ષમતા) અને **`DO NOTHING`** (insert અથવા ચૂપચાપ છોડી દો) — સામાન્ય patterns (upsert કરવું records, idempotent inserts, counters/aggregates જાળવી રાખવું) ને આવરી લે છે.

કારણ કે insert-or-update એક વારંવાર operation છે અને તેને સુધારે અને સુરક્ષિતરીતે (atomically, race conditions વિના) કરવું concurrent applications માં ડેટા integrity માટે મહત્વનું છે, UPSERT ને સમજવું — તે શું સુલજાવે છે, atomicity/race-condition લાભ, અને DO UPDATE/DO NOTHING forms — મૂલ્યવાન, વારંવાર-લાગુ પડતું PostgreSQL જ્ઞાન છે જે સામાન્ય જરૂરિયાત માટે સ્વચ્છ, સુરક્ષિત સમાધાન પૂરું પાડે છે જે અન્યથા error-prone હોય, આને વાસ્તવિક applications માટે વ્યવહારિક, મહત્વનું feature બનાવે છે.