რა არის გენერირებული სვეტები?

Question

Accepted Answer

**გენერირებული სვეტი** არის სვეტი, რომლის მნიშვნელობა **ავტომატურად გამოითვლება** სხვა სვეტებიდან, ვიდრე პირდაპირ ჩასმული იქნება. PostgreSQL მხარს უჭერს **შენახულ** გენერირებულ სვეტებს (Postgres 12+) — გამოთვლილი მნიშვნელობა მოითხოვება წერტილში და ინახება. ისინი ავტომატურად ინახავენ წარმოებულ მონაცემებს თანმიმდევრობაში.

## გენერირებული სვეტის განსაზღვრა

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

`GENERATED ALWAYS AS (expression) STORED` პუნქტი ხდის `total` ყოველთვის ტოლი `price * quantity` — გამოითვლება insert/update-ზე და ინახება. თქვენ არ შეგიძლიათ (და არ აკეთებთ) პირდაპირ ჩასმა; ის ყოველთვის წარმოებული.

## საერთო გამოყენება

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

გენერირებული სვეტები შესანიშნავი არის წარმოებული მნიშვნელობებისთვის, რომელთა ხშირად შედეგს იძებნით — ისინი ავტომატურად რჩებიან თანმიმდევრობაში და შეიძლება იყოს **ინდექსირებული** (რადგან შენახული).

## გენერირებული სვეტები შედეგების გამოთვლის წინააღმდეგ ტრიგერების წინააღმდეგ

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

## რატომ აქვს მნიშვნელობა

გენერირებული სვეტები სასარგებლო PostgreSQL ფუნქციაა **ავტომატური წარმოებული მონაცემების 维שინახვისთვის**, და მათი გაგება მূল্যვანია გამოთვლილი მნიშვნელობების თანმიმდევრობაში შენახვისა და შედეგის ძებნის კუთხით.

ძირითადი სარგებელი არის ის, რომ გენერირებული სვეტის მნიშვნელობა ყოველთვის ავტომატურად გამოითვლება სხვა სვეტებიდან და უცვლელი რჩება — ამიტომ წარმოებული მონაცემები (სულ, სრული სახელი, ნორმალიზებული მნიშვნელობები, ამოთხزნილი JSONB ველი) რჩება **თანმიმდევრი კონსტრუქციით** აპლიკაციის კოდის გარეშე ან ხელით განახლების გარეშე, რაც უნდა გახსოვდეს მისი გადაანგარიშება (აღმოფხვრა ბაგების კლასი სადაც წარმოებული მონაცემები მოსულობის გარეთ სცდება).

ვინაიდან შენახული გენერირებული სვეტები ფიზიკურად ინახავენ მნიშვნელობას, ისინი ასევე შეიძლება იყოს **ინდექსირებული** — რაც განსაკუთრებით ღირებული არის მცირე ასოს ელფოსტისთვის შემთხვევის მიმართ მდგრადი ძიებისთვის, ან JSONB ველის ამოშენ პროცესში ჩაკრული სვეტად (ძლევამოსილი ნიმუში JSONB მოქნილობის გაერთიანებით რელაციურ ინდექსირებასთან).

მიმართვის გაგება თუ როდის გამოიყენოთ გენერირებული სვეტები ალტერნატივების შესაბამისად — გენერირებული სვეტები მარტივი, განმსაზღვრელი წარმოებული მნიშვნელობებისთვის, რომელთა ხშირად შედეგს იძებნით ან ინდექსირებული (თანმიმდევრი, ინდექსირებული, მარტივი), შედეგში გამოთვლის შესაბამისად (რიცხვი სახსნელი მაგრამ გამოითვლება თითოეული დროზე და არ არის პირდაპირი ინდექსირებული) ან ტრიგერი (უფრო მოქნილი მაგრამ უფრო რთული) — ასახავს წმინდა დიზაინის განჯეროვას.

ვინაიდან წარმოებული/გამოთვლილი მონაცემების შენახვა თანმიმდევრობაში არის საერთო საჭიროება, და ვინაიდან გენერირებული სვეტები უზრუნველყოფენ ავტომატურ, თანმიმდევარ, ინდექსირებულ გზას მის გასაკეთებლად (უფრო სუფთა ვიდრე ხელით ფარავი ან ტრიგერი მარტივი წარმოებებისთვის), გენერირებული სვეტების გაგება ღირებული, პრაქტიკულად შესაბამო PostgreSQL ცოდნა სქემების დიზაინისთვის სადაც გამოთვლილი მნიშვნელობები შენახულია სწორად ავტომატურად და გაკეთებული ეფექტურად შედეგის ძებნის — სასარგებლო თანამედროვე Postgres ფუნქციის გამოყენება სუფთა, თანმიმდევარი მონაცემების მოდელირებისთვის.