UPSERT (INSERT ON CONFLICT) என்றால் என்ன?

Question

Accepted Answer

**UPSERT** என்றால் "செருக, அல்லது ஏற்கனவே இருந்தால் புதுப்பிக்க." PostgreSQL இதை **`INSERT ... ON CONFLICT`** மூலம் செயல்படுத்துகிறது — ஒரு வரிசையை செருக, ஆனால் அது ஒரு unique கட்டுப்பாட்டை மீறினால், மாறாக বதிலான வரிசையை புதுப்பிக்க (அல்லது எதுவும் செய்யாமல் விட்டுவிட). இது "செருக-அல்லது-புதுப்பிக்க" என்ற பொதுவான தேவையை 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 — செருக அல்லது புதுப்பிக்க

```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 கட்டுப்பாட்டில் மோதினால், Postgres பதிலாக பதிந்துள்ள வரிசையை புதுப்பிக்கிறது. **`EXCLUDED`** என்பது நீங்கள் செருக முயற்சித்த மதிப்புகளைக் குறிக்கிறது, மேலும் நீங்கள் பதிந்துள்ள வரிசையையும் (`users.login_count`) குறிப்பிடலாம் — எண்ணிக்கையை அதிகரிப்பது போன்ற தர্க்கம் இயக்க உதவும்.

## ON CONFLICT DO NOTHING — செருக அல்லது தவிர்க்க

```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` மோதக்கூடிய வரிசைகளை அ조 ஒதுக்கிவிடுகிறது —오류ஸ் இல்லாமல் "இல்லாவிட்டால் செருக" க்கு பயனுள்ளதாக இருக்கிறது.

## ஒரு பொதுவான நிஜ பயன்பாடு: எண்ணிக்கைகள் மற்றும் idempotent செருகுதல்

```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 அம்சம் ஆகும், இது மிகவும் பொதுவான "செருக-அல்லது-புதுப்பிக்க" தேவையை சுத்தமாக மற்றும் **பாதுகாப்புடன்** தீர்க்கிறது, எனவே இதைப் புரிந்துகொள்வது நிஜ-உலக தரவு செயல்பாடுகளுக்கு பயனுள்ளதாக இருக்கிறது.

தேவை — ஒரு வரிசையை செருக வேண்டும் (ஒரு unique விசை மூலம்) இது ஏற்கனவே இருக்கலாம் — மிக அடிக்கடி எழுகிறது (upsert பதிவுகள், எண்ணிக்கைகள், idempotent செருகுதல், தரவு ஒத்திசைவாக்குதல்), மற்றும் பழிய மாற்றுகள் பிரச்சனையுற்றவை: ஒரு சாதாரண INSERT சரியான வரிசை இருந்தால் விபத்துடன் தோல்வியடைகிறது, மற்றும் சரிபார்-பின்-செருக அணுகுமுறை (SELECT பின்னர் INSERT-அல்லது-UPDATE) ஒரு **race நிலை** வைத்திருக்கிறது (மற்றொரு ஒமTime-consuming பரிவர்த்தனை உங்கள் சரிபார் மற்றும் உங்கள் செருகுதல் இடையில் செருக முடியும், விபத்தை அல்லது இழந்த புதுப்பிப்புகளை ஏற்படுத்தி). `ON CONFLICT` இதை **ஒற்றை statement ல் atomically** தீர்க்கிறது — race நிலையை நீக்குகிறது, இது concurrent பயன்பாடுகளுக்கு அதன் முக்கிய சரியான நன்மை.

இரண்டு வடிவங்களையும் புரிந்துகொள்வது — **`DO UPDATE`** (செருக அல்லது புதுப்பிக்க, `EXCLUDED` முயற்சித்த மதிப்புகளைக் குறிக்கும் மற்றும் எண்ணிக்கையை அதிகரிப்பது போன்ற தர্க்கத்திற்கு பதிந்துள்ள வரிசையைக் குறிப்பிடும் திறன்) மற்றும் **`DO NOTHING`** (தவிர அல்லது அ خاموش ஒதுக்கிவிடு) — பொதுவான வடிவங்களை (upsert பதிவுகள், idempotent செருகுதல், பராமரிப்பு எண்ணிக்கைகள்/உருக்குலுக்க) மூடுகிறது.

செருக-அல்லது-புதுப்பிக்க ஒரு அடிக்கடி செயல்பாடு மற்றும் சரியாக மற்றும் பாதுகாப்புடன் (atomically, race நிலைகள் இல்லாமல்) அதைச் செய்வது concurrent பயன்பாடுகளில் தரவு integrity க்கு முக்கியம், UPSERT ஐ புரிந்துகொள்வது — அது என்ன தீர்க்கிறது, atomicity/race-நிலை நன்மை, மற்றும் DO UPDATE/DO NOTHING வடிவங்கள் — மதிப்பிய, அடிக்கடி-பயன்படுத்திய PostgreSQL அறிவு இது ஒரு பொதுவான தேவைக்கு ஒரு சுத்தமான, பாதுகாப்பான தீர்வை வழங்குகிறது இது இல்லாவிட்டால் பிழை-நோய்க்குளாக இருக்கிறது, இது நிஜ பயன்பாடுகளுக்கு ஒரு நடைமுறை, முக்கியமான அம்சத்தை உருவாக்குகிறது.