Tranzakciók gyakorlati anyag

Tranzakciókgyakorlati anyag

PPKE-ITK, Database Systems, 2009.

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)

2Database 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 3Database 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(x) read(y)x:=x-N x:=x+M y:=y-Owrite(x) write(x) write(y)read(y)y:=y+Nwrite(y)


Ü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…


Ütemezés – példaT1 T2 T3

read(x) read(x) read(y)x:=x-N x:=x+M y:=y-Owrite(x) write(x) write(y)read(y)y:=y+Nwrite(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=8b) 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=8d) És ha párhuzamosan, akkor veszítünk adatot?

lásd a következő ábrán: 6Database Systems - Tranzakciók (gyakorlat)

Párhuzamos ütemezés – példaT1 T2 T3

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


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

(gyakorlat)

Konfliktus-ekvivalencia – példa Konfliktus-ekvivalens, konfliktus sorosítható:

T1 T2 T3read(x)write(x)

read(x)read(y)

write(x)write(y)

read(y)write(y)

T1 T2 T3read(x)write(x)read(y)write(y)

read(x)write(x)

read(y)write(y)


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.


Példa – Nézet ekvivalensek-e?T1 T2 T3

read(X) 1X:=X-N 2

3 read(X)4 X:=X+M

write(X) 5Read(Y) 6

7 write(X)Y:=Y+N 8write(Y) 9

read(y)y:=y-Owrite(y)


T1 T2 T3read(X) 1X:=X+M 2

3 read(X)4 X:=X-N5 write(X)

write(X) 6read(Y) 7Y:=Y+N 8write(Y) 9

read(y)y:=y-Owrite(y)

S ütemezés S’ ütemezés

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.

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)


Megelőzési (precedencia) gráf irányított gráf, melynek csúcsai maguk a

tranzakciók, élei: (~ a conflicting műveleteknél:)

TiTk között fut él, ha Ti ugyanazt az adatot írta, amit Tk olvasni fog

TiTk ---------------| | --------------- olvasta -----| |---- írni fog

TiTk ---------------| | --------------- írta -----| |---- írni fog

Példa (1):


T1 T2read(A)

A := A – 50write (A)read(B)

B := B + 50write(B)

read(A)temp := A * 0.1A := A – temp

write(A)read(B)

B := B + tempwrite(B)

A precedencia-gráfja:

Sorosítható-e? Sorosítható.

T1 T2

Példák megelőzési gráfra (2)T1 T2 T3 T4

read(A)

read(B)

write(A)

read(C)

write(B)

read(C)

read(B)


T1 T2

T3 T4

Sorosítható-e?- Igen.

Ha a gráf körmentes, akkor sorosítható.

Példák megelőzési gráfra (3)


Nem körmentes, ezért nem sorosítható.

T1 T2read(A)

A := A – 50

read(A)temp := A * 0.1

A := A – tempwrite(A)

read(B)

write (A)read(B)

B := B + 50write(B)

B := B + tempwrite(B)

T1 T2



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-T7T1-T2-T3-T5-T4-T6-T7

T1 T2 T3

T4 T5 T6

T7



T1 T2 T3

T4 T5 T6

T7 T8

T9

Megoldás:Nem körmentes! T4-T5-T3-T6-T8-T7-T4

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. 19Database 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


Példa – zárolási technikára – 1.

X=20, Y=10Ütemezés: T1, T2 Eredmény:X=15, Y=25Ütemezés: T2, T1 Eredmény:X= 5, Y=30


T1 T2lock-x(x) lock-s(y)

read(x) read(y)X:=X-Y/2 unlock(y)write(x) lock-x(y)

unlock(x) read(y)lock-s(y) Y:=Y+Xread(y) write(y)

unlock(y) unlock(y)

Példa – zárolási technikára – 2.


T1 T2read(B)

B := B-50write(B)

read(A)read(B)

read(A)A := A+50

write(A)

Határozd meg a lockokat a következő ütemezésben: T1 T2

lock-X(B)read(B)

B := B 50write(B)

unlock(B)lock-S(A)

read(A)unlock(A)lock-S(B)

read(B)unlock(B)

lock-X(A)read(A)

A := A + 50write(A)

unlock(A)

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


Kétfázisú zárolási protokollT1 T2

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+Y Y:=X+Y

Z:=X-Ywrite(X) write(Y)

write(Z)unlock(X) unlock(Y)

unlock(Z)

Growing Phase:

Shrinking Phase:

Tétel: A kétfázisú protokoll szerint futó tranzakciók

tetszőleges ütemezése sorbarendezhető.


Kétfázisú zárolási protokoll tétele

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 T2lock-X(B) lock-S(A)

read(B) read(A)lock-X(A) lock-S(B)

read(A) read(B)B := B 50 unlock(A)write(B) unlock(B)

unlock(B)A := A + 50

write(A)unlock(A)


Példa 1. – Kétfázisú zárolási protokoll

Growing Phase:

Shrinking Phase:

T1 T2lock-X(A)

read(A)lock-S(B)

read(B)lock-S(B)

read(B)unlock(B

)A := A + B -

50write(A)

unlock(A)


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:


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

Szabályok – Időbélyegzési technika1. 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

c)Ha TS(Tj) < W-timestamp(X), akkor Tj egy elavult adatot írna, így ezt a write-ot elutasítjuk (+Tj rollback)

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

e)Egyébként az írás végrehajtódik, és W-timestamp(X) értékét TS(Tj)-re állítjuk


Szabályok – Időbélyegzési technika1. 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égrec) Ha TS(Tj) < W-timestamp(X), akkor Tj egy elavult adatot írna, így

ezt a write-ot elutasítjuk (+Tj rollback)d) 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)e) 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. 30Database Systems - Tranzakciók

(gyakorlat)

Példa 1.

write(Y)13.12.11.10.9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1


Példa 1. – 1. lépés

write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1

RTS(X)=nullWTS(X)=nullTS(T2)=21. b) szabályRTS(X)=2



write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1RTS(Z)=nullWTS(Z)=nullTS(T3)=32. c) szabály

RTS(X)=2

WTS(Z)=3



write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1 RTS(X)=2WTS(X)=nullTS(T1)=11. b) szabály

WTS(Z)=3

TS(T1) ? RTS(X)1 < 2

RTS(X)=2

RTS(X)=2



write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1 RTS(X)=2WTS(X)=nullTS(T4)=41. b) szabály

WTS(Z)=3

TS(T4) ? RTS(X)4 > 2

RTS(X)=4

RTS(X)=2

RTS(X)=2



write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1RTS(X)=4WTS(X)=nullTS(T3)=31. b) szabály

WTS(Z)=3

TS(T3) ? RTS(X)3 < 4

RTS(X)=2

RTS(X)=4

RTS(X)=2RTS(X)=4



write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1

RTS(Y)=nullWTS(Y)=nullTS(T2)=22. c) szabály

WTS(Z)=3RTS(X)=2

WTS(Y)=2

RTS(X)=2RTS(X)=4

RTS(X)=4



write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1RTS(Y)=nullWTS(Y)=2

TS(T4)=4

1. b) szabály

WTS(Z)=3RTS(X)=2

RTS(Y)=4

RTS(X)=2RTS(X)=4

RTS(X)=4WTS(Y)=2

1. read-kérdés:TS(T4) ? WTS(Y)

4 > 2



write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1

RTS(Z)=null

WTS(Z)=3TS(T2)=2

1. a) szabály

WTS(Z)=3RTS(X)=2

T2 abortál+ rollback:WTS(Y):=n

ull

RTS(X)=2RTS(X)=4

RTS(X)=4WTS(Y)=2

RTS(Y)=4

1. read-kérdés:TS(T2) ? WTS(Z)

2 < 3



write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1

RTS(X)=4WTS(X)=nu

llTS(T1)=1

2. b) szabály

WTS(Z)=3RTS(X)=2

T1 abortál(+

rollback: nincs mit)

RTS(X)=2RTS(X)=4

RTS(X)=4WTS(Y)=2 2. write-kérdés:

TS(T1) ? RTS(X)1 < 4

RTS(Y)=4



write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1

RTS(X)=4WTS(X)=nu

llTS(T5)=5

WTS(Z)=3RTS(X)=2

RTS(X)=2RTS(X)=4

RTS(X)=4

RTS(Y)=4

1. b) szabályTS(T5) ?

RTS(X)5 > 4

RTS(X)=5



write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1

RTS(Y)=4WTS(Y)= 2

nullTS(T3)=3

WTS(Z)=3RTS(X)=2

RTS(X)=2RTS(X)=4

RTS(X)=4

RTS(Y)=4

1. b) szabályTS(T3) ? RTS(Y)

3 < 4

RTS(Y)=4

RTS(X)=5

1. read-kérdés:TS(T3) ? WTS(Y)

3 > null


43


write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1

WTS(Z)=3RTS(X)=2

RTS(X)=2RTS(X)=4

RTS(X)=4WTS(Y)=2

RTS(Y)=4

2.c) szabályWTS(Y)=5

RTS(X)=5

2. write-kérdés:TS(T5) ? WTS(Y)

5 > nullTS(T5) ? RTS(Y)

5 > 4RTS(Y)=4

Database Systems - Tranzakciók (gyakorlat)

RTS(Y)=4WTS(Y)= 2

nullTS(T5)=5

44


write(Y)13.

12.

11.

10.

9.8.7.6.5.4.3.2.1.

write(Y)read(Y)

read(X)write(X)

read(Z)read(Y)

write(Y)read(X)

read(X)read(X)

write(Z)read(X)

T5T4T3T2T1

RTS(Y)=4WTS(Y)=5TS(T4)=4

WTS(Z)=3RTS(X)=2

RTS(X)=2RTS(X)=4

RTS(X)=4WTS(Y)=2

RTS(Y)=4

2.b) szabály

RTS(X)=5


4 < 5RTS(Y)=4

WTS(Y)=5

T4 abortál+

rollback:RTS(Y):=3

Database Systems - Tranzakciók (gyakorlat)

RTS(Y)=3

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


Példa 1. 13. – lépés Thomas szabállyal

T1 T2 T3 T4 T51. 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)=4WTS(Y)=5TS(T4)=4WTS(Z)=3

RTS(X)=2

RTS(X)=2RTS(X)=4

RTS(X)=4WTS(Y)=2

RTS(Y)=42.b) szabály

RTS(X)=5


4 < 5

RTS(Y)=4WTS(Y)=5

T4 abortálna+ rollback( )

Thomas’ Writing Rule:

RTS(Y) ≤ TS(T4) < WTS(Y)

4 ≤ 4 < 5write(Y) nem hajtódik végre,

DE T4 folytatódhat!…

Példa 1. – végeredmény

T3 és T5 tranzakció marad megX: read-ts(x)= 5

write-ts(x)= null (abort miatt)Y: read-ts(y)=3, Thomas’Rule-lal 4 marad.

write-ts(y)=5Z:read-ts(z)= null

write-ts(z)=3


Példa 2.

11.10.9.8.7.6.5.4.3.2.1.

write(Z)write(Y)

write(Z)read(X)

read(X)read(Z)

write(Z)write(Y)

read(Y)read(Y)

read(X)T5T4T3T2T1


Példa 2. – HF.

Mely tranzakciók abortálódnak?

Mik az adattagok időbélyegei?

Alkalmazható-e a Thomas writing rule?


Documents

Tranzakciók gyakorlati anyag