Qu'est-ce que les colonnes générées ?

Question

Accepted Answer

Une **colonne générée** est une colonne dont la valeur est **calculée automatiquement** à partir d'autres colonnes, plutôt que d'être insérée directement. PostgreSQL supporte les colonnes générées **stockées** (Postgres 12+) — la valeur calculée est déterminée à l'écriture et stockée. Elles maintiennent les données dérivées cohérentes automatiquement.

## Définir une colonne générée

```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 clause `GENERATED ALWAYS AS (expression) STORED` fait que `total` est toujours égal à `price * quantity` — calculé à l'insertion/mise à jour et stocké. Vous ne pouvez pas (et n'avez pas besoin) d'insérer directement dedans ; c'est toujours dérivé.

## Utilisations courantes

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

Les colonnes générées sont parfaites pour les valeurs dérivées que vous interrogez souvent — elles restent cohérentes automatiquement et peuvent être **indexées** (puisque stockées).

## Colonnes générées vs calcul dans les requêtes 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.
```

## Pourquoi c'est important

Les colonnes générées sont une fonctionnalité PostgreSQL utile pour **maintenir automatiquement les données dérivées**, et les comprendre est précieux pour garder les valeurs calculées cohérentes et interrogeables.

Le bénéfice principal est que la valeur d'une colonne générée est toujours calculée automatiquement à partir d'autres colonnes et maintenue synchronisée — donc les données dérivées (totaux, noms complets, valeurs normalisées, champs JSONB extraits) restent **cohérentes par construction** sans que le code applicatif ou les mises à jour manuelles n'aient besoin de se souvenir de les recalculer (éliminant une classe de bugs où les données dérivées se désynchronisent).

Parce que les colonnes générées stockées stockent physiquement la valeur, elles peuvent aussi être **indexées** — ce qui est particulièrement précieux pour des choses comme une adresse email en minuscules pour une recherche insensible à la casse, ou l'extraction d'un champ JSONB dans une colonne réelle et indexable (un motif puissant combinant la flexibilité de JSONB avec l'indexation relationnelle).

Comprendre quand utiliser les colonnes générées par rapport aux alternatives — colonnes générées pour des valeurs dérivées simples et déterministes que vous interrogez ou indexez fréquemment (cohérentes, indexables, simples), vs calcul dans les requêtes (pas de stockage mais recalculé à chaque fois et non directement indexable) ou triggers (plus flexible mais plus complexe) — reflète un jugement de conception sain.

Comme maintenir les données dérivées/calculées de manière cohérente est un besoin courant, et comme les colonnes générées fournissent un moyen automatique, cohérent et indexable de le faire (plus propre que la maintenance manuelle ou les triggers pour les dérivations simples), comprendre les colonnes générées est une connaissance PostgreSQL pratique et pertinente pour concevoir des schémas où les valeurs calculées sont maintenues correctes automatiquement et rendues efficacement interrogeables — une fonctionnalité PostgreSQL moderne utile pour une modélisation des données propre et cohérente.