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

Az előadások a következő témára: "Tranzakciók gyakorlati anyag PPKE-ITK, Database Systems, 2010."— Előadás másolata:

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

2 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) 2 Database Systems - Tranzakciók (gyakorlat) Pl. bank, wiki, jegyfoglalás, neptun, stb…

3 Elvárások tranzakciókezeléskor: ACID A  Atomosság ( A tomicity)  A tranzakció vagy teljes egészében, vagy egyáltalán ne hajtódjon végre. – helyreállító egység (recovery manager) C  Adatbázis helyessége ( C onsistency) (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 I  Elkülönítés ( I solation)  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ő) D  Tartósság( D urability)  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 3 Database Systems - Tranzakciók (gyakorlat)

4 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ó) T1T2T3 read(x) read(y) x:=x-Nx:=x+My:=y-O write(x) write(y) read(y) y:=y+N write(y) 4 Database Systems - Tranzakciók (gyakorlat)

5 Ü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, …  az ilyen mindig konzisztens  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… 5 Database Systems - Tranzakciók (gyakorlat)

6 Ütemezés – példa T1T2T3 read(x) read(y) x:=x-Nx:=x+My:=y-O write(x) write(y) read(y) y:=y+N write(y)  Mi lesz x és y, ha a kezdőértékek:  x=15; y=5; N=5; M=10; O=2 a) 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 b) 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 c) Egyéb sorrendben, ahol egymás után futnak le a tranzakciók? (soros)  végül mindig: x=20,y=8 d) És ha párhuzamosan, akkor veszítünk adatot?  lásd a következő ábrán: 6 Database Systems - Tranzakciók (gyakorlat)

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

8 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ó. 8 Database Systems - Tranzakciók (gyakorlat)

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

10 10

11 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. 11 Database Systems - Tranzakciók (gyakorlat)

12 12

13 Példa – Nézet ekvivalensek-e? T1T2T3 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) 13 Database Systems - Tranzakciók (gyakorlat) T1T2T3 read(X) 1 X:=X-N 2 3 read(X) 4 X:=X+M 5 write(X) write(X) 6 read(Y) 7 Y:=Y+N 8 write(Y) 9 read(y) y:=y-O write(y) S ütemezés S’ ütemezés Nem.

14 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 14 Database Systems - Tranzakciók (gyakorlat) N-E. K-E.

15 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) 15 Database Systems - Tranzakciók (gyakorlat)

16 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 1  Példa (1): 16 Database Systems - Tranzakciók (gyakorlat) T1T2 read(A) A := A – 50 write (A) read(B) B := B + 50 write(B) read(A) temp := A * 0.1 A := A – temp write(A) read(B) B := B + temp write(B)  A precedencia-gráfja:  Sorosítható-e?  Sorosítható. T1T2 A, B

17 Database Systems - Tranzakciók (gyakorlat) 17

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

19 Database Systems - Tranzakciók (gyakorlat) 19

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

21 Példák megelőzési gráfra (4) 21 Database Systems - Tranzakciók (gyakorlat)  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 T4T5 T6 T7

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

23 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. 23 Database Systems - Tranzakciók (gyakorlat)

24 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 24 Database Systems - Tranzakciók (gyakorlat)

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

26 Példa – zárolási technikára – 2. 26 Database Systems - Tranzakciók (gyakorlat) Határozd meg a lockokat a következő ütemezésben:

27 Kétfázisú zárolási protokoll 27 Database Systems - Tranzakciók (gyakorlat)  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

28 28 Database Systems - Tranzakciók (gyakorlat) Kétfázisú zárolási protokoll T1T2 lock-s(Y)lock-s(X) read(Y)read(X) lock-x(X)lock-x(Y) lock-x(Z) unlock(Y)unlock(X) read(X)read(Y) X:=X+YY:=X+Y Z:=X-Y write(X)write(Y) write(Z) unlock(X)unlock(Y) unlock(Z) Growing Phase: Shrinking Phase: MJ: Tranzakciónként külön kell megállapítani a két fázist! Growing Phase Shrinking Phase

29 Database Systems - Tranzakciók (gyakorlat) Add locks, unlocks, denote the two phase! 29

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

31  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. 31 Database Systems - Tranzakciók (gyakorlat) Példa 1. – Kétfázisú zárolási protokoll Growing Phase: Shrinking Phase:

32 32 Database Systems - Tranzakciók (gyakorlat) 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. Growing Phase: Shrinking Phase:

33 09-05-11Database Systems - Tranzakciók (gyakorlat) 33

34 Database Systems - Tranzakciók (gyakorlat) 34

35 35 Database Systems - Tranzakciók (gyakorlat)  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 Időbélyegzési technika, TimeStamping

36 Szabályok – Időbélyegzési technika 1. Legyen Tj tranzakció, mely read(X) műveletet szeretne a)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) ‏ b)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 a)Ha TS(Tj) < W-timestamp(X), akkor Tj egy elavult adatot írna, így ezt a write- ot elutasítjuk (+Tj rollback) ‏ b)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) ‏ c)Egyébként az írás végrehajtódik, és W-timestamp(X) értékét TS(Tj)-re állítjuk 36 Database Systems - Tranzakciók (gyakorlat)

37 Szabályok – Időbélyegzési technika 1. Legyen Tj tranzakció, mely read(X) műveletet szeretne a)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) ‏ b)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 a)Ha TS(Tj) < W-timestamp(X), akkor Tj egy elavult adatot írna, így ezt a write-ot elutasítjuk (+Tj rollback) ‏ b)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) ‏ c)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. 37 Database Systems - Tranzakciók (gyakorlat)

38 Példa 1. 38 Database Systems - Tranzakciók (gyakorlat)

39 Példa 1. – 1. lépés RTS(X)=null WTS(X)=null TS(T2)=2 1. b) szabály RTS(X)= 2 39 Database Systems - Tranzakciók (gyakorlat)

40 Példa 1. – 2. lépés RTS(Z)=null WTS(Z)=null TS(T3)=3 2. c) szabály RTS(X)=2 WTS(Z)= 3 40 Database Systems - Tranzakciók (gyakorlat)

41 Példa 1. – 3. lépés RTS(X)=2 WTS(X)=null TS(T1)=1 1. b) szabály WTS(Z)=3 TS(T1) ? RTS(X) ‏ 1 < 2 RTS(X)=2 41 Database Systems - Tranzakciók (gyakorlat)

42 Példa 1. – 4. lépés RTS(X)=2 WTS(X)=null TS(T4)=4 1. b) szabály WTS(Z)=3 TS(T4) ? RTS(X) ‏ 4 > 2 RTS(X)=4 RTS(X)=2 42 Database Systems - Tranzakciók (gyakorlat)

43 Példa 1. – 5. lépés RTS(X)=4 WTS(X)=null TS(T3)=3 1. b) szabály WTS(Z)=3 TS(T3) ? RTS(X) ‏ 3 < 4 RTS(X)=2 RTS(X)=4 RTS(X)=2 RTS(X)=4 43 Database Systems - Tranzakciók (gyakorlat)

44 Példa 1. – 6. lépés RTS(Y)=null WTS(Y)=null TS(T2)=2 2. c) szabály WTS(Z)=3 RTS(X)=2 WTS(Y)= 2 RTS(X)=2 RTS(X)=4 44 Database Systems - Tranzakciók (gyakorlat)

45 Példa 1. – 7. lépés RTS(Y)=null WTS(Y)=2 TS(T4)=4 1. b) szabály WTS(Z)=3 RTS(X)=2 RTS(Y)=4 RTS(X)=2 RTS(X)=4 WTS(Y)=2 1. read-kérdés: TS(T4) ? WTS(Y) ‏ 4 > 2 45 Database Systems - Tranzakciók (gyakorlat)

46 Példa 1. – 8. lépés RTS(Z)=null WTS(Z)=3 TS(T2)=2 1. a) szabály WTS(Z)=3 RTS(X)=2 T2 abortál + rollback: WTS(Y):=null RTS(X)=2 RTS(X)=4 WTS(Y)=2 RTS(Y)=4 1. read-kérdés: TS(T2) ? WTS(Z) ‏ 2 < 3 46 Database Systems - Tranzakciók (gyakorlat)

47 Példa 1. – 9. lépés RTS(X)=4 WTS(X)=null TS(T1)=1 2. b) szabály WTS(Z)=3 RTS(X)=2 T1 abortál (+ rollback: nincs mit) RTS(X)=2 RTS(X)=4 WTS(Y)=2 2. write-kérdés: TS(T1) ? RTS(X) ‏ 1 < 4 RTS(Y)=4 47 Database Systems - Tranzakciók (gyakorlat)

48 Példa 1. – 10. lépés RTS(X)=4 WTS(X)=null TS(T5)=5 WTS(Z)=3 RTS(X)=2 RTS(X)=4 RTS(Y)=4 1. b) szabály TS(T5) ? RTS(X) ‏ 5 > 4 RTS(X)=5 48 Database Systems - Tranzakciók (gyakorlat)

49 Példa 1. – 11. lépés RTS(Y)=4 WTS(Y)= 2 null TS(T3)=3 WTS(Z)=3 RTS(X)=2 RTS(X)=4 RTS(Y)=4 1. b) szabály TS(T3) ? RTS(Y) ‏ 3 < 4 RTS(Y)=4 RTS(X)=5 1. read-kérdés: TS(T3) ? WTS(Y) ‏ 3 > null 49 Database Systems - Tranzakciók (gyakorlat)

50 50 Példa 1. – 12. lépés WTS(Z)=3 RTS(X)=2 RTS(X)=4 WTS(Y)=2 RTS(Y)=4 2.c) szabály WTS(Y)= 5 RTS(X)=5 2. write-kérdés: TS(T5) ? WTS(Y) ‏ 5 > null TS(T5) ? RTS(Y) ‏ 5 > 4 RTS(Y)=4 Database Systems - Tranzakciók (gyakorlat) RTS(Y)=4 WTS(Y)= 2 null TS(T5)=5

51 51 Példa 1. – 13. lépés RTS(Y)=4 WTS(Y)=5 TS(T4)=4 WTS(Z)=3 RTS(X)=2 RTS(X)=4 WTS(Y)=2 RTS(Y)=4 2.b) szabály RTS(X)=5 2. write-kérdés: TS(T4) ? WTS(Y) ‏ 4 < 5 RTS(Y)=4 WTS(Y)=5 T4 abortál + rollback: RTS(Y):=3 Database Systems - Tranzakciók (gyakorlat) RTS(Y)=3

52 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ó. 52 Database Systems - Tranzakciók (gyakorlat)

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

54 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 54 Database Systems - Tranzakciók (gyakorlat)

55 Példa 2. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. write(Z) ‏ write(Y) ‏ write(Z) ‏ read(X) ‏ read(Z) ‏ write(Z) ‏ write(Y) ‏ read(Y) ‏ read(X) ‏T5T4T3T2T1 55 Database Systems - Tranzakciók (gyakorlat)

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