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

ਜੇ inserting `email` unique constraint ਉੱਪਰ ਸਾਂਝ ਹੋਵੇ, ਤਾਂ Postgres ਮੌਜੂਦਾ row ਨੂੰ ਇਸ ਦੀ ਜਗ੍ਹਾ update ਕਰਦਾ ਹੈ। **`EXCLUDED`** ਉਹ values ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ insert ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, ਅਤੇ ਤੁਸੀਂ ਮੌਜੂਦਾ row (`users.login_count`) ਨੂੰ ਵੀ ਸੰਦਰਭਤ ਕਰ ਸਕਦੇ ਹੋ — logic ਨੂੰ ਸਮਰਥ ਬਣਾ ਕੇ ਜਿਵੇਂ ਕਾਉਂਟਰ ਨੂੰ increment ਕਰਨਾ।

## 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` ਸਾਂਝ rows ਨੂੰ ਚੁੱਪ ਚਾਪ ਛੱਡ ਦਿੰਦਾ ਹੈ — "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 ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ ਜੋ ਬਹੁਤ ਆਮ "insert-or-update" ਲੋੜ ਨੂੰ ਸਾਫ ਅਤੇ **ਸੁਰੱਖਿਤ** ਤਰੀਕੇ ਨਾਲ ਹੱਲ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇਸ ਨੂੰ ਸਮਝਣਾ ਵਾਸਤਵਿਕ ਡੇਟਾ ਓਪਰੇਸ਼ਨਾਂ ਲਈ ਮਫੀਦ ਹੈ।

ਲੋੜ — ਇੱਕ row ਨੂੰ insert ਕਰਨਾ ਜੋ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਹੋ ਸਕਦਾ ਹੈ (ਇੱਕ unique key ਦੁਆਰਾ) — ਲਗਾਤਾਰ ਆਉਂਦੀ ਹੈ (records upserting, counters, idempotent inserts, ਡੇਟਾ syncing), ਅਤੇ ਭਲਕਾਵੇ ਵਿਕਲਪ ਸਮੱਸਿਆਵਾਂ ਹਨ: ਸਧਾਰਨ INSERT ਅਨੁਰੂਪ ਅਗਲੀ ਖੁੱਦ ਅਸਫ ਹੁੰਦੀ ਹੈ ਜੇ row ਮੌਜੂਦ ਹੈ, ਅਤੇ check-then-insert ਪਹੁੰਚ (SELECT ਫਿਰ INSERT-or-UPDATE) ਇੱਕ **race condition** ਹੈ (ਇੱਕ ਹੋਰ concurrent transaction ਤੁਹਾਡੇ check ਅਤੇ ਤੁਹਾਡੇ insert ਵਿਚਕਾਰ insert ਕਰ ਸਕਦਾ ਹੈ, ਗਲਤੀਆਂ ਜਾਂ ਖਲੀ ਅੱਪਡੇਟਸ ਦਾ ਕਾਰਨ ਬਨ ਸਕਦਾ ਹੈ)। `ON CONFLICT` ਇਸ ਨੂੰ **atomically ਇੱਕ ਸਿੰਗਲ statement ਵਿੱਚ** ਹੱਲ ਕਰਦਾ ਹੈ — race condition ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ, ਜੋ concurrent applications ਲਈ ਇਸ ਦਾ ਮੁੱਖ correctness ਲਾਭ ਹੈ।

ਦੋਵਾਂ ਫਾਰਮ ਨੂੰ ਸਮਝਣਾ — **`DO UPDATE`** (insert ਜਾਂ update, `EXCLUDED` ਨਾਲ ਪ੍ਰਯਾਸ ਕੀਤੀ values ਨਾਂ ਦਿਆਂ ਅਤੇ ਮੌਜੂਦਾ row ਨੂੰ ਸੰਦਰਭਤ ਕਰਨ ਦੀ ਸਮਰਥਾ counter ਨੂੰ increment ਕਰਨ ਵਰਗੀ logic ਲਈ) ਅਤੇ **`DO NOTHING`** (insert ਜਾਂ ਚੁੱਪ ਚਾਪ skip) — ਆਮ patterns ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ (records upserting, idempotent inserts, counters/aggregates ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ)।

ਕਿਉਂਕਿ insert-or-update ਇੱਕ ਬਾਰ-ਬਾਰ ਆਉਣ ਵਾਲੀ operation ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਸਹੀ ਅਤੇ ਸੁਰੱਖਿਤ (atomically, race conditions ਤੋਂ ਬਿਨਾਂ) ਕਰਨਾ concurrent applications ਵਿੱਚ ਡੇਟਾ ਇੰਟੀਗਰਿਟੀ ਲਈ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ, UPSERT ਨੂੰ ਸਮਝਣਾ — ਕੀ ਇਹ ਹੱਲ ਕਰਦਾ ਹੈ, atomicity/race-condition ਲਾਭ, ਅਤੇ DO UPDATE/DO NOTHING ਫਾਰਮ — ਅਕਸਰ ਲਾਗੂ ਕੀਤੀ PostgreSQL ਜਾਣਕਾਰੀ ਹੈ ਜੋ ਇੱਕ ਸਾਧਾਰਨ, ਸੁਰੱਖਿਤ ਹੱਲ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ ਇੱਕ ਸਾਧਾਰਨ ਲੋੜ ਤੇ ਜੋ ਨਹੀਂ ਤਾਂ ਗਲਤੀਆਂ-ਸਮਰਥ ਹੈ, ਇਸ ਨੂੰ ਇੱਕ ਅਭਿਜ਼ਾਤਮਕ, ਮਹੱਤਵਪੂਰਣ ਵਿਸ਼ੇਸ਼ਤਾ ਵਾਸਤਵਿਕ applications ਲਈ ਬਣਾ ਰਿਹਾ ਹੈ।