Ce sunt coloanele generate?

Question

Accepted Answer

O **coloană generată** este o coloană a cărei valoare este **calculată automat** din alte coloane, mai degrabă decât să fie inserată direct. PostgreSQL suportă coloane generate **stocate** (Postgres 12+) — valoarea calculată este evaluată la scriere și stocată. Ele mențin datele derivate consistente automat.

## Definirea unei coloane generate

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

Clauza `GENERATED ALWAYS AS (expression) STORED` face ca `total` să fie întotdeauna egal cu `price * quantity` — calculat la insert/update și stocat. Nu poți (și nu trebuie) să inserezi în ea direct; este întotdeauna derivată.

## Utilizări comune

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

Coloanele generate sunt excelente pentru valorile derivate pe care le interogezi frecvent — rămân consistente automat și pot fi **indexate** (deoarece sunt stocate).

## Coloane generate vs calcul în interogări vs triggeri

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

## De ce contează

Coloanele generate sunt o funcționalitate utilă PostgreSQL pentru **menținerea automată a datelor derivate**, iar înțelegerea lor este valoroasă pentru a ține valorile calculate consistente și interogabile.

Beneficiul principal este că valoarea unei coloane generate este întotdeauna calculată automat din alte coloane și ținută sincronizată — deci datele derivate (totale, nume complete, valori normalizate, câmpuri JSONB extrase) rămân **consistente prin construcție** fără ca codul aplicației sau actualizările manuale să trebuie să-și amintească să o recalculeze (eliminând o clasă de erori în care datele derivate se desincronizează).

Deoarece coloanele generate stocate stockează fizic valoarea, ele pot fi de asemenea **indexate** — ceea ce este deosebit de valoros pentru lucruri precum un email cu litere mici pentru căutare case-insensitive, sau extragerea unui câmp JSONB într-o coloană reală, indexabilă (un model puternic combinând flexibilitatea JSONB cu indexarea relațională).

Înțelegerea când se folosesc coloane generate versus alternative — coloane generate pentru valori derivate simple, deterministe pe care le interogezi sau indexezi frecvent (consistente, indexabile, simple), versus calcul în interogări (nicio stocare dar recalculat de fiecare dată și nu direct indexabil) sau triggeri (mai flexibil dar mai complex) — reflectă judecată de design solidă.

Deoarece menținerea datelor derivate/calculate consistente este o nevoie comună, și deoarece coloanele generate oferă o modalitate automată, consistentă, indexabilă să o faci (mai curată decât menținerea manuală sau triggeri pentru derivații simple), înțelegerea coloanelor generate este cunoaștere PostgreSQL valoroasă, practic-relevantă pentru proiectarea schemelor unde valorile calculate sunt ținute corecte automat și făcute eficient interogabile — o funcționalitate PostgreSQL modernă și utilă pentru modelarea datelor curată și consistentă.