¿Cómo funcionan los IDs auto-incrementables (SERIAL, sequences, IDENTITY)?

Question

Accepted Answer

PostgreSQL genera IDs auto-incrementables (típicamente para claves primarias) usando **sequences** — objetos especiales que producen números únicos y crecientes. **`SERIAL`** es una abreviatura que crea una sequence automáticamente, e **`IDENTITY`** es el equivalente moderno estándar de SQL.

## SERIAL — la abreviatura clásica

```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` crea automáticamente una sequence y establece el default de la columna para extraer el siguiente valor de ella. `BIGSERIAL` usa `BIGINT` para rangos más grandes (importante para tablas que pueden exceder ~2 mil millones de filas).

## IDENTITY — la forma moderna y recomendada (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` es el enfoque moderno estándar de SQL (preferido sobre `SERIAL` en código nuevo) — es más limpio y evita algunos quirks de `SERIAL` (como casos edge de propiedad/permisos).

## Cómo funcionan las sequences bajo el capó

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

Una sequence es un contador independiente. `SERIAL`/`IDENTITY` usan una detrás de escenas. Nota: las sequences **no** se revierten por transacciones (por lo que los IDs pueden tener gaps después de rollbacks — normal y esperado).

## Obtener el nuevo ID

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

## Por qué es importante

Los IDs auto-incrementables son fundamentales — casi todas las tablas necesitan una clave primaria única, y los IDs secuenciales auto-generados son el enfoque estándar, por lo que entender cómo PostgreSQL los maneja es conocimiento esencial cotidiano.

Conocer **`SERIAL`** (la abreviatura clásica y común que crea una sequence automáticamente) y especialmente **`IDENTITY`** (`GENERATED ... AS IDENTITY` — el enfoque moderno, estándar de SQL, recomendado para código nuevo, que es más limpio y evita los quirks de SERIAL) es importante para definir claves primarias correctamente.

Entender las **sequences** subyacentes (contadores independientes que producen valores únicos y crecientes) desmitifica cómo funciona el auto-increment y es útil para control avanzado (`nextval`, `setval`).

Dos puntos prácticos importan: elegir **`BIGSERIAL`/BIGINT`** para tablas que puedan crecer mucho (evitando desbordamiento de enteros — una preocupación real), y saber que **las sequences no se revierten** por transacciones (por lo que los IDs pueden tener gaps después de rollbacks o inserts fallidos — comportamiento normal y esperado que sorprende a algunos).

La cláusula **`RETURNING`** para obtener el ID generado de vuelta de un INSERT también es conocimiento valioso y cotidiano.

Como cada tabla necesita claves primarias e IDs auto-incrementables son el estándar, y como entender SERIAL versus la recomendada IDENTITY, las sequences subyacentes, el dimensionamiento (BIGSERIAL), comportamiento de gaps, y RETURNING cubre las necesidades prácticas, saber cómo PostgreSQL genera IDs auto-incrementables es conocimiento fundamental y frecuentemente aplicado para trabajar con tablas Postgres y un punto común donde saber la práctica mejor moderna (IDENTITY) refleja competencia actual en Postgres.