auto-incrementing IDs ఎలా పని చేస్తాయి (SERIAL, sequences, IDENTITY)?

Question

Accepted Answer

PostgreSQL సాధారణంగా ప్రాథమిక కీల కోసం auto-incrementing IDs ను **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 లావాదిద్దులు ద్వారా రోల్‌బ్యాక్ చేయబడవు (కాబట్టి IDs రోల్‌బ్యాక్‌ల తర్వాత ఖాళీలను కలిగి ఉండవచ్చు — సాధారణ మరియు అంచనా).

## కొత్త ID పొందడం

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

## ఇది ఎందుకు ముఖ్యమైనది

Auto-incrementing IDs ప్రాథమికం — దాదాపు ప్రతి పట్టికకు ఒక ఏకైక ప్రాథమిక కీ అవసరం, మరియు స్వయంచాలక ક్రమానికి IDs ప్రామాణిక విధానం, కాబట్టి PostgreSQL వాటిని ఎలా నిర్వహిస్తుందో అర్థం చేసుకోవడం ముఖ్యమైన రోజువారీ జ్ఞానం.

**`SERIAL`** (చిన్న, సాధారణ సంక్షిప్తపదం ఇది స్వయంచాలకంగా ఒక sequence సృష్టిస్తుంది) మరియు ప్రత్యేకంగా **`IDENTITY`** (`GENERATED ... AS IDENTITY` — ఆధునిక, SQL-ప్రమాణ, కొత్త కోడ్‌కు సిఫారసు చేయబడిన విధానం, ఇది స్వచ్ఛమైనది మరియు SERIAL యొక్క విచిత్రతలను తీసివేస్తుంది) తెలుసుకోవడం ప్రాథమిక కీలను సరిగ్గా నిర్వచించడానికి ముఖ్యమైనది.

ఆధారిత **sequences** (స్వతంత్ర కౌంటర్‌లు ఇవి ఏకైక పెరుగుతున్న విలువలను ఉత్పత్తి చేస్తాయి) అర్థం చేసుకోవడం auto-increment ఎలా పని చేస్తుందో స్పష్టం చేస్తుంది మరియు అధునాతన నియంత్రణ (`nextval`, `setval`) కోసం ఉపయోగకరమైనది.

ორი ఆచరణాత్మక పాయింట్‌లు ముఖ్యమైనవి: పెద్ద పట్టికలకు కాలిపండ్‌లో పెరిగే ఐఎస్ పట్టికలకు **`BIGSERIAL`/BIGINT`** ఎంచుకోవడం (పూర్ణాంక ఓవర్‌ఫ్లో తీసివేయడం — నిజమైన ఆందోళన), మరియు **sequences లావాదిద్దులు ద్వారా రోల్‌బ్యాక్ చేయబడవు** (కాబట్టి IDs రోల్‌బ్యాక్‌లు లేదా విఫల insertల తర్వాత ఖాళీలను కలిగి ఉండవచ్చు — సాధారణ, అంచనా ప్రవర్తన ఇది కొందరిని ఆశ్చర్యపరుస్తుంది).

generated ID తిరిగి INSERT నుండి పొందడానికి **`RETURNING`** నిబంధన కూడా విలువైనది, రోజువారీ జ్ఞానం.

ప్రతి పట్టికకు ప్రాథమిక కీలు అవసరం కాబట్టి మరియు auto-incrementing IDs ప్రామాణిక విధానం, మరియు SERIAL వర్సుస్ సిఫారసు చేయబడిన IDENTITY, ఆధారిత sequences, సైజింగ్ (BIGSERIAL), గ్యాప్ ప్రవర్తన, మరియు RETURNING అర్థం చేసుకోవడం ఆచరణాత్మక అవసరాలను కవర్ చేస్తుంది, PostgreSQL ఎలా auto-incrementing IDs ఉత్పత్తి చేస్తుందో తెలుసుకోవడం ప్రాథమికం, Postgres పట్టికలు మరియు ఆధునిక సరైన ఆచరణ (IDENTITY) ప్రతిబింబిస్తున్న సమకాలీన Postgres సామర్థ్యం తెలిసిన సాధారణ బిందువుతో ఎక్కువ సంఘటన జ్ఞానం.