Cum funcționează ID-urile cu auto-incrementare (SERIAL, sequences, IDENTITY)?

Question

Accepted Answer

PostgreSQL generează ID-uri cu auto-incrementare (de obicei pentru chei primare) folosind **sequences** — obiecte speciale care produc numere unice în creștere. **`SERIAL`** este o prescurtare care creează o secvență automat, iar **`IDENTITY`** este echivalentul modern conform standardului SQL.

## SERIAL — prescurtarea clasică

```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` creează automat o secvență și setează valoarea implicită a coloanei să extragă următoarea valoare din aceasta. `BIGSERIAL` folosește `BIGINT` pentru intervale mai mari (important pentru tabelele care pot depăși ~2 miliarde de rânduri).

## IDENTITY — modul modern, recomandat (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` este abordarea modernă, conform standardului SQL (preferată în locul `SERIAL` în codul nou) — este mai curată și evită anumite neajunsuri ale `SERIAL` (cum ar fi cazurile limită legate de proprietate/permisiuni).

## Cum funcționează secvențele în spate

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

O secvență este un contor independent. `SERIAL`/`IDENTITY` folosesc una în spate. Notă: secvențele **nu sunt** anuate de tranzacții (deci ID-urile pot avea goluri după anulări — normal și de așteptat).

## Obținerea ID-ului nou

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

## De ce contează

ID-urile cu auto-incrementare sunt fundamentale — aproape fiecare tabel are nevoie de o cheie primară unică, iar ID-urile secvențiale generate automat sunt abordarea standard, deci înțelegerea modului în care PostgreSQL le gestionează este cunoștințe esențiale pentru zi cu zi.

Cunoașterea **`SERIAL`** (prescurtarea clasică, comună, care creează o secvență automat) și mai ales **`IDENTITY`** (`GENERATED ... AS IDENTITY` — abordarea modernă, conform standardului SQL, recomandată pentru codul nou, care este mai curată și evită neajunsurile SERIAL) este importantă pentru definirea corectă a cheilor primare.

Înțelegerea **secvențelor** subiacente (contoare independente care produc valori unice în creștere) clarifiază cum funcționează auto-incrementarea și este utilă pentru control avansat (`nextval`, `setval`).

Două puncte practice sunt importante: alegerea **`BIGSERIAL`/BIGINT`** pentru tabelele care pot crește mult (evitând depășirea întregilor — o preocupare reală) și cunoașterea faptului că **secvențele nu sunt anuate** de tranzacții (deci ID-urile pot avea goluri după anulări sau inserări eșuate — comportament normal, de așteptat, care surprinde unii).

Clauza **`RETURNING`** pentru obținerea ID-ului generat înapoi din INSERT este, de asemenea, cunoștințe valoroase și de zi cu zi.

Deoarece fiecare tabel are nevoie de chei primare și ID-urile cu auto-incrementare sunt standardul, iar deoarece înțelegerea SERIAL versus IDENTITY recomandat, secvențele subiacente, dimensionarea (BIGSERIAL), comportamentul golurilor și RETURNING acoperă nevoile practice, cunoașterea modului în care PostgreSQL generează ID-uri cu auto-incrementare este cunoștință fundamentală, frecvent aplicată, pentru lucrul cu tabele Postgres și un punct comun în care cunoașterea practicii moderne (IDENTITY) reflectă competența actuală în Postgres.