როგორ მუშაობს ავტომატურად გაზრდილი ID-ები (SERIAL, sequences, IDENTITY)?

Question

Accepted Answer

PostgreSQL აგენერირებს ავტომატურად გაზრდილ ID-ებს (ჩვეულებრივად პირველადი გასაღებებისთვის) **sequences** ის გამოყენებით — განსაკუთრებული ობიექტები, რომლებიც აწარმოებენ უნიკალური აღმავალი რიცხვებს. **`SERIAL`** არის მოკლე წერტილი, რომელიც ავტომატურად ქმნის sequence-ს, და **`IDENTITY`** არის თანამედროვე SQL-სტანდარტის ექვივალენტი.

## SERIAL — კლასიკური მოკლე წერტილი

```sql
CREATE TABLE users (
  id SERIAL PRIMARY KEY,      -- auto-incrementing integer (SERIAL = INT + a sequence)
  name TEXT
);
-- BIGSERIAL for larger ranges (BIGINT-backed) — use for tables expecting many rows

INSERT INTO users (name) VALUES ('Ann');   -- id auto-assigned (1, 2, 3, ...)
```

`SERIAL` ავტომატურად ქმნის sequence-ს და ადგენს სვეტის ნაგულისხმევ მნიშვნელობას, რომ წამოიღოს შემდეგი მნიშვნელობა მისგან. `BIGSERIAL` იყენებს `BIGINT`-ს უფრო დიდი დიაპაზონებისთვის (მნიშვნელოვანია ცხრილებისთვის, რომლებმაც შეიძლება აღემატოს ~2 მილიარდ სტრიქონს).

## IDENTITY — თანამედროვე, რეკომენდებული მეთოდი (Postgres 10+)

```sql
CREATE TABLE users (
  id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,   -- SQL-standard, recommended
  name TEXT
);
-- GENERATED ALWAYS → you can't manually insert a value (cleaner)
-- GENERATED BY DEFAULT → allows manual override when needed
```

`GENERATED ... AS IDENTITY` არის თანამედროვე, SQL-სტანდარტის მიდგომა (რეკომენდებული `SERIAL`-ის ნაცვლად ახალ კოდში) — ის უფრო სუფთაა და თავს არიდებს ზოგიერთ `SERIAL` უცნობ ქცევას (მაგ. ლიკვიდაცია/ნებართვის კიდეების შემთხვევები).

## როგორ მუშაობს sequences წინ მხარეში

```sql
CREATE SEQUENCE my_seq START 1 INCREMENT 1;
SELECT nextval('my_seq');     -- get the next value (advances the sequence)
SELECT currval('my_seq');     -- the last value YOU got
SELECT setval('my_seq', 100); -- set the current value
```

sequence არის დამოუკიდებელი ჯამტოტი. `SERIAL`/`IDENTITY` იყენებს ერთ მათ უკან. შენიშვნა: sequences არ არის **თავდაბრუნებული** ტრანზაქციებით (ამიტომ ID-ები შეიძლება ჩამოიშორდეს უკუტურნებების შემდეგ — ნორმალური და მოსალოდნელი).

## ახალი ID-ის მიღება

```sql
-- RETURNING — get the generated id back from an INSERT (very useful)
INSERT INTO users (name) VALUES ('Ann') RETURNING id;
```

## რატომ აქვს მნიშვნელობა

ავტომატურად გაზრდილი ID-ები ფუნდამენტური არიან — თითქმის ყველა ცხრილი საჭიროებს უნიკალური პირველადი გასაღებს, და ავტომატურად გენერირებული თანმიმდევრული ID-ები არის სტანდარტული მიდგომა, ამიტომ იმის გაგება, თუ როგორ მოიჭრება მათ PostgreSQL, აუცილებელი ყოველდღიური ცოდნაა.

**`SERIAL`** ის ცოდნა (კლასიკური, ხშირი მოკლე წერტილი, რომელიც ავტომატურად ქმნის sequence-ს) და განსაკუთრებით **`IDENTITY`** (`GENERATED ... AS IDENTITY` — თანამედროვე, SQL-სტანდარტი, ახალი კოდში რეკომენდებული მიდგომა, რომელიც უფრო სუფთაა და თავს არიდებს SERIAL-ის უცნობ ქცევას) მნიშვნელოვანია პირველადი გასაღებების სწორად განსაზღვრისთვის.

უკვე მყოფი **sequences** ის გაგება (დამოუკიდებელი ჯამტოტები, რომლებიც აწარმოებენ უნიკალური აღმავალი მნიშვნელობებს) აღმოფხვრის იდუმალებას, თუ როგორ მუშაობს auto-increment და სასარგებლოა გამন্ত კონტროლისთვის (`nextval`, `setval`).

ორი პრაქტიკული პუნქტი მნიშვნელოვანია: აირჩიოთ **`BIGSERIAL`/BIGINT`** ცხრილებისთვის, რომლებიც შეიძლება დიდი იყოს (integer overflow-ის თავიდან აცილება — ნამდვილი შეშფოთება), და იცოდეთ, რომ **sequences არ არის თავდაბრუნებული** ტრანზაქციებით (ამიტომ ID-ები შეიძლება ჩამოიშორდეს უკუტურნებების ან წარუმატებელი inserts-ის შემდეგ — ნორმალური, მოსალოდნელი ქცევა, რომელიც გარკვევლებს გაკვირვებთ).

INSERT-ის **`RETURNING`** პუნქტი გენერირებული ID-ის უკან მისაღებად ასევე ღირებულია, ყოველდღიური ცოდნა.

ვინაიდან ყველა ცხრილი საჭიროებს პირველადი გასაღებებს და ავტომატურად გაზრდილი ID-ები არის სტანდარტული, და იმის გაგება SERIAL vs რეკომენდებული IDENTITY, უკვე მყოფი sequences, ზომიერება (BIGSERIAL), gap ქცევა და RETURNING ეფუძნება პრაქტიკულ საჭიროებებს, იმის ცოდნა, თუ როგორ აგენერირებს PostgreSQL ავტომატურად გაზრდილ ID-ებს, ფუნდამენტური, ხშირად გამოყენებული ცოდნაა Postgres ცხრილებთან მუშაობისთვის და საერთო წერტილი, სადაც იმის ცოდნა, რომ თანამედროვე საუკეთესო პრაქტიკა (IDENTITY) ასახავს ამჟამინდელი Postgres კომპეტენციას.