Databázy (2) Prednáška 03. Alexander Šimko

Transcription

1 Databázy (2) Prednáška 03 Alexander Šimko

2 Contents I Databázové transakcie

3 Section 1 Databázové transakcie

4 Transakcie Transakcia je postupnosť príkazov, ktoré vystupujú ako celok

5 Databázové transakcie Databázové transakcie sú transakcie nad databázovým systémom.

6 Motivácia Transakcie Motivácia void transfer(string from, String to, BigNumber amount) { } SELECT balance, overdraft FROM accounts WHERE number = from; if (overdraft == false && balance < amount) { throw new Exception("Insufficient balance"); } UPDATE accounts SET balance = balance - amount WHERE number = from; UPDATE accounts SET balance = balance + amount WHERE number = to;

7 Motivácia Transakcie Motivácia void transfer(string from, String to, BigNumber amount) { } SELECT balance, overdraft FROM accounts WHERE number = from; if (overdraft == false && balance < amount) { throw new Exception("Insufficient balance"); } UPDATE accounts SET balance = balance - amount WHERE number = from; // Co ak v tomto momente spadne databazove spojenie? UPDATE accounts SET balance = balance + amount WHERE number = to;

8 Atomickosť Transakcie Atomickosť (Atomicity) Buď sa vykonajú všetky príkazy v transakcii alebo žiaden

9 Atomickosť Transakcie - príkazy BEGIN, COMMIT a ROLLBACK BEGIN [TRANSACTION] začne novú transakciu ak je spustený už počas behu transakcie, vygeneruje varovanie, ale stav transakcie sa nezmení COMMIT [TRANSACTION] úspešne ukončí transakciu a vykonané zmeny sa potvrdia ROLLBACK [TRANSACTION] zruší aktuálne bežiacu transakciu všetky zmeny, ktoré boli vykonané od BEGIN sa zrušia

10 Atomickosť COMMIT Príklad data type value (A1) BEGIN; (A2) SELECT sum(value) FROM data WHERE type = 2; (A3) INSERT INTO data (type,value) VALUES (2,30); (A4) SELECT sum(value) FROM data WHERE type = 2; (A5) COMMIT; (B1) SELECT sum(value) FROM data WHERE type = 2;

11 Atomickosť ROLLBACK Príklad data type value (A1) BEGIN; (A2) SELECT sum(value) FROM data WHERE type = 2; (A3) INSERT INTO data (type,value) VALUES (2,30); (A4) SELECT sum(value) FROM data WHERE type = 2; (A5) ROLLBACK; (B1) SELECT sum(value) FROM data WHERE type = 2;

12 Atomickosť Čo ak spojenie skončí skôr než zavoláme COMMIT alebo ROLLBACK? Zmeny sa zrušia podobne ako keby sme zavolali ROLLBACK.

13 Atomickosť BEGIN, COMMIT a ROLLBACK Typické použitie void transfer(string from, String to, BigNumber amount) { BEGIN; try { SELECT balance, overdraft FROM accounts WHERE number = from; if (overdraft == false && balance < amount) { throw new Exception("Insufficient balance"); } UPDATE accounts SET balance = balance - amount WHERE number = from; UPDATE accounts SET balance = balance + amount WHERE number = to; COMMIT; } catch (Exception e) { ROLLBACK; throw e;} }

14 Atomickosť BEGIN, COMMIT a ROLLBACK Typické použitie void transfer(string from, String to, BigNumber amount) { BEGIN; try { SELECT balance, overdraft FROM accounts WHERE number = from; if (overdraft == false && balance < amount) { throw new Exception("Insufficient balance"); } UPDATE accounts SET balance = balance - amount WHERE number = from; // Ak tu padne spojenie, databazovy system nedostane COMMIT UPDATE accounts SET balance = balance + amount WHERE number = to; COMMIT; } catch (Exception e) { ROLLBACK; throw e;} }

15 Atomickosť Transakcie Chyby V prípade akejkoľvek chyby: syntaktická chyba porušené integritné obmedzenie,... sú všetky príkazy ignorované a systém čaká kým dostane: COMMIT alebo ROLLBACK. V oboch prípadoch transakciu zruší.

16 Atomickosť Transakcie Chyby (A1) BEGIN; (A2) INSERT INTO data (type,value) VALUES (2,30); (A3) SELECT * FROM; -- ERROR: syntax error at or near ";" (A4) SELECT sum(value) FROM data WHERE type = 2; -- ERROR: current transaction is aborted, commands ignored until end of transaction block (A5) COMMIT; -- ROLLBACK

17 Atomickosť Transakcie - Autocommit mód je vtedy, ak nepoužívame BEGIN a COMMIT explicitne každý príkaz beží vo vlastnej transakcii

18 Atomickosť JDBC a transakcie transakcie sa ovládajú metódami rozhrania Connection void setautocommit(boolean autocommit) nastaví spôsob vykonávania SQL príkazov true každý SQL príkaz beží v samotnej transakcii spôsobí, že príkaz BEGIN sa nebude posielať false príkazy sú zoskupené do transakcií (oddelených commit/rollback) tento príkaz samotný BEGIN ešte nepošle BEGIN sa posiela tesne pred spustením SQL príkazu, ak ešte nie sme v transakcii

19 Atomickosť JDBC a transakcie void setautocommit(boolean autocommit) ak meníme autocommit mód a transakcia beží, tak je transakcia commitnutá ak nemeníme autocommit mód, nič sa neudeje

20 Atomickosť JDBC a transakcie void commit() akceptuje transakciu (na pozadí pošle COMMIT) void rollback() zruší transakciu (na pozadí pošle ROLLBACK)

21 Atomickosť JDBC a transakcie Connection c = // nove spojenie Statement s = c.createstatement(); c.setautocommit(true); // nasledovne prikazy posielame v autocommit mode s.executeupdate("update accounts SET balance = 10"); // poslal sa iba UPDATE, ziaden BEGIN ani COMMIT s.executeupdate("update accounts SET balance = 20"); // opat sa poslal iba UPDATE, ziaden BEGIN ani COMMIT

22 Atomickosť JDBC a transakcie c.setautocommit(false); // rusime autocommit mode // BEGIN sa este neposlal // transakcia este nebezi s.executeupdate("update accounts SET balance = 30"); // teraz sa poslal aj BEGIN aj UPDATE // uz bezime v transakcii s.executeupdate("update accounts SET balance = 40"); // uz sme v transakcii, takze sa teraz poslal iba UPDATE c.commit(); // teraz sa poslal COMMIT // uz nebezime v transakcii s.executeupdate("update accounts SET balance = 50"); // kedze nie sme v autocommit mode a transakcia nebezi // posle sa BEGIN aj UPDATE // bezime v dalsej transakcii

23 Atomickosť JDBC a transakcie c.setautocommit(true); // transakcia bezi, takze toto spusti COMMIT // transakcia je ukoncena // nasledovne prikazy posielame v autocommit mode s.executeupdate("update accounts SET balance = 60"); // poslal sa iba UPDATE, ziaden BEGIN ani COMMIT s.executeupdate("update accounts SET balance = 70"); // opat sa poslal iba UPDATE, ziaden BEGIN ani COMMIT

24 Atomickosť Transakcie Ako sa dosahuje atomicita? databázový systém každú operáciu pred vykonaním zaloguje: redo log zapíše sa záznam, ktorý obsahuje info o tom, čo sa zmenilo (nové hodnoty, ktoré riadky sa zmazali,...) undo log zapíše sa záznam, ktorý hovorí ako dostaneme databázu do stavu pred vykonaním operácie (ktoré riadky musíme pridať, zmazať, aké boli pôvodné hodnoty) v prípade rollbacku vie aplikovaním undo logu vrátiť databázu do pôvodného stavu v prípade výpadku vie potom podľa redo logu operácie buď zopakovať alebo podľa undo logu vrátiť databázu do pôvodného stavu

25 Atomickosť Transakcie Atomicita Ako dopadne nasledovný príkaz? Majme pázdnu tabuľku vytvorenú príkazom CREATE TABLE test ( x integer CHECK(x > 0) ) Predpokladajme, že spojenie je v autocommit móde a spustíme príkaz INSERT INTO test(x) VALUES (1), (-1) Ako bude vyzerať tabuľka?

26 Atomickosť Transakcie Atomicita Ako dopadne nasledovný príkaz? Tabuľka bude prázdna autocommit mód jeden príkaz je jedna transakcia celý príkaz buď prejde, alebo celý neprejde keďže časť príkazu neprejde, tak neprejde celý príkaz

27 Trvanlivosť Transakcie Trvanlivosť (Durability) vykonaním COMMIT musia prežiť zmeny vykonané transakciou aj keby hneď na to databázový systém celý padol dáta, ktoré sú zapísané zatiaľ iba vo vyrovnávacích pamätiach sa musia zapísať do trvalej pamäte (na disk)

28 Konzistentnosť Transakcie Konzistentnosť (Consistency) po skončení transakcii sú splnené všetky integritné obmedzenia ak by transakcia mala porušiť nejaké integritné obmedzenie, transakcia sa zruší

29 Konzistentnosť Odložiteľné integritné obmedzenia Pri vytváraní integritného obmedzenia môžeme uviesť NOT DEFERRABLE integritné obmedzenie sa bude kontrolovať vždy po vykonaní príkazu modifikujúceho databázu (toto je default) DEFERRABLE kontrola integritného obmedzenia sa dá odložiť na koniec transakie Tieto sa dajú odložiť (v PostgreSQL) UNIQUE, PRIMARY KEY, FOREIGN KEY/REFERENCES Tieto sa nedajú odložiť (v PostgreSQL) NOT NULL, CHECK

30 Konzistentnosť Odloženie integritných obmedzení SET CONSTRAINTS nazov_obmedzenia_1,..., nazov_obmedzenia_n mod SET CONSTRAINTS ALL mod zvoleným/všetkým DEFERRABLE integritným obmedzeniam nastaví zadaný mód kontroly zmena platí v rámci aktuálnej transakcie kde mod je IMMEDIATE integritné obmedzenie sa skontroluje po vykonaní príkazu, ktorý modifikuje dáta DEFERRED integritné obmedzenie sa skontroluje na konci transakcie

31 Konzistentnosť Default správanie Ak nepoužijeme SET CONSTRAINTS, použije sa to, čo sme zadali pri vytváraní integritného obmedzenia: INITIALLY IMMEDIATE integritné obmedzenie sa skontroluje po vykonaní príkazu, ktorý modifikuje dáta (toto je default) INITIALLY DEFERRED integritné obmedzenie sa skontroluje na konci transakcie

32 Konzistentnosť Odloženie integritných obmedzení Príklad CREATE TABLE main (id integer PRIMARY KEY, val integer); CREATE TABLE sub (id integer, ref integer REFERENCES main DEFERRABLE INITIALLY IMMEDIATE); BEGIN; INSERT INTO sub(id, ref) VALUES (10, 1); -- zlyha tu INSERT INTO main(id, val) VALUES (1,100); COMMIT; BEGIN; SET CONSTRAINTS ALL DEFERRED; INSERT INTO sub(id, ref) VALUES (10, 1); INSERT INTO main(id, val) VALUES (1, 100); COMMIT; -- zbehne v poriadku

33 Konzistentnosť Odloženie integritných obmedzení Kedy to pomôže? Pri komplexných vzťahoch (zložených objektoch) do kolekcie si odložíme veľa inštancií Row Data Gateway potom ich chceme v cykle uložiť do DB nemusíme sa starať, či sú v správnom poradí toto je samozrejme možné iba ak vieme dopredu idčka keď budeme preberať Data Mapper sa to ukáže ako veľmi vhodné

34 Platnosť dát Dáta môžeme považovať za platné až keď prejde COMMIT CRATE TABLE test ( x integer UNIQUE DEFERRABLE INITIALLY DEFERRED ); BEGIN; INSERT INTO (x) VALUES (10), (10); -- zbehne SELECT count(*) FROM TEST; -- zbehne a vrati 2 COMMIT; -- padne to az tu, cize vysledok z prechadzajuceho kroku musime zahodit

35 Platnosť dát Dáta môžeme považovať za platné až keď prejde COMMIT CRATE TABLE test ( x integer UNIQUE DEFERRABLE INITIALLY DEFERRED ); BEGIN; INSERT INTO (x) VALUES (10), (10); -- zbehne SELECT count(*) FROM TEST; -- zbehne a vrati 2 COMMIT; -- padne to az tu, cize vysledok z prechadzajuceho kroku musime zahodit získané dáta nemôžeme považovať za platné pokiaľ nezbehne COMMIT čiže pozor, kedy prečítané dáta posielame externým systémom

36 Transakcie Čo ďalšie by sa mohlo pokaziť? void transfer(string from, String to, BigNumber amount) { BEGIN; try { SELECT balance, overdraft FROM accounts WHERE number = from; if (overdraft == false && balance < amount) { throw new Exception("Insufficient balance"); } UPDATE accounts SET balance = balance - amount WHERE number = from; UPDATE accounts SET balance = balance + amount WHERE number = to; COMMIT; } catch (SQLException e) { ROLLBACK; throw e;} }

37 Transakcie Čo ďalšie by sa mohlo pokaziť? void transfer(string from, String to, BigNumber amount) { BEGIN; try { SELECT balance, overdraft FROM accounts WHERE number = from; if (overdraft == false && balance < amount) { throw new Exception("Insufficient balance"); } // Co ak v tomto momente ina transakcia vyberie vsetky peniaze? UPDATE accounts SET balance = balance - amount WHERE number = from; UPDATE accounts SET balance = balance + amount WHERE number = to; COMMIT; } catch (SQLException e) { ROLLBACK; throw e;} }

38 Transakcie (Isolation) izolovanie transakcie od zmien realizovaných súbežne bežiacími transakciami existuje viacero stupňov izolovanosti ideál: akokeby naraz bežala iba jedna transakcia

39 Transakcie Východiská program posiela databázovému systému jednotlivé príkazy postupne táto postupnosť vo všeobecnosti nie je dopredu daná napr. program spúšta príkazy v if-e na základe nejakej podmienky databázový systém teda v žiadnom momente nemôže vedieť, aké prikazy budú nasledovať

40 Transakcie Východiská preto databázový systém spúšta príkazy tak ako prichádzajú, plus vykonáva opatrenia na zabezpečenie izolovanosti vykonávanie opatrení znižuje výkonnosť systému nie vždy potrebujeme plnú izolovanosť preto máme viac úrovní izolovanosti

41 Transakcie Úrovne izolovanosti PostgreSQL má tieto Read Commited Repeatable read Serializable každá úroveň chráni pred neželanými javmi istého typu

42 Ako DBS implementuje izolovanosť? zamykanie multiversioning

43 Ako DBS implementuje izolovanosť? Zamykanie dáta, ku ktorým transakcia pristupuje, sa zamknú tým pádom k nim nemôže pristúpiť nikto iný keď transakcia už dáta nepotrebuje, tak ich odomkne

44 Zamykanie Zopakovanie Row[] array; void a(int index) { array[index].col1 *= 2; array[index].col2++; } int b() { int sum = 0; for (int i=0; i<array.length; ++i) { sum += array[i].col1 - array[i].col2; } return sum; }

45 Zamykanie Zopakovanie Row[] array; Lock arraylock; void a(int index) { arraylock.lock(); // zamkli sme, ostatni budu na prikaze arraylock.lock() cakat array[index].col1 *= 2; array[index].col2++; arraylock.unlock(); // povolime, aby niekto dalsi presiel cez arraylock.lock() } int b() { arraylock.lock(); int sum = 0; for (int i=0; i<array.length; ++i) { sum += array[i].col1 - array[i].col2; } arraylock.unlock(); return sum; }

46 Zamykanie Problém Row[] array; Lock arraylock; void a(int index) { arraylock.lock(); array[index].col1 *= 2; array[index].col2++; arraylock.unlock(); } Toto riešenie nám neumožňuje paralelne aktualizovať prvky na rôznych indexoch

47 Zamykanie Zámok pre každý prvok Row[] array; Lock[] locks; void a(int index) { locks[index].lock(); array[index].col1 *= 2; array[index].col2++; locks[index].unlock(); } int b() { for (int i=0;i<array.length;++i) {locks[i].lock();} int sum = 0; for (int i=0; i<array.length;++i) { sum += array[i].col1 - array[i].col2; } for (int i=0;i<array.length;++i){locks[i].unlock();} return sum; }

48 V DB sa môže zamykať tabuľka ako celok iba vybrané riadky diskové bloky

49 Zamykanie Problém 2 Row[] array; Lock[] locks; int b() { for (int i=0;i<array.length;++i) {locks[i].lock();} int sum = 0; for (int i=0; i<array.length;++i) { sum += array[i].col1 - array[i].col2; } for (int i=0;i<array.length;++i){locks[i].unlock();} } return sum; Toto riešenie nám neumožňuje spustiť b() 2x paralelne, hoci dáta iba číta

50 Zamykanie Viac módov zamykania Row[] array; ReadWriteLock[] locks; //zamky ineho typu void a(int index) { locks[index].writelock().lock(); // zamkli sme na zapis // ine citanie ani zapis nebude povolene array[index].cal1 *= 2; array[index].cal2++; locks[index].writelock().unlock(); // vsetkych odomkneme } int b() { for (int i=0;i<array.length;++i) {locks[i].readlock().lock();} // zamkli sme na citanie - zapisy nie su povolene, citania ano int sum = 0; for (int i=0; i<array.length;++i) { sum += array[i].col1 - array[i].col2; } for (int i=0;i<array.length;++i){locks[i].readlock().unlock();} return sum; }

51 Zamykanie Ako sa módy vylučujú read write read ok x write x x

52 V DB je módov oveľa viac Módy riadkových zámkov FOR UPDATE FOR NO KEY UPDATE FOR SHARE FOR KEY SHARE Módy tabuľkových zámkov ACCESS SHARE ROW SHARE ROW EXCLUSIVE SHARE UPDATE EXCLUSIVE SHARE SHARE ROW EXCLUSIVE EXCLUSIVE ACCESS EXCLUSIVE Každý mód má zoznam ostatných módov, s ktorými sa vylučuje

53 V DB je módov oveľa viac Ani PostgreSQL dokumentácia poriadne nehovorí, na čo ktorý mód slúži:(

54 V DB je módov oveľa viac Zhruba je to o tom: čítanie dát musí vylúčiť modifikácie nad čítanými riadkami aktualizovanie dát musí vylúčiť zápisy nad modifikovanými riadkami modifikovanie štruktúry tabuľky musí vylúčiť všetky čítania a zmeny na tabuľke a jej dátach...

55 Zamykanie pesimistické vs optimistické BEGIN; UPDATE data SET value = 30 WHERE value = 50; COMMIT; Row[] array; for (int i = 0; i < array.length; ++i) { if (array[i].value == 50) { array[i].value = 30; } }

56 Zamykanie pesimistické Row[] array; Lock[] locks; for (int i = 0; i < array.length; ++i) { // pri pesimistickom zamykani zamkneme hned // bez ohladu na mod, nikto nemoze riadok zmenit // aj keby to bol riadok, o ktory nemame zaujem locks[i].lock(); if (array[i].value == 50) { array[i].value = 30; } locks[i].unlock(); } dôsledkom je, že sme zamkli každý riadok niektoré aj zbytočne (nemenili sme ich) znižujeme výkon systému

57 Zamykanie optimistické Row[] array; Lock[] locks; for (int i = 0; i < array.length; ++i) { // pri citani nezamykame vobec if (array[i].value == 50) { // zamkneme az ideme zapisovat locks[i].lock(); // testujeme opat, lebo medzitym mohol niekto zmenit hodnotu if (array[i].value == 50) { array[i].value = 30; } locks[i].unlock(); } } znížili sme počet zamykaní lepší výkon systému

58 V DB sa zámky odomykajú vždy až na konci transakcii

59 Ako DBS implementuje izolovanosť? Multiversioning Predpokladajme dve transakcie: A: BEGIN; UPDATE data SET value = 30 WHERE value = 50; COMMIT; B: BEGIN; SELECT sum(value) FROM data; COMMIT; }

60 Ako DBS implementuje izolovanosť? Multiversioning transakcia B iba číta dáta nepotrebuje ostatným zakázať zapisovanie ak bude vidieť dáta ako vyzerali pred tým, než začalo zapisovanie to vieme docieliť napr. pomocou undo logu, ukladadím rôznych verzií riadkov Multiversioning umožňuje transakciám vidieť dáta v rôznych časových bodoch (verziách) redukuje množstvo zamykania

61 Špinavé čítanie (dirty read) Transakcia prečíta necommitnuté dáta zapísané inou transakciou (špinavé dáta)

62 Javy Špinavé čítanie (dirty read) data type value (A1) BEGIN; (B1) BEGIN; (B2) INSERT INTO data (type,value) VALUES (2,30); (A2) SELECT SUM(value) AS x FROM data WHERE type = 2; ak A2 prečíta 330, ide o špinavé čítanie ak A2 prečíta 300, neide o špinavé čítanie

63 Javy Špinavé čítanie (dirty read) data type value (A1) BEGIN; (B1) BEGIN; (B2) INSERT INTO data (type,value) VALUES (2,30); (B3) COMMIT; (A2) SELECT SUM(value) AS x FROM data WHERE type = 2; teraz ak A2 prečíta 330, o špinavé čítanie už neide, lebo (B3) commitla dáta

64 PostgreSQL Úroveň Read Commited Chráni transakciu pred špinavým čítaním

65 PostgreSQL Úroveň Read Commited Ako funguje? INSERT zamkne čo potrebuje a vloží nové riadky SELECT nevidí aktuálnu verziu databázy ale rekonštruovanú berú sa zmeny commitnuté inými transakciami pred spustením príkazu berú sa aj zmeny vykonané aktuálnou transakciou nekommitnuté zmeny vykonané inými transakciami alebo commitnuté inými transakciami po tom, čo sa príkaz začal vykonávať, sú ignorované

66 PostgreSQL Úroveň Read Commited Ako funguje? UPDATE, DELETE 1. Vyberie riadky, ktoré spĺňajú WHERE podmienku tu platí to isté, čo pre SELECT. 2. Zamkne tieto riadky na zápis ak iná transakcia zapisuje, tak aktuálna čaká, kým commitne alebo rollbackne. 3. Prechádza riadky a vykonáva zmenu tu môže zistiť, že sa riadky zmenili, lebo medzi krokom 1 a 2 commitla iná transakcia. Použije novú verziu riadkov a prekontroluje, či WHERE podmienka je stále splnená. Zmazané riadky ignoruje. 4. Riadky sa neodomykajú odomykajú sa až na konci transakcie.

67 PostgreSQL Úroveň Read Commited Problém Nechráni nás už pred neopakovateľným čítaním.

68 Javy neopakovateľné čítanie (nonrepeatable read) transakcia opätovne prečíta riadky, ktoré už raz čítala zistí, že dáta sú iné než pri predchádzajúcom čítaní a dáta boli zmenené transakciou, ktorá medzičasom bola akceptovaná (COMMIT)

69 Javy neopakovateľné čítanie (nonrepeatable read) data type value (A1) BEGIN; (A2) SELECT SUM(value) AS x FROM data WHERE type = 2; -- x = 300 (B1) BEGIN; (B2) UPDATE data SET value = 300 WHERE value = 200; (B3) COMMIT; (A3) SELECT SUM(value) as y FROM data WHERE type = 2; -- y = 300 alebo y = 400? ak A3 prečíta 400, ide o neopakovateľné čítanie ak A3 prečíta 300, neide o neopakovateľné čítanie

70 Javy neopakovateľné čítanie (nonrepeatable read) websites id hits (A1) BEGIN; (A2) UPDATE websites SET hits = hits + 1; (A3) END; (B1) BEGIN; (B2) DELETE FROM websites WHERE hits = 10; (B3) END;

71 Javy neopakovateľné čítanie (nonrepeatable read) websites id hits (A2) UPDATE websites SET hits = hits + 1; (B2) DELETE FROM websites WHERE hits = 10; Môže to dopadnúť takto: 1. Začne A2, uzamkne oba riadky. 2. Zhehne WHERE časť B2, ktorá vidí pôvodnú tabuľku. Vyberie druhý riadok. 3. DELETE časť B2 čaká, lebo riadky sú zamknuté. 4. A commitne. Nové hodnoty stĺpca hits sú 10 a Pokračuje B2. Zistí, že druhý riadok už nespĺňa pôvodnú podmienku a teda ho ignoruje.

72 Javy neopakovateľné čítanie (nonrepeatable read) websites id hits (A2) UPDATE websites SET hits = hits + 1; (B2) DELETE FROM websites WHERE hits = 10; Môže to dopadnúť takto: Nové hodnoty stĺpca hits sú 10 a 11. Žiaden riadok nebol zmazaný, hoci aj predtým aj potom máme riadok spĺňajúci podmienku. B2 čítal ten istý riadok 2x, no ten medzitým zmenila commitnutá transakcia.

73 PostgreSQL Úroveň Repeatable Read Chráni nás pred neopakovateľným čítaním

74 PostgreSQL Úroveň Repeatable Read Ako funguje? podobne ako Read Commited až na 2 zmeny INSERT zamkne čo potrebuje a vloží nové riadky SELECT nevidí aktuálnu verziu databázy ale rekonštruovanú berú sa zmeny commitnuté inými transakciami pred začiatkom transakcie berú sa aj zmeny vykonané aktuálnou transakciou nekommitnuté zmeny vykonané inými transakciami alebo commitnuté inými transakciami po začiatku transakcie sú ignorované ako začiatok sa berie prvý príkaz po príkaze BEGIN

75 PostgreSQL Úroveň Repeatable Read Ako funguje? UPDATE, DELETE 1. Vyberie riadky, ktoré spĺňajú WHERE podmienku tu platí to isté, čo pre SELECT. 2. Zamkne tieto riadky na zápis ak iná transakcia zapisuje, tak aktuálna čaká, kým commitne alebo rollbackne. 3. Prechádza riadky a vykonáva zmenu tu môže zistiť, že sa riadky zmenili, lebo medzi začiatkom transakcie a bodom 2 commitla iná transakcia. V prípade, že sa riadky reálne zmenili alebo boli zmazané, aktuálna transakcia je zrušená s chybou serialization_failure 4. Riadky sa neodomykajú odomykajú sa až na konci transakcie.

76 PostgreSQL Úroveň Repeatable Read Ako funguje? hraničný prípad ako garantovať túto úroveň izolovanosti je transakciu zrušiť musíme byť teda pripravení transakciu opätovne spustiť

77 PostgreSQL Repeatable read Príklad websites id hits (A2) UPDATE websites SET hits = hits + 1; (B2) DELETE FROM websites WHERE hits = 10; Môže to dopadnúť takto: 1. Začne A2, uzamkne oba riadky. 2. Zhehne WHERE časť B2, ktorá vidí pôvodnú tabuľku. Vyberie druhý riadok. 3. DELETE časť B2 čaká, lebo riadky sú zamknuté. 4. A commitne. Nové hodnoty stĺpca hits sú 10 a Pokračuje B2. Zistí, že druhý riadok bol zmenený a teda transakciu B zruší.

78 PostgreSQL Repeatable read Príklad Opätovne spustíme transakciu B websites id hits (B2) DELETE FROM websites WHERE hits = 10; 1. Transakcia B teraz vidí od začiatku nové hodnoty. 2. Transakcia A už je ukončená, takže k žiadnej interakcii nedôjde. 3. B úspešne skončí.

79 PostgreSQL Repeatable read Príklad websites id hits 2 11

80 PostgreSQL Úroveň Repeatable Read Problém Nechráni už pred serializačnou anomáliou

81 Serializačná anomália (serialization anomaly) Výsledok transakcií bude iný, akokeby boli spustené jedna po druhej

82 Serializačná anomália data type value (A1) BEGIN; (A2) SELECT SUM(value) AS x FROM data WHERE type = 1; (A3) INSERT INTO data (type,value) VALUES (2,x); (A4) COMMIT; (B1) BEGIN; (B2) SELECT SUM(value) AS y FROM data WHERE type = 2; (B3) INSERT INTO data (type,value) VALUES (1,y); (B4) COMMIT;

83 Serializačná anomália Prípustná možnosť AB data type value (A1) BEGIN; (A2) SELECT SUM(value) AS x FROM data WHERE type = 1; (A3) INSERT INTO data (type,value) VALUES (2,x); -- (2,30) (A4) COMMIT; (B1) BEGIN; (B2) SELECT SUM(value) AS y FROM data WHERE type = 2; (B3) INSERT INTO data (type,value) VALUES (1,y); -- (1,330) (B4) COMMIT;

84 Serializačná anomália Prípustná možnosť BA data type value (B1) BEGIN; (B2) SELECT SUM(value) AS y FROM data WHERE type = 2; (B3) INSERT INTO data (type,value) VALUES (1,y); -- (1,300) (B4) COMMIT; (A1) BEGIN; (A2) SELECT SUM(value) AS x FROM data WHERE type = 1; (A3) INSERT INTO data (type,value) VALUES (2,x); -- (2,330) (A4) COMMIT;

85 Serializačná anomália Problémový prípad data type value (A1) BEGIN; (B1) BEGIN; (A2) SELECT SUM(value) AS x FROM data WHERE type = 1; (B2) SELECT SUM(value) AS y FROM data WHERE type = 2; (A3) INSERT INTO data (type,value) VALUES (2,x); -- (2,30) (B3) INSERT INTO data (type,value) VALUES (1,y); -- (1,300) (A4) COMMIT; (B4) COMMIT;

86 Serializačná anomália Rekapitulácia AB (1,330) (2,30) BA (1,300) (2,330) problémový prípad (1,300) (2,30)

87 PostgreSQL Úroveň Serializable Chráni nás pred serializačnou anomáliou

88 PostgreSQL Úroveň Serializable Ako funguje? ako Repeatable Read navyše pri čítaní riadkov si pre transakciu uchovávame podmienky, podľa ktorých sme riadky vyberali potom pri kommitnutí iných transakcií vieme skontrolovať, či menené dáta spôsobia zmenu výsledkov už vykonaných príkazov aktuálnej transakcie ak k tomu dôjde, aktuálna transakcia je zrušená s chybou serialization_failure

89 PostgreSQL Úroveň Serializable Príklad data type value (A1) BEGIN; (B1) BEGIN; (A2) SELECT SUM(value) AS x FROM data WHERE type = 1; -- pre A sa zapamata podmienka P1: type = 1 (B2) SELECT SUM(value) AS y FROM data WHERE type = 2; -- pre B sa zapamata podmienka P2: type = 2 (A3) INSERT INTO data(type,value) VALUES (2,x); -- (2,30) (B3) INSERT INTO data(type,value) VALUES (1,y); -- (1,300) (A4) COMMIT; -- A uspesne prebehne (B4) COMMIT; -- A menila data, na ktorych B zavisi. B je zrusena.

90 PostgreSQL Úroveň Serializable Príklad Opätovne spustíme B. data type value (B1) BEGIN; (B2) SELECT SUM(value) AS y FROM data WHERE type = 2; (B3) INSERT INTO data(type,value) VALUES (1,y); -- (1,330) (B4) COMMIT;

91 PostgreSQL Úroveň Serializable Príklad data type value

92 PostgreSQL Úroveň Serializable je to najvyšší stupeň izolovanosti garantuje, že výsledok vykonania transakcií bude taký, akokeby sme ich vykonávali jednu po druhej umožňuje zjednodušiť vývoj aplikácie ak vieme garantovať, že každá transakcia sama o sebe urobí korektnú vec, potom aj kolekcia transakcií s úrovňou Serializable urobí korektnú vec

93 Fantómové čítanie (phantom read) transakcia získa riadky spĺňajúce nejakú podmienku opätovné získanie s tou istou podmienkou vráti tie isté riadky, plus nejaké navyše

94 Fantómové čítanie (phantom read) data type value (A1) BEGIN; (A2) SELECT SUM(value) AS X FROM data WHERE type = 2; -- X = 300 (B1) BEGIN; (B2) INSERT INTO data (type,value) VALUES (2, 300); (B3) COMMIT; (A3) SELECT SUM(value) AS Y FROM data WHERE type = 2; ak A3 vráti 600, ide o fantómové čítanie ak A3 vráti 300, neide o fantómové čítanie neide o neopakovateľné čítanie už čítané riadky sa nezmenili

95 To o izolovanosti doteraz bolo o tom ako izolovanosť implementuje PostgreSQL

96 Štandard definuje úrovne izolovanosti cez javy, ktoré môžu nastať úroveň čítanie serializačná špinavé neop. fantómové anomália Read uncommitted áno* áno áno áno Read committed nie áno áno áno Repeatable read nie nie áno* áno Serializable nie nie nie nie keď si v PostgreSQL vyžiadame Read uncommited, dostaneme Read commited * SQL špecifikácia ich povoľuje, no v PostgreSQL nenastanú v PostgreSQL je default Read Committed

97 Úrovne izolovanosti štandard ich definuje vo forme javov, ktoré nemôžu nastať nie je jednoznačný v definícii javov existujúce databázové systémy ich implementujú rôzne a rôznia sa v správani

98 Úrovne izolovanosti Ako ich vybrať BEGIN [TRANSACTION] ISOLATION LEVEL uroven kde uroven je READ UNCOMMITTED READ COMMITTED REPEATABLE READ SERIALIZABLE

99 Úroveň izolovanosti JDBC Rozhranie Connection void settransactionisolation(int level) nastaví danú úroveň izolovanosti ovplyvňuje, čo sa pošle v BEGIN ISOLATION LEVEL treba volať pred začiatkom transakcie, inač hodí výnimku kde level je Connection.TRANSACTION_READ_UNCOMMITTED Connection.TRANSACTION_READ_COMMITTED Connection.TRANSACTION_REPEATABLE_READ Connection.TRANSACTION_SERIALIZABLE

100 Každá transakcia môže mať inú izolovanosť izolovanosť je vlastnosť konkrétnej transakcie hovorí vlastne, čo daná transakcia vidí tiež hovorí aké kontroly sa robia nad danou transakciou ak sú tieto kontroly porušené, transakcia sa zruší ostatné transakcie, ktoré ale mohli byť dôvodom zrušenia transakcie nie sú nijako dotknuté tiež nehovorí, či zmeny aktuálnej transakcie vidia iné transakcie to je dané ich úrovňou izolácie

101 Každá transakcia môže mať inú izolovanosť A serializable B read uncommited A vidí databázu pred B alebo po B B vidí zmeny aj počas toho ako ich A robí ak by sa malo stať niečo zlé, A bude zrušená

102 Zablokovanie Zablokovanie (Deadlock) dve transakcie čakajú na seba kvôli zámkom môže sa stať pri každej úrovni izolovanosti PostgreSQL deteguje zablokovania jednu transakciu zruší s chybou 40P01 deadlock_detected druhá pobeží ďalej Musíme byť pripravení zrušenú transakciu opätovne spustiť

103 Zablokovanie Zablokovanie Príklad (A1) BEGIN;

104 Zablokovanie Zablokovanie Príklad (A1) BEGIN; (B1) BEGIN;

105 Zablokovanie Zablokovanie Príklad (A1) BEGIN; (B1) BEGIN; (A2) UPDATE test SET x = 10 WHERE id = 1; --zamkne riadok 1 pre A

106 Zablokovanie Zablokovanie Príklad (A1) BEGIN; (B1) BEGIN; (A2) UPDATE test SET x = 10 WHERE id = 1; --zamkne riadok 1 pre A (B2) UPDATE test SET x = 10 WHERE id = 2; --zamkne riadok 2 pre B

107 Zablokovanie Zablokovanie Príklad (A1) BEGIN; (B1) BEGIN; (A2) UPDATE test SET x = 10 WHERE id = 1; --zamkne riadok 1 pre A (B2) UPDATE test SET x = 10 WHERE id = 2; --zamkne riadok 2 pre B (B3) UPDATE test SET x = 10 WHERE id = 1; --caka na A

108 Zablokovanie Zablokovanie Príklad (A1) BEGIN; (B1) BEGIN; (A2) UPDATE test SET x = 10 WHERE id = 1; --zamkne riadok 1 pre A (B2) UPDATE test SET x = 10 WHERE id = 2; --zamkne riadok 2 pre B (B3) UPDATE test SET x = 10 WHERE id = 1; --caka na A (A3) UPDATE test SET x = 10 WHERE id = 2; --caka na B

109 Zablokovanie Zablokovanie Príklad (A1) BEGIN; (B1) BEGIN; (A2) UPDATE test SET x = 10 WHERE id = 1; --zamkne riadok 1 pre A (B2) UPDATE test SET x = 10 WHERE id = 2; --zamkne riadok 2 pre B (B3) UPDATE test SET x = 10 WHERE id = 1; --caka na A (A3) UPDATE test SET x = 10 WHERE id = 2; --caka na B -- PostgreSQL deteguje deadlock, zrusi napr. transakciu A

110 Zablokovanie Zablokovanie Príklad (A1) BEGIN; (B1) BEGIN; (A2) UPDATE test SET x = 10 WHERE id = 1; --zamkne riadok 1 pre A (B2) UPDATE test SET x = 10 WHERE id = 2; --zamkne riadok 2 pre B (B3) UPDATE test SET x = 10 WHERE id = 1; --caka na A (A3) UPDATE test SET x = 10 WHERE id = 2; --caka na B -- PostgreSQL deteguje deadlock, zrusi napr. transakciu A -- Tym padom riadky zamknute pre A su odomknute

111 Zablokovanie Zablokovanie Príklad (A1) BEGIN; (B1) BEGIN; (A2) UPDATE test SET x = 10 WHERE id = 1; --zamkne riadok 1 pre A (B2) UPDATE test SET x = 10 WHERE id = 2; --zamkne riadok 2 pre B (B3) UPDATE test SET x = 10 WHERE id = 1; --caka na A (A3) UPDATE test SET x = 10 WHERE id = 2; --caka na B -- PostgreSQL deteguje deadlock, zrusi napr. transakciu A -- Tym padom riadky zamknute pre A su odomknute -- B moze pokracovat

112 Zablokovanie Zablokovanie Príklad (A1) BEGIN; (B1) BEGIN; (A2) UPDATE test SET x = 10 WHERE id = 1; --zamkne riadok 1 pre A (B2) UPDATE test SET x = 10 WHERE id = 2; --zamkne riadok 2 pre B (B3) UPDATE test SET x = 10 WHERE id = 1; --caka na A (A3) UPDATE test SET x = 10 WHERE id = 2; --caka na B -- PostgreSQL deteguje deadlock, zrusi napr. transakciu A -- Tym padom riadky zamknute pre A su odomknute -- B moze pokracovat (B4) COMMIT; -- riadky zamknute pre B su odomknute

113 Čo je to ACID Transakcie ACID Spomenuté vlastnosti transakcií sa označujú skratkou ACID: Atomicity Consistency Isolation Durability

114 Špeciality Transakcie Výnimočné správanie niektoré typy a funkcie majú výnimočné správanie voči transakciám

115 Špeciality Transakcie Dátum a čas CURRENT_TIME CURRENT_DATE CURRENT_TIMESTAMP vždy vráti čas/dátum začiatku transakcie čiže ich opätovné volanie v rámci transakcie vráti tú istú hodnotu transakcia je atomická, čiže akokeby zbehla v jednom okamihu platí pre všetky úrovne izolácie

116 Špeciality Transakcie Typ serial serial hodnota počítadla, ktoré je za ním je viditeľná okamžite všetkým transakciám nevzťahuje sa na neho rollback inač by vznikali kolízie

117 Špeciality Transakcie a príkazy na definíciu dát PostgreSQL v transakciách podporuje príkazy na úpravu štruktúry tabuliek (CREATE TABLE, ALTER TABLE,...) zmeny štruktúry tabuliek sú akceptované až príkazom COMMIT tým pádom vieme odvolať (rollback) aj pridanie, zmazanie stĺpca, vytvorenie, zmazanie tabuľky vhodné ako ochrana proti ľudskej chybe, keď robíme ručne nejaké zmeny Iné systémy nie všetky to podporujú pri prvom príkaze, ktorý mení štruktúru tabuľky (CREATE TABLE, ALTER TABLE,...) ukončia predchádzajúcu transakciu

118 Špeciality Koniec Koniec