Tranzakciók gyakorlati anyag PPKE-ITK, Database Systems, 2009.

Database Systems - Tranzakciók (gyakorlat) Definíció: tranzakciók Olyan program-végrehajtási egységek, amik az adatbázison valamilyen műveleteket végeznek. olvasás: vö. SELECT, X: adattagon read(X) írás, törlés, módosítás: vö. INSERT, DELETE, UPDATE  write(X) Database Systems - Tranzakciók (gyakorlat) 2

Database Systems - Tranzakciók (gyakorlat) Elvárások tranzakciókezeléskor: ACID Atomosság (Atomicity) A tranzakció vagy teljes egészében, vagy egyáltalán ne hajtódjon végre. – helyreállító egység (recovery manager) Adatbázis helyessége (Consistency) (konzisztencia, következetesség) A tranzakció hatására az adatbázis a kezdeti konzisztens állapotból egy másik konzisztens állapotba jut. – programozó feladata Elkülönítés (Isolation) A tranzakció befejeződése után az adatbázis állapota csak olyan lehet, mintha a tranzakció egyedül futott volna, nem párhuzamosan a többivel. – tranzakció kezelő (ütemező) Tartósság(Durability) A tranzakció befejeződése után annak eredménye nem veszhet el, be kell jegyezni az adatbázisba. – tranzakció kezelő (ütemező), helyreállító egység Database Systems - Tranzakciók (gyakorlat) 3

Database Systems - Tranzakciók (gyakorlat) Tranzakció példa – sörösüvegek x: kamrában lévő üvegek száma (adattag) y: hűtőben lévő üvegek száma (adattag) T1: a kamrából N db-ot átteszek a hűtőbe (tranzakció) T2: apu hozott M db üveggel a kamrába (tranzakció) T3: megiszunk O db üveggel a hűtőből (tranzakció) T1 T2 T3 read(x) read(y) x:=x-N x:=x+M y:=y-O write(x) write(y) y:=y+N Database Systems - Tranzakciók (gyakorlat) 4

Database Systems - Tranzakciók (gyakorlat) Ütemezés (Scheduling) Olyan szekvenciák, amik megmutatják az időbeli sorrendjét az egyidejűleg futó tranzakciók műveleteinek Soros ütemezés: egymás után futnak le a tranzakciók T1, T2, T6, T3, … Párhuzamos ütemezés: egyszerre több tranzakció fut párhuzamosan egy tranzakció egyik művelete megelőzhet, egy másik művelete követheti egy másik tranzakció egy műveletét… Database Systems - Tranzakciók (gyakorlat) 5

Database Systems - Tranzakciók (gyakorlat) read(x) read(y) x:=x-N x:=x+M y:=y-O write(x) write(y) y:=y+N Ütemezés – példa Mi lesz x és y, ha a kezdőértékek: x=15; y=5; N=5; M=10; O=2 Ha T1 lefut, majd T2 és T3? (soros ütemezés) T1 után x=10,y=10, T2 után x=20,y=10, T3 után x=20,y=8 Ha T2 fut le először, majd T3 és végül T1? (soros) T2 után x=25,y=5, T3 után x=25,y=3, T1 után x=20,y=8 Egyéb sorrendben, ahol egymás után futnak le a tranzakciók? (soros) végül mindig: x=20,y=8 És ha párhuzamosan, akkor veszítünk adatot? lásd a következő ábrán: Database Systems - Tranzakciók (gyakorlat) 6

Database Systems - Tranzakciók (gyakorlat) Párhuzamos ütemezés – példa T1 T2 T3 read(x) x:=x-N x:=x+M write(x) read(y) y:=y+N y:=y-O write(y) Kezdőértékek: x=15; y=5; N=5; M=10; O=2 x=25, y=3 igen veszítünk adatot, mivel az x és y változok sem lesznek kiírva a következő olvasás előtt Veszítünk adatot? Database Systems - Tranzakciók (gyakorlat) 7

Database Systems - Tranzakciók (gyakorlat) Konfliktus, ekvivalencia, sorosíthatóság Conflicting tranzakciók: azok a tranzakciók, amelyek ugyanazon az adattagon dolgoznak, és legalább az egyik írni szeretné Ha egy S ütemezés átalakítható egy S’ ütemezésre non-conflicting műveletek cseréjével, akkor: S és S’ konfliktus ekvivalens. Két művelet non-conflicting: Ha különböző adattagon dolgoznak, vagy ha ugyanazon, de mindkettő csak olvassa.   Ha egy S ütemezés konfliktus ekvivalens egy S’ soros ütemezéssel, akkor az S ütemezés konfliktus sorosítható. Database Systems - Tranzakciók (gyakorlat) 8

Database Systems - Tranzakciók (gyakorlat) Konfliktus-ekvivalencia – példa Konfliktus-ekvivalens, konfliktus sorosítható: T1 T2 T3 read(x) write(x) read(y) write(y) T1 T2 T3 read(x) write(x) read(y) write(y) Database Systems - Tranzakciók (gyakorlat) 9 9

Database Systems - Tranzakciók (gyakorlat) Nézet ekvivalencia – definíció Legyen S és S’ két ütemezés ugyanazon tranzakciós műveletekkel. Ezek nézet ekvivalensek, ha: minden X adatelemre, ha Ti olvassa S-ben X- kezdőértékét, akkor S’-ben is ugyanúgy kell olvasnia Ti-nek X kezdőértékét ÉS minden X adatelemre, ha Ti S-ben olvassa X-et, amely X egy létező Tj tranzakciótól származik, akkor Ti-nek S’ ütemezésben ugyanúgy egy létező Tj által adott értéket kell olvasnia, ÉS minden X adatelemre, ha egy tranzakció S-ben az utolsó write(X) utasítást hajtja végre, akkor S’-ben ugyancsak write(X)-et kell csinálnia. Database Systems - Tranzakciók (gyakorlat) 10

Database Systems - Tranzakciók (gyakorlat) Példa – Nézet ekvivalensek-e? S ütemezés S’ ütemezés T1 T2 T3 read(X) 1 X:=X-N 2 3 read(X) 4 X:=X+M write(X) 5 Read(Y) 6 7 write(X) Y:=Y+N 8 write(Y) 9 read(y) y:=y-O write(y) T1 T2 T3 read(X) 1 X:=X+M 2 3 read(X) 4 X:=X-N 5 write(X) write(X) 6 read(Y) 7 Y:=Y+N 8 write(Y) 9 read(y) y:=y-O write(y) Database Systems - Tranzakciók (gyakorlat) 11

Database Systems - Tranzakciók (gyakorlat) Nézet és konfliktus ekvivalencia Ami konfliktus ekvivalens, az nézet ekvivalens is. Ami nézet ekvivalens, az nem biztos, hogy konfliktus ekvivalens is. Pl.: vakonírás N-E. K-E. Database Systems - Tranzakciók (gyakorlat) 12

Database Systems - Tranzakciók (gyakorlat) Sorosíthatóság eldöntése, biztosítása megelőzési gráf (gyakorlatban nem alkalmas) különböző protokollok kétfázisú protokoll időbélyegzési protokoll (timestamping) Database Systems - Tranzakciók (gyakorlat) 13

Database Systems - Tranzakciók (gyakorlat) Megelőzési (precedencia) gráf irányított gráf, melynek csúcsai maguk a tranzakciók, élei: (~ a conflicting műveleteknél:) TiTk között fut él, ha Ti ugyanazt az adatot írta, amit Tk olvasni fog TiTk ---------------| | --------------- olvasta -----| |---- írni fog TiTk ---------------| | --------------- írta -----| |---- írni fog Példa (1): T1 T2 read(A) A := A – 50 write (A) read(B) B := B + 50 write(B) temp := A * 0.1 A := A – temp write(A) B := B + temp A precedencia-gráfja: Sorosítható-e? Sorosítható. T1 T2 Database Systems - Tranzakciók (gyakorlat) 14

Database Systems - Tranzakciók (gyakorlat) Példák megelőzési gráfra (2) T1 T2 T3 T4 read(A) read(B) write(A) read(C) write(B) T1 T2 T3 T4 Sorosítható-e? Igen. Ha a gráf körmentes, akkor sorosítható. Database Systems - Tranzakciók (gyakorlat) 15

Database Systems - Tranzakciók (gyakorlat) Példák megelőzési gráfra (3) T1 T2 read(A) A := A – 50 temp := A * 0.1 A := A – temp write(A) read(B) write (A) B := B + 50 write(B) B := B + temp T1 T2 Nem körmentes, ezért nem sorosítható. Database Systems - Tranzakciók (gyakorlat) 16

Database Systems - Tranzakciók (gyakorlat) Példák megelőzési gráfra (4) Döntse el a gráf alapján, hogy sorosítható-e? Ha igen, adjon meg legalább két sorrendet! Sorosítható. Megoldások pl: T1-T2-T3-T4-T5-T6-T7 T1-T2-T3-T5-T4-T6-T7 T1 T2 T3 T4 T5 T6 T7 Database Systems - Tranzakciók (gyakorlat) 17

Database Systems - Tranzakciók (gyakorlat) Példák megelőzési gráfra (5) T1 T2 T3 T4 T5 T6 T7 T8 T9 Megoldás: Nem körmentes! T4-T5-T3-T6-T8-T7-T4 Database Systems - Tranzakciók (gyakorlat) 18

Database Systems - Tranzakciók (gyakorlat) Zárolási technikák (Locking) Minden adatelemhez hozzárendelünk egy állapotjelzőt, amivel megadjuk,hogy mire használhatjuk az adatot, vagy, hogy használhatjuk-e. lock(X): a tranzakció lock-ol egy adatot, így azt addig nem érheti el semmilyen tranzakció unlock(X): lock feloldása ha csak ezeket használjuk, nem lesz optimális a rendszerünk teljesítménye.  vezessünk be új lock-okat lock-x(X): exclusive lock : csak az adott tranzakció által használható az adat, mindenki más számára hozzáférhetetlen lock-s(X): shared lock: (~ read only) mindegyik tranzakció csak olvashatja őt. Database Systems - Tranzakciók (gyakorlat) 19

Database Systems - Tranzakciók (gyakorlat) Zárolási technikák (Locking) (folyt.) és tételezzük fel ezekről a lockokról, hogy: a tranzakciónak kötelezően mindig küldenie kell egy kérelmet (request), ha írni/olvasni akar egye adatelemet ha már nincs szüksége az adatelemre, unlockolja a tranzakció nem lockolja, ha már egyszer őnála van ugyanígy, ne unlockolja, ha nincs nála Database Systems - Tranzakciók (gyakorlat) 20

Példa – zárolási technikára – 1. lock-x(x) lock-s(y) read(x) read(y) X:=X-Y/2 unlock(y) write(x) lock-x(y) unlock(x) Y:=Y+X write(y) X=20, Y=10 Ütemezés: T1, T2 Eredmény:X=15, Y=25 Ütemezés: T2, T1 Eredmény:X= 5, Y=30 Database Systems - Tranzakciók (gyakorlat) 21

Példa – zárolási technikára – 2. Határozd meg a lockokat a következő ütemezésben: T1 T2 lock-X(B) read(B) B := B 50 write(B) unlock(B) lock-S(A) read(A) unlock(A) lock-S(B) lock-X(A) A := A + 50 write(A) T1 T2 read(B) B := B-50 write(B) read(A) A := A+50 write(A) Database Systems - Tranzakciók (gyakorlat) 22

Kétfázisú zárolási protokoll Növekvő (growing) fázis: ebben a fázisban kell minden lock-ot kiadnia a tranzakciónak Csökkenő (shrinking) fázis: a zárolások feloldhatók, de új zárolás már semmiképp sem adható ki ebben a fázisban Database Systems - Tranzakciók (gyakorlat) 23

Kétfázisú zárolási protokoll lock-s(Y) lock-s(X) read(Y) read(X) lock-x(X) lock-x(Y) lock-x(Z) unlock(Y) unlock(X) X:=X+Y Y:=X+Y Z:=X-Y write(X) write(Y) write(Z) unlock(Z) Growing Phase: Shrinking Phase: Database Systems - Tranzakciók (gyakorlat) 24

Kétfázisú zárolási protokoll tétele A kétfázisú protokoll szerint futó tranzakciók tetszőleges ütemezése sorbarendezhető. Database Systems - Tranzakciók (gyakorlat) 25

Példa 1. – Kétfázisú zárolási protokoll Lefut-e az alábbi összefésült kétfázisú ütemezés? Mi lesz a végeredmény A=100, B=20 esetén? Jelöld be a fázisokat! Megoldás: Dead-Lock a lock-x(B)—lock-s(A)— lock-s(B)—lock-x(A) miatt. T1 T2 lock-X(B) lock-S(A) read(B) read(A) lock-X(A) lock-S(B) B := B 50 unlock(A) write(B) unlock(B) A := A + 50 write(A) Growing Phase: Shrinking Phase: Database Systems - Tranzakciók (gyakorlat) 26

Példa 2. – Kétfázisú zárolási protokoll Lefut-e az alábbi összefésült kétfázisú ütemezés? Mi lesz a végeredmény A=100, B=20 esetén? Jelöld be a fázisokat! Megoldás: Igen, lefut. A végeredmény: A=70, B=20 lesz. T1 T2 lock-X(A) read(A) lock-S(B) read(B) unlock(B) A := A + B - 50 write(A) unlock(A) Growing Phase: Shrinking Phase: Database Systems - Tranzakciók (gyakorlat) 27

Időbélyegzési technika, TimeStamping Példa: bankautomata, tranzakciószám, stb… Minden tranzakció kap egy időbélyeget: TS(Ti): i a tranzakció fiatalságát jelenti kisebb TS ~ öregebb! (vö. szül. évszám…) Minden adat is kap egy írási és egy olvasási időbélyeget: read-timestamp: RTS(X) – X az adat write-timestamp: WTS(X) – X az adat lényegében legutóbb/legfiatalabbként kiolvasó/beíró tranzakció TS-je mindig a fiatalabb van előnyben, ha az öregebb akar olvasni, az elavult Database Systems - Tranzakciók (gyakorlat) 28

Szabályok – Időbélyegzési technika 1. Legyen Tj tranzakció, mely read(X) műveletet szeretne Ha TS(Tj) < W-timestamp(X), akkor Tj X-nek olyan értékét olvasná ki, amit már fölülírtak azóta, így ezt a read-et elutasítjuk (+Tj rollback)‏ Ha TS(Tj) ≥ W-timestamp(X), akkor megtörténik az olvasás, és a R- timestamp(X) értékét az R-timestamp(X) és a TS(Tj) közül a legnagyobb értékére állítjuk max{r-timestamp(x),TS(Ti)} 2. Legyen Tj tranzakció olyan, mely write(X) műveletet hajtana végre Ha TS(Tj) < W-timestamp(X), akkor Tj egy elavult adatot írna, így ezt a write- ot elutasítjuk (+Tj rollback)‏ Ha TS(Tj) < R-timestamp(X), akkor Tj olyanra állítaná be X-et, amit azóta már kiolvastak, így ezt a write-ot elutasítjuk (+Tj rollback)‏ Egyébként az írás végrehajtódik, és W-timestamp(X) értékét TS(Tj)-re állítjuk Database Systems - Tranzakciók (gyakorlat) 29

Szabályok – Időbélyegzési technika 1. Legyen Tj tranzakció, mely read(X) műveletet szeretne Ha TS(Tj) < W-timestamp(X), akkor Tj X-nek olyan értékét olvasná ki, amit már fölülírtak azóta, így ezt a read-et elutasítjuk (+Tj rollback)‏ Ha TS(Tj) ≥ W-timestamp(X), akkor megtörténik az olvasás, és a R-timestamp(X) értékét az R-timestamp(X) és a TS(Tj) közül a legnagyobb értékére állítjuk max{r-timestamp(x),TS(Ti)} 2. Legyen Tj tranzakció olyan, mely write(X) műveletet hajtana végre Ha TS(Tj) < W-timestamp(X), akkor Tj egy elavult adatot írna, így ezt a write-ot elutasítjuk (+Tj rollback)‏ Ha TS(Tj) < R-timestamp(X), akkor Tj olyanra állítaná be X-et, amit azóta már kiolvastak, így ezt a write-ot elutasítjuk (+Tj rollback)‏ Egyébként az írás végrehajtódik, és W-timestamp(X) értékét TS(Tj)-re állítjuk Thomas’ Writing Rule: 2. a) ~vakoníráskor: Tj-ben write(X) igény => ha RTS(X) < TS(Tj) < WTS(X), akkor a write(X) művelet nem futhat le, de a tranzakció folytatódhat, mégsincs abort és rollback. Database Systems - Tranzakciók (gyakorlat) 30

Database Systems - Tranzakciók (gyakorlat) Példa 1. write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 Database Systems - Tranzakciók (gyakorlat) 31

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 1. lépés RTS(X)=null WTS(X)=null write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 TS(T2)=2 1. b) szabály RTS(X)=2 Database Systems - Tranzakciók (gyakorlat) 32

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 2. lépés RTS(Z)=null WTS(Z)=null TS(T3)=3 write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 2. c) szabály WTS(Z)=3 Database Systems - Tranzakciók (gyakorlat) 33

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 3. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 WTS(X)=null TS(T1)=1 RTS(X)=2 WTS(Z)=3 1. b) szabály TS(T1) ? RTS(X)‏ 1 < 2 RTS(X)=2 Database Systems - Tranzakciók (gyakorlat) 34

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 4. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 WTS(X)=null TS(T4)=4 RTS(X)=2 WTS(Z)=3 RTS(X)=2 1. b) szabály TS(T4) ? RTS(X)‏ 4 > 2 RTS(X)=4 Database Systems - Tranzakciók (gyakorlat) 35

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 5. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 RTS(X)=4 WTS(X)=null TS(T3)=3 WTS(Z)=3 RTS(X)=2 1. b) szabály RTS(X)=4 TS(T3) ? RTS(X)‏ 3 < 4 RTS(X)=4 Database Systems - Tranzakciók (gyakorlat) 36

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 6. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 WTS(Z)=3 RTS(X)=2 RTS(Y)=null WTS(Y)=null TS(T2)=2 RTS(X)=4 RTS(X)=4 2. c) szabály WTS(Y)=2 Database Systems - Tranzakciók (gyakorlat) 37

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 7. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 RTS(Y)=null WTS(Y)=2 TS(T4)=4 WTS(Z)=3 RTS(X)=2 RTS(X)=4 1. read-kérdés: TS(T4) ? WTS(Y)‏ 4 > 2 RTS(X)=4 WTS(Y)=2 1. b) szabály RTS(Y)=4 Database Systems - Tranzakciók (gyakorlat) 38

+ rollback: WTS(Y):=null Példa 1. – 8. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 WTS(Z)=3 RTS(Z)=null WTS(Z)=3 TS(T2)=2 RTS(X)=2 RTS(X)=4 RTS(X)=4 1. read-kérdés: TS(T2) ? WTS(Z)‏ 2 < 3 WTS(Y)=2 RTS(Y)=4 1. a) szabály T2 abortál + rollback: WTS(Y):=null Database Systems - Tranzakciók (gyakorlat) 39

Példa 1. – 9. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 WTS(Z)=3 RTS(X)=2 RTS(X)=4 WTS(X)=null TS(T1)=1 RTS(X)=4 RTS(X)=4 WTS(Y)=2 2. write-kérdés: TS(T1) ? RTS(X)‏ 1 < 4 RTS(Y)=4 2. b) szabály T1 abortál (+ rollback: nincs mit) Database Systems - Tranzakciók (gyakorlat) 40

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 10. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 WTS(Z)=3 RTS(X)=2 RTS(X)=4 RTS(X)=4 RTS(X)=4 WTS(X)=null TS(T5)=5 RTS(Y)=4 1. b) szabály TS(T5) ? RTS(X)‏ 5 > 4 RTS(X)=5 Database Systems - Tranzakciók (gyakorlat) 41

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 11. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 WTS(Z)=3 RTS(X)=2 RTS(X)=4 RTS(Y)=4 WTS(Y)= 2 null TS(T3)=3 RTS(X)=4 RTS(Y)=4 1. read-kérdés: TS(T3) ? WTS(Y)‏ 3 > null RTS(X)=5 1. b) szabály TS(T3) ? RTS(Y)‏ 3 < 4 RTS(Y)=4 Database Systems - Tranzakciók (gyakorlat) 42

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 12. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 WTS(Z)=3 RTS(X)=2 RTS(X)=4 RTS(Y)=4 WTS(Y)= 2 null TS(T5)=5 RTS(X)=4 WTS(Y)=2 2. write-kérdés: TS(T5) ? WTS(Y)‏ 5 > null TS(T5) ? RTS(Y)‏ 5 > 4 RTS(Y)=4 RTS(X)=5 RTS(Y)=4 2.c) szabály WTS(Y)=5 Database Systems - Tranzakciók (gyakorlat) 43

Database Systems - Tranzakciók (gyakorlat) Példa 1. – 13. lépés write(Y)‏ 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. read(Y)‏ read(X)‏ write(X)‏ read(Z)‏ write(Z)‏ T5 T4 T3 T2 T1 RTS(X)=2 WTS(Z)=3 RTS(X)=2 RTS(X)=4 RTS(X)=4 RTS(Y)=4 WTS(Y)=5 TS(T4)=4 WTS(Y)=2 RTS(Y)=4 2. write-kérdés: TS(T4) ? WTS(Y)‏ 4 < 5 RTS(X)=5 RTS(Y)=4 RTS(Y)=3 2.b) szabály WTS(Y)=5 T4 abortál + rollback: RTS(Y):=3 Database Systems - Tranzakciók (gyakorlat) 44

Database Systems - Tranzakciók (gyakorlat) Példa 1. – Thomas szabály? Hogyan változna a lefutás, ha engedélyeznénk a Thomas írási szabályt? A 13. lépésben write(Y)-igény van, RTS(Y)=4, WTS(Y)=5, TS(T4)=4 TS(T4)=4 < 5=WTS(Y) ütközik, de TS(T4)=4 = 4=RTS(Y) nem, ezért a Thomas szabály értelmében nem fog lefutni ez a write(Y), viszont a T4 nem abortál, folytatódhat a tranzakció. Database Systems - Tranzakciók (gyakorlat) 45

Példa 1. 13. – lépés Thomas szabállyal read(X) 2. write(Z) 3. 4. 5. 6. write(Y) 7. read(Y) 8. read(Z) 9. write(X) 10. 11. 12. 13. RTS(X)=2 RTS(Y)=4 WTS(Y)=5 TS(T4)=4 WTS(Z)=3 RTS(X)=2 2. write-kérdés: TS(T4) ? WTS(Y) 4 < 5 RTS(X)=4 RTS(X)=4 WTS(Y)=2 2.b) szabály RTS(Y)=4 ( ) T4 abortálna + rollback RTS(X)=5 Thomas’ Writing Rule: RTS(Y) ≤ TS(T4) < WTS(Y) 4 ≤ 4 < 5 RTS(Y)=4 WTS(Y)=5 write(Y) nem hajtódik végre, DE T4 folytatódhat! …

Database Systems - Tranzakciók (gyakorlat) Példa 1. – végeredmény T3 és T5 tranzakció marad meg X: read-ts(x)= 5 write-ts(x)= null (abort miatt) Y: read-ts(y)=3, Thomas’Rule-lal 4 marad. write-ts(y)=5 Z: read-ts(z)= null write-ts(z)=3 Database Systems - Tranzakciók (gyakorlat) 47

Database Systems - Tranzakciók (gyakorlat) Példa 2. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. write(Z)‏ write(Y)‏ read(X)‏ read(Z)‏ read(Y)‏ T5 T4 T3 T2 T1 Database Systems - Tranzakciók (gyakorlat) 48

Database Systems - Tranzakciók (gyakorlat) Példa 2. – HF. Mely tranzakciók abortálódnak? Mik az adattagok időbélyegei? Alkalmazható-e a Thomas writing rule? Database Systems - Tranzakciók (gyakorlat) 49