Dakle, razmotrili smo pitanja vezana za , i napravili smo digresiju o . I konačno smo došli do najzanimljivijeg — do verzija redova.
Naslov
Kao što smo već spomenuli, svaki red može istovremeno postojati u bazi podataka u nekoliko verzija. Jedna verzija mora biti nekako razlikovana od druge. U tu svrhu svaka verzija ima dvije oznake koje određuju "vrijeme" važenja te verzije (xmin i xmax). U navodnicima — zato što se ne koristi vrijeme u pravom smislu, već poseban rastući brojač. A taj brojač je broj transakcije.
(Kao obično, u stvarnosti je sve složenije: broj transakcija ne može stalno rasti zbog ograničene veličine brojača. Ali te detalje ćemo razmotriti detaljno kada dođemo do zamrzavanja.)
Kada se red kreira, vrijednost xmin se postavlja na broj transakcije koja je izvršila INSERT, a xmax se ne popunjava.
Kada se red briše, vrijednost xmax tekuće verzije se označava brojem transakcije koja je izvršila DELETE.
Kada se red mijenja komandom UPDATE, zapravo se izvode dvije operacije: DELETE i INSERT. U tekućoj verziji reda, xmax se postavlja na broj transakcije koja je izvršila UPDATE. Zatim se kreira nova verzija istog reda; vrijednost xmin joj odgovara vrijednosti xmax prethodne verzije.
Polja xmin i xmax ulaze u naslov verzije reda. Pored ovih polja, naslov sadrži i druge, na primjer:
- infomask — niz bitova koji određuju osobine ove verzije. Ima ih prilično mnogo; osnovne ćemo postepeno razmatrati.
- ctid — referenca na sljedeću, noviju verziju istog reda. U najnovijoj, aktuelnoj, verziji reda ctid se odnosi na samu ovu verziju. Broj ima oblik (x,y), gdje je x broj stranice, a y redni broj pokazivača u nizu.
- bitmapa neodređenih vrijednosti — označava one kolone ove verzije koje sadrže neodređenu vrijednost (NULL). NULL nije jedno od običnih vrijednosti tipova podataka, pa se oznaka mora čuvati odvojeno.
Kao rezultat, naslov postaje prilično velik — minimum 23 bajta po svakoj verziji reda, a obično više zbog bitmapa NULL-ova. Ako je tabela "uska" (tj. sadrži malo kolona), troškovi mogu zauzimati više od korisnih informacija.
Umetanje
Pogledajmo pobliže kako se niske operacije vrše sa stringovima, počevši od umetanja.
Za eksperimente ćemo kreirati novu tabelu sa dva kolone i indeks na jednoj od njih:
=> CREATE TABLE t(
id serial,
s text
);
=> CREATE INDEX ON t(s);
Umetnućemo jedan red, nakon što započnemo transakciju.
=> BEGIN;
=> INSERT INTO t(s) VALUES ('FOO');
Evo broja naše trenutne transakcije:
=> SELECT txid_current();
txid_current
--------------
3664
(1 row)
Pogledajmo sadržaj stranice. Funkcija heap_page_items iz proširenja pageinspect omogućava dobijanje informacija o pokazivačima i verzijama redova:
=> SELECT * FROM heap_page_items(get_raw_page('t',0)) gx
-[ RECORD 1 ]-------------------
lp | 1
lp_off | 8160
lp_flags | 1
lp_len | 32
t_xmin | 3664
t_xmax | 0
t_field3 | 0
t_ctid | (0,1)
t_infomask2 | 2
t_infomask | 2050
t_hoff | 24
t_bits |
t_oid |
t_data | x0100000009464f4f
Primećujemo da reč heap (hrpa) u PostgreSQL označava tabele. Ovo je još jedno čudno korišćenje termina — hrpa je poznata , koja nema ništa zajedničko sa tabelom. Ovdje se ova reč koristi u znanju "sve je bačeno u hrpu", za razliku od uređenih indeksa.
Funkcija pokazuje podatke "kako jesu", u formatu koji je teško razumeti. Da bismo to raširili, ostavićemo samo deo informacija i dešifrovati ih:
=> SELECT '(0,'||lp||')' AS ctid,
CASE lp_flags
WHEN 0 THEN 'unused'
WHEN 1 THEN 'normal'
WHEN 2 THEN 'redirect to '||lp_off
WHEN 3 THEN 'dead'
END AS state,
t_xmin as xmin,
t_xmax as xmax,
(t_infomask & 256) > 0 AS xmin_commited,
(t_infomask & 512) > 0 AS xmin_aborted,
(t_infomask & 1024) > 0 AS xmax_commited,
(t_infomask & 2048) > 0 AS xmax_aborted,
t_ctid
FROM heap_page_items(get_raw_page('t',0)) gx
-[ RECORD 1 ]-+-------
ctid | (0,1)
state | normal
xmin | 3664
xmax | 0
xmin_commited | f
xmin_aborted | f
xmax_commited | f
xmax_aborted | t
t_ctid | (0,1)
Evo šta smo uradili:
- Dodali smo nulu broju pokazivača kako bismo ga doveli do istog oblika kao t_ctid: (broj stranice, broj pokazivača).
- Dešifrovali smo stanje pokazivača lp_flags. Ovde je "normal" — to znači da pokazivač zaista ukazuje na verziju reda. Ostale vrednosti ćemo razmotriti kasnije.
- Od svih informativnih bitova trenutno smo izdvojili samo dva para. Bitovi xmin_committed i xmin_aborted pokazuju da li je transakcija sa brojem xmin priznata (otkazana). Dva slična bita odnose se na transakciju sa brojem xmax.
Šta možemo videti? Kada umetnete red u tabelu, pojaviće se pokazivač sa brojem 1 koji se odnosi na prvu i jedinu verziju reda.
U verziji reda polje xmin je popunjeno brojem aktuelne transakcije. Transakcija je još uvek aktivna, zato oba bita xmin_committed i xmin_aborted nisu postavljena.
Polje ctid verzije reda se odnosi na isti taj red. To znači da novija verzija ne postoji.
Polje xmax je popunjeno lažnim brojem 0, jer ova verzija reda nije obrisana i aktuelna je. Transakcije neće obraćati pažnju na ovaj broj, jer je bit xmax_aborted postavljen.
Napravimo još jedan korak ka poboljšanju čitljivosti, dodavanjem informativnih bitova brojevima transakcija. I kreiraćemo funkciju, jer će nam upit još više puta biti potreban:
=> CREATE FUNCTION heap_page(relname text, pageno integer)
RETURNS TABLE(ctid tid, state text, xmin text, xmax text, t_ctid tid)
AS $$
SELECT (pageno,lp)::text::tid AS ctid,
CASE lp_flags
WHEN 0 THEN 'neiskorišćen'
WHEN 1 THEN 'normalan'
WHEN 2 THEN 'preusmeravanje na '||lp_off
WHEN 3 THEN 'mrtav'
END AS state,
t_xmin || CASE
WHEN (t_infomask & 256) > 0 THEN ' (c)'
WHEN (t_infomask & 512) > 0 THEN ' (a)'
ELSE ''
END AS xmin,
t_xmax || CASE
WHEN (t_infomask & 1024) > 0 THEN ' (c)'
WHEN (t_infomask & 2048) > 0 THEN ' (a)'
ELSE ''
END AS xmax,
t_ctid
FROM heap_page_items(get_raw_page(relname,pageno))
ORDER BY lp;
$$ LANGUAGE SQL;
U ovom obliku je znatno jasnije šta se događa u zaglavlju verzije reda:
=> SELECT * FROM heap_page('t',0);
ctid | stanje | xmin | xmax | t_ctid
-------+--------+------+-------+--------
(0,1) | normalan | 3664 | 0 (a) | (0,1)
(1 red)
Slične, ali značajno manje detaljne informacije mogu se dobiti i iz same tabele, koristeći pseudokolone xmin i xmax:
=> SELECT xmin, xmax, * FROM t;
xmin | xmax | id | s
------+------+----+-----
3664 | 0 | 1 | FOO
(1 red)
Završavanje
Kada se transakcija uspešno završi, potrebno je zapamtiti njen status — označiti da je potvrđena. Za to se koristi struktura koja se zove XACT (a do verzije 10 zvala se CLOG (log o potvrdi) i ovo ime se još može nalaziti na različitim mestima).
XACT — nije tabela sistemskog kataloga; to su fajlovi u katalogu PGDATA/pg_xact. U njima je za svaku transakciju predviđeno dva bita: committed i aborted — baš kao u zaglavlju verzije reda. Ova informacija je podeljena na nekoliko fajlova isključivo radi pogodnosti, a ponovo ćemo se vratiti na ovo pitanje kada budemo razmatrali zamrzavanje. Rad sa ovim fajlovima se vrši po stranicama, kao i sa svim drugim.
Dakle, kada se transakcija fiksira u XACT, postavlja se bit committed za tu transakciju. I to je sve što se dešava prilikom fiksacije (iako trenutno ne govorimo o journal pre-upisa).
Kada neka druga transakcija pristupi tabeli koju smo upravo gledali, moraće da odgovori na nekoliko pitanja.
- Da li je transakcija xmin završena? Ako nije, tada stvorena verzija reda ne sme biti vidljiva.
Takva provera se vrši pregledanjem druge strukture koja se nalazi u zajedničkoj memoriji instancije i zove se ProcArray. U njoj se nalazi lista svih aktivnih procesa, a za svaki je naveden broj njegove trenutne (aktivne) transakcije. - Ako je završena, kako — fiksacijom ili poništenjem? Ako je poništenjem, nadležna verzija reda takođe ne bi trebala biti vidljiva.
E upravo zato je potreban XACT. Međutim, iako se poslednje stranice XACT čuvaju u baferima u operativnoj memoriji, svaki put prozvati XACT je skupo. Stoga se status transakcije koji je jednom utvrđen zapisuje u bite xmin_committed i xmin_aborted verzije reda. Ako je jedan od ovih bitova postavljen, stanje transakcije xmin se smatra poznatim i narednoj transakciji više neće biti potrebno da pristupa XACT.
Zašto ti bitovi nisu postavljeni od strane same transakcije koja izvršava umetanje? Kada dođe do umetanja, transakcija još uvek ne zna da li će biti uspešna. A u trenutku fiksacije već je nejasno koji su tačno redovi u kojim tačno stranicama izmenjeni. Takvih stranica može biti mnogo, i pamćenje njihovih ne bi bilo isplativo. Pored toga, deo stranica može biti istisnut iz bafer menadžera na disk; ponovo ih čitati radi menjanja bitova bi značilo značajno usporavanje fiksacije.
S druge strane ekonomije, posle izmena svaka transakcija (čak i ona koja samo vrši čitanje — SELECT) može početi menjati podatke na stranicama u bafer menadžeru.
Dakle, fiksirajmo izmenu.
=> COMMIT;
Na stranici se ništa nije promenilo (ali znamo da je status transakcije već zabeležen u XACT-u):
=> SELECT * FROM heap_page('t',0);
ctid | stanje | xmin | xmax | t_ctid
-------+--------+------+-------+--------
(0,1) | normalan | 3664 | 0 (a) | (0,1)
(1 red)
Sada će transakcija koja je prva pristupila stranici morati da utvrdi status transakcije xmin i zabeležiće ga u informacione bite:
=> SELECT * FROM t;
id | s
----+-----
1 | FOO
(1 row)
=> SELECT * FROM heap_page('t',0);
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+-------+--------
(0,1) | normal | 3664 (c) | 0 (a) | (0,1)
(1 row)
Brisanje
Kada se redak izbriše iz polja xmax, trenutna verzija zapisuje broj trenutne uklanjajuće transakcije, dok se bit xmax_aborted resetuje.
Primjećujemo da postavljena vrijednost xmax, koja odgovara aktivnoj transakciji, služi kao blokada reda. Ako druga transakcija želi ažurirati ili izbrisati ovaj red, morat će pričekati završetak transakcije xmax. O blokadama ćemo detaljnije govoriti kasnije. Za sada, napominjemo da broj blokada redova nije ograničen. One ne zauzimaju prostor u radnoj memoriji i performanse sistema ne pate od njihovog broja. Istina, „duge“ transakcije imaju druge nedostatke, ali o tome također kasnije.
Izbrišimo redak.
=> POČNI;
=> IZBRIŠI IZ t;
=> ODABERI txid_current();
txid_current
--------------
3665
(1 red)
Vidimo da je broj transakcije upisan u polje xmax, ali informativni bitovi nisu postavljeni:
=> SELECT * FROM heap_page('t',0);
ctid | stanje | xmin | xmax | t_ctid
-------+--------+----------+------+--------
(0,1) | normal | 3664 (c) | 3665 | (0,1)
(1 red)
Poništenje
Poništavanje promjena funkcionira slično kao i potvrda, samo što se u XACT-u za transakciju postavlja bit aborted. Poništavanje se vrši gotovo jednako brzo kao i potvrda. Iako se komanda zove ROLLBACK, poništavanje promjena se ne događa: sve što je transakcija uspjela promijeniti u stranicama podataka ostaje nepromijenjeno.
=> ROLLBACK;
=> ODABERI * IZ heap_page('t',0);
ctid | stanje | xmin | xmax | t_ctid
-------+--------+----------+------+--------
(0,1) | normal | 3664 (c) | 3665 | (0,1)
(1 red)
Pri pristupu stranici će se provjeriti status i u verziju reda će biti postavljen bit oznake xmax_aborted. Sam broj xmax ostaje na stranici, ali ga više niko neće gledati.
=> SELECT * FROM t;
id | s
----+-----
1 | FOO
(1 row)
=> SELECT * FROM heap_page('t',0);
ctid | stanje | xmin | xmax | t_ctid
-------+--------+----------+----------+--------
(0,1) | normal | 3664 (c) | 3665 (a) | (0,1)
(1 red)
Ažuriranje
Ažuriranje funkcioniše kao da se prvo izvršilo brisanje trenutne verzije reda, a zatim umetanje nove.
=> POČNI;
=> AŽURIRAJ t POSTAVI s = 'BAR';
=> ODABERI txid_current();
txid_current
--------------
3666
(1 red)
Upit vraća jedan redak (novu verziju):
=> SELECT * FROM t;
id | s
----+-----
1 | BAR
(1 red)
Ali na stranici vidimo obje verzije:
=> SELECT * FROM heap_page('t',0);
ctid | stanje | xmin | xmax | t_ctid
-------+--------+----------+-------+--------
(0,1) | normal | 3664 (c) | 3666 | (0,2)
(0,2) | normal | 3666 | 0 (a) | (0,2)
(2 reda)
Izbrisana verzija je označena brojem trenutne transakcije u polju xmax. Ovo vrijednost je upisano preko stare, budući da je prethodna transakcija otkazana. A bit xmax_aborted je resetovan, jer status trenutne transakcije još nije poznat.
Prva verzija reda sada se odnosi na drugu (polje t_ctid), kao na noviju.
Na indeksnoj stranici se pojavljuje druga referenca i druga linija, koja se odnosi na drugu verziju na tabelarnoj stranici.
Kao i kod brisanja, maksimalna vrijednost xmax u prvoj verziji linije služi kao pokazatelj da je linija blokirana.
I završimo transakciju.
=> COMMIT;
Indeksi
Do sada smo govorili samo o tabelarnim stranicama. A šta se dešava unutar indeksa?
Informacije na indeksnim stranicama u velikoj mjeri zavise od konkretne vrste indeksa. Čak i kod jedne vrste indeksa mogu postojati različite vrste stranica. Na primjer, B-stablo ima stranicu sa metapodacima i 'obične' stranice.
Ipak, obično stranica sadrži niz pokazatelja na linije i same linije (kao i kod tabelarne stranice). Pored toga, na kraju stranice se ostavlja prostor za posebne podatke.
Linije u indeksima takođe mogu imati veoma različitu strukturu, zavisno od vrste indeksa. Na primjer, za B-stablo, linije koje se odnose na listne stranice sadrže vrijednost ključa indeksiranja i referencu (ctid) na odgovarajuću liniju tabele. Općenito, indeks može biti strukturiran na potpuno drugačiji način.
Najvažnija stvar je da u indeksima bilo koje vrste nema verzija linija. Ili se može smatrati da je svaka linija predstavljena tačno jednom verzijom. Drugim riječima, u headeru indeksne linije ne postoje polja xmin i xmax. Može se smatrati da reference iz indeksa vode na sve tabelarne verzije linija — tako da se može razumjeti koju verziju će transakcija vidjeti samo tako što ćemo zaviriti u tabelu. (Kao i obično, ovo nije cela istina. U nekim slučajevima, mapa vidljivosti omogućava optimizaciju procesa, ali ćemo o tome razgovarati kasnije.)
Pri tome na indeksnoj stranici otkrivamo pokazatelje na obe verzije, kako na aktuelnu, tako i na staru:
=> SELECT itemoffset, ctid FROM bt_page_items('t_s_idx',1);
itemoffset | ctid
------------+-------
1 | (0,2)
2 | (0,1)
(2 reda)
Virtuelne transakcije
U praksi, PostgreSQL koristi optimizaciju koja omogućava 'štednju' brojeva transakcija.
Ako transakcija samo čita podatke, ona nikako ne utiče na vidljivost verzija linija. Zato servisni proces u početku dodeljuje transakcijama virtuelni broj (virtual xid). Broj se sastoji od identifikatora procesa i sekvencijalnog broja.
Izdavanje ovog broja ne zahteva sinhronizaciju između svih procesa i stoga se obavlja vrlo brzo. S drugom razlogom korišćenja virtuelnih brojeva upoznaćemo se kada budemo razgovarali o zamrzavanju.
Virtuelni brojevi se nikako ne uzimaju u obzir u snimcima podataka.
U različitim trenucima u sistemu mogu se nalaziti virtuelne transakcije s brojevima koji su već korišćeni, i to je normalno. Ali takav broj se ne može upisivati u stranice podataka, jer prilikom sledeće referencije na stranicu može izgubiti svaki smisao.
=> POČETAK;
=> IZABERI txid_current_if_assigned();
txid_current_if_assigned
--------------------------
(1 red)
Ako transakcija počne menjati podatke, dobija pravi, jedinstveni broj transakcije.
=> AŽURIRAJ račune SET iznos = iznos - 1.00;
=> IZABERI txid_current_if_assigned();
txid_current_if_assigned
--------------------------
3667
(1 red)
=> COMMIT;
Ugnježdene transakcije
Punkti čuvanja
U SQL-u su definisani punkti čuvanja (savepoint), koji omogućavaju poništavanje dela operacija transakcije, ne prekidajući je potpuno. Ali to se ne uklapa u ranije navedenu šemu, pošto status transakcije važi za sve njene izmene, a fizički se nikakvi podaci ne vraćaju.
Da bi se implementirala takva funkcionalnost, transakcija sa tačkom čuvanja deli se na nekoliko odvojenih ugnježdenih transakcija (subtransaction), čijim statusom se može upravljati odvojeno.
Ugnježdene transakcije imaju svoj vlastiti broj (veći od broja glavne transakcije). Status ugnježdenih transakcija se zapisuje na uobičajen način u XACT-u, ali finalni status zavisi od statusa glavne transakcije: ako je ona poništena, poništavaju se i sve ugnježdene transakcije.
Informacije o ugnježdenosti transakcija čuvaju se u datotekama u direktorijumu PGDATA/pg_subtrans. Pristup datotekama se vrši kroz baferne memorije instancije, organizovane na isti način kao baferi XACT.
Ne mešajte ugnježdene transakcije i autonomne transakcije. Autonomne transakcije se međusobno ne zavise, dok se ugnježdene zavise. Autonomne transakcije u običnom PostgreSQL-u ne postoje, i, verovatno, to je bolje: potrebne su veoma retko, a njihovo postojanje u drugim SGBD-ima provocira zloupotrebu, od koje svi kasnije pate.
Očistićemo tabelu, započeti transakciju i umetnuti red:
=> TRUNCATE TABLE t;
=> BEGIN;
=> INSERT INTO t(s) VALUES ('FOO');
=> SELECT txid_current();
txid_current
--------------
3669
(1 row)
=> SELECT xmin, xmax, * FROM t;
xmin | xmax | id | s
------+------+----+-----
3669 | 0 | 2 | FOO
(1 row)
=> SELECT * FROM heap_page('t',0);
ctid | state | xmin | xmax | t_ctid
-------+--------+------+-------+--------
(0,1) | normal | 3669 | 0 (a) | (0,1)
(1 row)
Sada postavljamo tačku sačuvanja i dodajemo još jedan red.
=> SAVEPOINT sp;
=> INSERT INTO t(s) VALUES ('XYZ');
=> SELECT txid_current();
txid_current
--------------
3669
(1 row)
Primijetite da funkcija txid_current() vraća ID glavne, a ne ugniježdene transakcije.
=> SELECT xmin, xmax, * FROM t;
xmin | xmax | id | s
------+------+----+-----
3669 | 0 | 2 | FOO
3670 | 0 | 3 | XYZ
(2 rows)
=> SELECT * FROM heap_page('t',0);
ctid | state | xmin | xmax | t_ctid
-------+--------+------+-------+--------
(0,1) | normal | 3669 | 0 (a) | (0,1)
(0,2) | normal | 3670 | 0 (a) | (0,2)
(2 rows)
Vraćamo se na tačku sačuvanja i dodajemo treći red.
=> ROLLBACK TO sp;
=> INSERT INTO t(s) VALUES ('BAR');
=> SELECT xmin, xmax, * FROM t;
xmin | xmax | id | s
------+------+----+-----
3669 | 0 | 2 | FOO
3671 | 0 | 4 | BAR
(2 rows)
=> SELECT * FROM heap_page('t',0);
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+-------+--------
(0,1) | normal | 3669 | 0 (a) | (0,1)
(0,2) | normal | 3670 (a) | 0 (a) | (0,2)
(0,3) | normal | 3671 | 0 (a) | (0,3)
(3 rows)
Na stranici i dalje možemo vidjeti red koji je dodala otkazana ugniježdena transakcija.
Fiksiramo promjene.
=> COMMIT;
=> SELECT xmin, xmax, * FROM t;
xmin | xmax | id | s
------+------+----+-----
3669 | 0 | 2 | FOO
3671 | 0 | 4 | BAR
(2 rows)
=> SELECT * FROM heap_page('t',0);
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+-------+--------
(0,1) | normal | 3669 (c) | 0 (a) | (0,1)
(0,2) | normal | 3670 (a) | 0 (a) | (0,2)
(0,3) | normal | 3671 (c) | 0 (a) | (0,3)
(3 rows)
Sada je jasno da svaka ugniježdena transakcija ima svoj status.
Primijetit ćemo da se ugniježdene transakcije ne mogu eksplicitno koristiti u SQL-u, tj. ne možemo započeti novu transakciju bez završetka trenutne. Ovaj mehanizam se neprimjetno aktivira prilikom korištenja tačaka sačuvanja, kao i prilikom obrade izuzetaka PL/pgSQL i u nizu drugih, egzotičnijih slučajeva.
=> BEGIN;
BEGIN
=> BEGIN;
UPUTSTVO: već postoji transakcija u toku
BEGIN
=> COMMIT;
COMMIT
=> COMMIT;
UPUTSTVO: nema transakcije u toku
COMMIT
Greške i atomarnost operacija
Šta će se desiti ako dođe do greške tokom izvršavanja operacije? Na primjer:
=> BEGIN;
=> SELECT * FROM t;
id | s
----+-----
2 | FOO
4 | BAR
(2 rows)
=> UPDATE t SET s = repeat('X', 1/(id-4));
GREŠKA: deljenje sa nulom
Došlo je do greške. Sada se transakcija smatra prekinutom i nijedna operacija u njoj nije dozvoljena:
=> SELECT * FROM t;
GREŠKA: trenutna transakcija je prekinuta, komande se ignorišu do kraja blok transakcije
I čak i ako pokušate fiksirati promjene, PostgreSQL će javiti otkazivanje:
=> COMMIT;
ROLLBACK
Zašto nije moguće nastaviti izvršavanje transakcije nakon greške? Razlog je u tome što je greška mogla nastati na način da bismo imali pristup delu podataka — atomarnost ne bi bila poštovana čak ni za transakciju, već za operatera. Kao u našem primeru, gde je operater do greške uspeo da ažurira jedan red.
=> SELECT * FROM heap_page('t',0);
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+-------+--------
(0,1) | normal | 3669 (c) | 3672 | (0,4)
(0,2) | normal | 3670 (a) | 0 (a) | (0,2)
(0,3) | normal | 3671 (c) | 0 (a) | (0,3)
(0,4) | normal | 3672 | 0 (a) | (0,4)
(4 rows)
Treba reći da psql ima režim koji ipak omogućava nastavak rada transakcije nakon greške kao da se akcije grešnog operatera odbacuju.
=> set ON_ERROR_ROLLBACK on
=> BEGIN;
=> SELECT * FROM t;
id | s
----+-----
2 | FOO
4 | BAR
(2 rows)
=> UPDATE t SET s = repeat('X', 1/(id-4));
GREŠKA: deljenje sa nulom
=> SELECT * FROM t;
id | s
----+-----
2 | FOO
4 | BAR
(2 rows)
=> COMMIT;
Nije teško pogoditi da u tom režimu psql zapravo postavlja implicitnu tačku vraćanja pre svake komande, a u slučaju greške pokreće vraćanje na nju. Ovaj režim se ne koristi po defaultu, jer postavljanje tačaka vraćanja (čak i bez vraćanja na njih) nosi značajne troškove.
Izvor: habr.com
