UPSERT (INSERT ON CONFLICT) म्हणजे काय?

Question

Accepted Answer

**UPSERT** म्हणजे "insert करा, किंवा जर ते आधीच अस्तित्वात असेल तर update करा." PostgreSQL हे **`INSERT ... ON CONFLICT`** सह लागू करते — एक row insert करा, परंतु जर ते unique constraint चे उल्लंघन करेल, तर त्याऐवजी विद्यमान row update करा (किंवा काहीही करू नका). हे सामान्य "insert-or-update" गरज atomically हाताळते.

## ON CONFLICT हे समस्या सोडवते

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

जर `email` unique constraint वर inserting conflict करेल, तर Postgres विद्यमान row update करते. **`EXCLUDED`** हे मूल्ये संदर्भित करते ज्या insert करण्याचा प्रयत्न केला होता, आणि आप विद्यमान row (`users.login_count`) देखील संदर्भित करू शकता — counter वाढवण्यासारख्या 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 करते — "अस्तित्वात असल्यास 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" गरज स्वच्छपणे आणि **सुरक्षितपणे** सोडवते, त्यामुळे वास्तविक जग डेटा operations साठी हे समजून घेणे उपयोगी आहे.

गरज — एक row insert करणे जो आधीच एक unique key द्वारे अस्तित्वात असू शकतो — सतत उद्भवते (records upsert करणे, counters, idempotent inserts, डेटा sync करणे), आणि naive alternatives समस्याग्रस्त आहेत: साधारण INSERT row अस्तित्वात असल्यास त्रुटीसह अयशस्वी होते, आणि check-then-insert approach (SELECT नंतर INSERT-or-UPDATE) एक **race condition** आहे (दुसरा concurrent transaction आपल्या check आणि आपल्या insert दरम्यान insert करू शकतो, त्रुटी किंवा lost updates कारणीभूत करून). `ON CONFLICT` हे **atomically एक single statement मध्ये** सोडवते — race condition दूर करून, जो concurrent applications साठी त्याचा मुख्य correctness benefit आहे.

दोन्ही forms समजून घेणे — **`DO UPDATE`** (insert किंवा update, `EXCLUDED` साथे attempted values संदर्भित करणे आणि existing row साठी reference करण्याची क्षमता counters incrementing असे logic साठी) आणि **`DO NOTHING`** (insert किंवा silently skip) — सामान्य patterns कव्हर करते (records upsert करणे, idempotent inserts, counters/aggregates राखणे).

Insert-or-update एक वारंवार operation असल्यामुळे आणि हे सुरक्षितपणे (atomically, race conditions शिवाय) करणे concurrent applications मध्ये डेटा integrity साठी महत्वाचे आहे, UPSERT समजून घेणे — ते काय सोडवते, atomicity/race-condition benefit, आणि DO UPDATE/DO NOTHING forms — मूल्यवान, वारंवार-लागू PostgreSQL knowledge आहे जे एक सामान्य गरजेला स्वच्छ, सुरक्षित solution प्रदान करते जे अन्यथा error-prone आहे, हे वास्तविक applications साठी एक व्यावहारिक, महत्वाचे feature बनवते.

ON CONFLICT हे समस्या सोडवते

ON CONFLICT DO UPDATE — insert किंवा update करा

ON CONFLICT DO NOTHING — insert किंवा skip करा

एक सामान्य वास्तविक वापर: counters आणि idempotent inserts

हे महत्वाचे का आहे

question.related