¿Qué son las columnas generadas?

Question

Accepted Answer

Una **columna generada** es una columna cuyo valor se **calcula automáticamente** a partir de otras columnas, en lugar de ser insertado directamente. PostgreSQL soporta columnas generadas **almacenadas** (Postgres 12+) — el valor computado se calcula al escribir y se almacena. Mantienen los datos derivados consistentes automáticamente.

## Por qué es importante

```sql
CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  price NUMERIC,
  quantity INT,
  -- a STORED generated column — computed from price and quantity
  total NUMERIC GENERATED ALWAYS AS (price * quantity) STORED
);

INSERT INTO products (price, quantity) VALUES (10, 3);
SELECT total FROM products;          -- 30 — computed automatically (you didn't insert it)
```

La cláusula `GENERATED ALWAYS AS (expression) STORED` hace que `total` siempre sea igual a `price * quantity` — se calcula al insertar/actualizar y se almacena. No puedes (ni debes) insertar en ella directamente; siempre es derivada.

## Usos comunes

```sql
-- a full name from parts
full_name TEXT GENERATED ALWAYS AS (first_name || ' ' || last_name) STORED

-- a normalized/lowercased value for searching
email_lower TEXT GENERATED ALWAYS AS (lower(email)) STORED

-- area from dimensions
area NUMERIC GENERATED ALWAYS AS (width * height) STORED

-- extract a value from JSONB into a real column (then index it)
user_id INT GENERATED ALWAYS AS ((data->>'user_id')::int) STORED
```

Las columnas generadas son excelentes para valores derivados que consultas frecuentemente — se mantienen consistentes automáticamente y pueden ser **indexadas** (ya que son almacenadas).

## Columnas generadas vs calcular en consultas vs triggers

```text
Generated column → derived value computed automatically, stored, indexable, consistent
Computing in a query (price*qty in SELECT) → no storage, but recomputed every query,
                                              can't be indexed directly
Trigger → more flexible but more complex; generated columns are simpler for pure derivations
→ Use generated columns for simple, deterministic derived values you query/index often.
```

## Por qué es importante

Las columnas generadas son una característica útil de PostgreSQL para **mantener automáticamente datos derivados**, y comprenderlas es valioso para mantener valores computados consistentes y consultables.

El beneficio principal es que el valor de una columna generada siempre se calcula automáticamente a partir de otras columnas y se mantiene sincronizado — así que los datos derivados (totales, nombres completos, valores normalizados, campos JSONB extraídos) se mantienen **consistentes por construcción** sin que el código de aplicación o actualizaciones manuales tengan que recordar recomputarlos (eliminando una clase de errores donde los datos derivados se dessincronizan).

Dado que las columnas generadas almacenadas físicamente guardan el valor, también pueden ser **indexadas** — lo cual es particularmente valioso para cosas como un email en minúsculas para búsqueda insensible a mayúsculas, o extraer un campo JSONB en una columna real e indexable (un patrón poderoso que combina la flexibilidad de JSONB con indexación relacional).

Comprender cuándo usar columnas generadas versus alternativas — columnas generadas para valores derivados simples y deterministas que consultas o indexas frecuentemente (consistentes, indexables, simples), versus calcular en consultas (sin almacenamiento pero recomputado cada vez e no directamente indexable) o triggers (más flexible pero más complejo) — refleja buen juicio en el diseño.

Ya que mantener datos derivados/computados de forma consistente es una necesidad común, y dado que las columnas generadas proporcionan una forma automática, consistente e indexable de hacerlo (más limpio que mantenimiento manual o triggers para derivaciones simples), comprender columnas generadas es conocimiento valioso y prácticamente relevante de PostgreSQL para diseñar esquemas donde valores computados se mantienen correctos automáticamente y se hacen eficientemente consultables — una característica moderna útil de Postgres para modelado de datos limpio y consistente.