Cosa sono le colonne generate?

Question

Accepted Answer

Una **colonna generata** è una colonna il cui valore è **calcolato automaticamente** da altre colonne, piuttosto che essere inserito direttamente. PostgreSQL supporta colonne generate **stored** (Postgres 12+) — il valore calcolato viene determinato al momento della scrittura e memorizzato. Mantengono i dati derivati consistenti automaticamente.

## Definire una colonna generata

```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 clausola `GENERATED ALWAYS AS (expression) STORED` fa sì che `total` sia sempre uguale a `price * quantity` — calcolato al momento dell'insert/update e memorizzato. Non puoi (e non dovresti) inserire direttamente in essa; è sempre derivato.

## Usi comuni

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

Le colonne generate sono ottime per i valori derivati che interroghi spesso — rimangono consistenti automaticamente e possono essere **indicizzate** (poiché memorizzate).

## Colonne generate vs calcolo nelle query vs trigger

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

## Perché è importante

Le colonne generate sono una funzionalità utile di PostgreSQL per **mantenere automaticamente i dati derivati**, e comprenderle è prezioso per mantenere i valori calcolati consistenti e interrogabili.

Il vantaggio principale è che il valore di una colonna generata è sempre calcolato automaticamente da altre colonne e mantenuto sincronizzato — così i dati derivati (totali, nomi completi, valori normalizzati, campi JSONB estratti) rimangono **consistenti per costruzione** senza che il codice applicativo o gli aggiornamenti manuali debbano ricordare di ricalcolarli (eliminando una classe di bug dove i dati derivati diventano non sincronizzati).

Poiché le colonne generate memorizzate fisicamente memorizzano il valore, possono anche essere **indicizzate** — il che è particolarmente prezioso per cose come un'email in minuscolo per la ricerca case-insensitive, o l'estrazione di un campo JSONB in una colonna reale e indicizzabile (uno schema potente che combina la flessibilità di JSONB con l'indicizzazione relazionale).

Comprendere quando utilizzare colonne generate rispetto alle alternative — colonne generate per valori derivati semplici e deterministici che interroghi o indicizzi frequentemente (consistenti, indicizzabili, semplici), rispetto al calcolo nelle query (nessuna memorizzazione ma ricalcolato ogni volta e non direttamente indicizzabile) o trigger (più flessibili ma più complessi) — riflette un giudizio di progettazione solido.

Poiché mantenere i dati derivati/calcolati in modo consistente è un'esigenza comune, e poiché le colonne generate forniscono un modo automatico, consistente e indicizzabile per farlo (più pulito della manutenzione manuale o dei trigger per derivazioni semplici), comprendere le colonne generate è una conoscenza PostgreSQL preziosa e praticamente rilevante per progettare schemi dove i valori calcolati sono mantenuti corretti automaticamente e resi efficientemente interrogabili — una funzionalità Postgres moderna utile per la modellazione dei dati pulita e consistente.