რა არის UPSERT (INSERT ON CONFLICT)?

Question

Accepted Answer

**UPSERT** ნიშნავს "ჩასმა, ან განახლება თუ ის უკვე არსებობს." PostgreSQL ახორციელებს ამას **`INSERT ... ON CONFLICT`**-ით — სტრიქონის ჩასმა, მაგრამ თუ ის ერთეული შეზღუდვას დაარღვევს, ამის ნაცლად სულ ცა განაახლებს (ან არაფერი გააკეთებს). იგი ატომურად ამუშავებს საერთო "ჩასმა-ან-განახლება" მოთხოვნას.

## პრობლემა, რომელსაც 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` ერთეული შეზღუდვაზე, 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`조용히გამოტოვებს კონფლიქტებული სტრიქონებს — სასარგებლო "ჩასმა თუ არ არის" შეცდომების გარეშე.

## გავრცელებული რეალური გამოყენება: მრიცხველები და იდემპოტენტური ჩასმები

```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 ვერ შედგება შეცდომით თუ სტრიქონი არსებობს, და check-then-insert მიდგომა (SELECT შემდეგ INSERT-ან-UPDATE) **რეისების პირობას** ატარებს (სხვა კონკურენტული ტრანზაქცია შეიძლება ჩაწეროს თქვენი შემოწმებისა და ჩასმის შორის, რაც შეცდომებს ან დაკარგულ განახლებებს იწვევს). `ON CONFLICT` ეს **ატომურად ერთ დებულებაში** გადაჭრის — რეისების პირობის აღმოფხვრა, რაც მისი ძირითადი სიმართის უპირატესობა კონკურენტული აპლიკაციებისთვის.

ორივე ფორმის გაგება — **`DO UPDATE`** (ჩასმა ან განახლება, `EXCLUDED`-ით ჩასმის მცდელობის მნიშვნელობების ჩვენება და არსებული სტრიქონის ჩვენება ლოგიკისთვის, როგორიცაა მრიცხველის გაზრდა) და **`DO NOTHING`** (ჩასმა ან თუმ გამოტოვება) — კვლავ გავრცელებული შაბლონებს (ჩაწერების განახლება, იდემპოტენტური ჩასმები, მრიცხველების/აგრეგატების შენარჩუნება).

ვინაიდან ჩასმა-ან-განახლება სიხშირე ოპერაცია არის და მისი სწორად და უსაფრთხოდ შესრულება (ატომურად, რეისების პირობის გარეშე) მნიშვნელოვანია მონაცემთა სიმართის კონკურენტული აპლიკაციებში, UPSERT-ის გაგება — რა ის გადაჭრის, ატომურობის/რეისების პირობის უპირატესობა და DO UPDATE/DO NOTHING ფორმები — ღირებული, ხშირად გამოყენებული PostgreSQL ცოდნა, რომელიც აკეთებს სუფთა, უსაფრთხო გამოსავალი გავრცელებული მოთხოვნისთვის, რომელიც სხვაგვარად შეცდომებისთვის ხელმისაწვდომია, რაც მას პრაქტიკულ, მნიშვნელოვან ფიჩাში აქცევს რეალური აპლიკაციებისთვის.