VI. Témakör: Feladatok tranzakciókezelésre

[Az V. és a VI. Témakört párhuzamosan dolgozzuk fel! ]
   
7.gyak. - Oracle rendszergazda feladatai (2010.márc.25)
>> 6.1. Adatbázisok biztonsága és felhasználói jogosultságok

8.gyak. - Oracle naplózási és archiválási rendszere (2010.ápr.8)
>> 6.2. Oracle naplózási és archiválási rendszere

9.gyak. - Naplózás, helyreállítás (zöld könyv feladatai) (2010.ápr.15)
>> 6.3. Feladatok undo és redo naplózásra és helyreállításra

10.gyak. - Oracle konkurenciavezérlési technikája  (2010.ápr.22)
>> 6.4. Az Oracle konkurenciavezérlési technikája

11.gyak. - Konkurenciavezérlés, zárak  (zöld könyv feladatai) (2010.ápr.29)
>> 6.5. Feladatok sorolhatóságra és zárakra

2.ZH (12.gyak - 2010.máj.6.)
_______________________________________________________
7. gyak. - Oracle rendszergazda feladatai 
 
6.1. Adatbázisok biztonsága és felhasználói jogosultságok

Segédanyagok:
>> Oracle Online Documentation -  Administrator's Guide: HTML   PDF
>> Nikovits Tibor összefoglalói: constraint.txt   kulsojoin.txt   jogosultsagok.txt  

Feladatok - Nikovits Tibor Információkezelés gyakorlatai alapján
SQL DCL (Data Control Language)

61dcl_1
   - Táblák és megszorítások (constraints) létrehozása.
   - Az alábbi feladatokhoz hozzunk létre az emp és dept tábláknak megfelelő magyar
      nyelvű (de ékezet nélküli) oszlopnevekkel rendelkező dolgozo és osztaly táblákat
      különböző megszorításokkal együtt, lásd constraint.txt.
   - Töltsük fel a táblákat a megszorításoknak eleget tevő adatsorokkal.
      Ellenőrizzük le a DBA_CONSTRAINTS katalógusban a megszorításokat.

61dcl_2
   - Nézettáblák létrehozása.
      Hozzunk létre egy táblán illetve két tábla természetes összekapcsolásán illetve
      (baloldali, jobboldali, teljes) külső összekapcsolásán alapuló nézettáblákat.
      Figyeljük meg, hogyan hatnak az eredeti táblán végrehajtott módosítások
      a létrehozott nézettábláinkon, és fordítva, mi történik az eredeti táblánkon,
      ha a különböző nézeteket módosítjuk.
   - Például hozzunk létre egy nézettáblát, amelyik osztályonként az összfizetést
      és a dolgozók számát tartalmazza.
   - Keressük elő a megfelelő rendszertáblából a nézettáblát létrehozó utasítás
      SQL "forrás szövegét". (DBA_VIEWS)

61dcl_3
   - Külső join.
   - Hozzunk létre egy nézettáblát, amely tartalmazza a dolgozó nevét, fizetését,
     az osztály nevét és telephelyét. Azok az osztályok is jelenjenek meg, amelyeken
     még nem dolgozik senki. Az ilyen osztályokra a dolgozó neve oszlopban az  
     jelenjen meg, hogy 'FELVETEL ALATT', a fizetés oszlopban pedig
     az alapértelmezés szerinti kezdő fizetés, ami 1500. Próbáld ki a külső join
     mindkét szintaxisával (+) illetve OUTER JOIN,lásd kulsojoin.txt.

61dcl_4
   - Jogosultságok megadása és visszavonása. GRANT, REVOKE
      Adjunk különböző jogosultságokat a fenti nézettábláinkhoz,
      lásd jogosultsagok.txt.

61dcl_5
   - Erőforrások korlátok, jogosultságok.
   - a.) Hány SQL ablakot (sessiont) tudtok egyszerre megnyitni?
   - b.) Mennyi a számotokra engedélyezett maximális kapcsolódási idő?
   - c.) Hány sikertelen bejelentkezést enged az adatbáziskezelő a számotokra?

_______________________________________________________
8. gyak. - Oracle naplózási és archiválási rendszere
 
6.2. Az Oracle naplózási és archiválási rendszere

Segédanyagok:
>> Az Oracle naplózási és archiválási rendszere: ORA_Naplozas.pdf (jelszóval)
>> Oracle Online Documentation -  Administrator's Guide:   HTML     PDF
>> Nikovits Tibor összefoglalói: triggerek.txt     trigger_peldak.txt
      instancia.txt       instancia_inditas.txt       inic_param.txt
 
Feladatok - Nikovits Tibor Információkezelés gyakorlatai alapján
 
62log_1
   - Az előző feladatban létrehozott saját DOLGOZO nevű táblához hozzunk
      létre egy TRIGGER_LOG nevű táblát, aminek a következő a szerkezete:
         ( idopont     DATE,
           muvelet     VARCHAR2(20),
           esemeny     VARCHAR2(80)
          )
   - Hozzunk létre egy triggert, ami akkor aktivizálódik ha a dolgozo tábla
      fizetés oszlopát módosítják. A trigger a következő műveleteket végezze el:
   - Ha a dolgozo új fizetése nagyobb lesz mint 4000 akkor erről tegyen egy
      bejegyzést a trigger_log táblába. Az esemény oszlopba írja be a régi és
      az  új fizetést is.
   - Az elnök (foglalkozas = 'PRESIDENT') fizetését ne engedje módosítani.
     A módosítás után a fizetés maradjon a régi.
     Erről is tegyen egy bejegyzést a trigger_log táblába.
     Az esemény oszlopba írja be, hogy a fizetés nem változott.
     (TIPP: after trigger)

62log_2
   - Hozzatok létre egy TRIGGER_LOG2 nevű táblát is,
     aminek a szerkezete a következő:
         ( idopont     DATE,
           muvelet     VARCHAR2(20),
           uj_osszfiz  NUMBER
          )
   - Hozzunk létre egy triggert, ami akkor aktivizálódik ha a dolgozo táblára
     valamilyen módosító műveletet (INSERT, DELETE, UPDATE)
     hajtanak végre. A trigger irja be a TRIGGER_LOG2 táblába
     a módosítás időpontját, a műveletet és az új összfizetést.
   - Ha az új összfizetés nagyobb lenne mint 40000, akkor a trigger utasítsa
     vissza a módosító műveletet, és hibaüzenetként küldje vissza, hogy
     'Túl nagy összfizetés'. Ez esetben naplóznia sem kell.

62log_3
  - folyt.köv. lásd 6.4. Az Oracle konkurenciavezérlési technikája utolsó feladata.

_______________________________________________________
9. gyak. - Naplózás, helyreállítás (zöld könyv feladatai) 
   
6.3. Feladatok undo és redo naplózásra és helyreállításra
 
Segédanyagok:
>> Molina-Ullman-Widom: Adatbázisrendszerek megvalósítása, Panem, 2001.
                                          8.fejezet: A rendszerhibák kezelése fejezet feladatai
>> Előadásból: 2MU08_Naplo_gyak.pdf  NAPLÓZÁS PÉLDÁK összefoglaló (jelszóval)
  
Feladatok -  (Molina-Ullman-Widom) "zöld tankönyv" 8.1-8.4 fejezetek végén
 
Molina-Ullman 8. fejezete: A rendszerhibák kezelése
 
8.1.1. Feladat - A tranzakciók korrekt végrehajtása 
Tegyük fel, hogy az adatbázisra vonatkozó konzisztenciamegszorítás: 0 <= A <= B.
Állapítsuk meg, hogy a következő tranzakciók megőrzik-e az adatbázis konzisztenciáját.
T1: A := A + B; B := A + B;
T2: B := A + B; A := A + B;
T3: A := B + 1; B := A + 1;
  
8.1.2. Feladat - A tranzakciók alaptevékenységei 
(Adjuk meg néhány, konkrét művelettel megadott tranzakció esetén az adatbáziselemek
 memóriabeli és lemezen levő értékét az egyes műveletek után.)
A 8.1.1 feladat mindegyik tranzakciójához a számításokon kívül tegyük hozzá a
beolvasó-kiíró tevékenységeket is, és mutassuk be a tranzakciók lépésenkénti hatását
a memóriában és a lemezen tárolt adatokra. Tegyük fel, hogy kezdetben A = 5 és B = 10.
  
Molina-Ullman 8.2. fejezete: Undo naplózás
  
8.2.1. Feladat - UNDO naplóbejegyzések 
Adjuk meg a 8.1.1 feladatban szereplő tranzakciók UNDO naplóbejegyzéseit.
Tegyük fel, hogy kezdetben A = 5 és B = 10.
  
8.2.2. Feladat - UNDO naplózás szabályai (tevékenységek és naplóbejegyzéseik)
Az alábbi naplóbejegyzés-sorozatok valamely T tranzakció tevékenységeit tükrözik.
Állapítsa meg az UNDO naplózás szabályainak megfelelően a naplóbejegyzések és
az adatbáziselemeket tartalmazó blokkok lemezre írási lehetőségeit, figyelembe véve,
hogy naplóbejegyzést nem lehet addig a lemezre írni, amíg a megelőző bejegyzés
nem került lemezre.

a)   
<START T>
<T,A,10>
<T,B,20>
<COMMIT T>;

b)   
<START T>
<T,A,10>
<T,B,20>
<T,C,30>
<COMMIT T>
 
8.2.4. Feladat - Helyreállítás UNDO naplózás használatával 
A következő naplóbejegyzés-sorozat a T és U két tranzakcióra vonatkozik:
<START  T>
<T, A, 10>
<START  U>
<U, B, 20>
<T, C, 30>
<U, D, 40>
<COMMIT  U>
<T, E, 50>
<COMMIT  T>
 
Adjuk meg a helyreállítás-kezelő tevékenységeit, ha az utolsó lemezre került naplóbejegyzés:
a) <START  U>
b) <COMMIT  U>
c) <T, E, 50>
d) <COMMIT  T>

8.2.7. Feladat - UNDO naplózás ellenőrzőponttal 
Tegyük fel, hogy a napló a következő bejegyzéssorozatot tartalmazza:
<START S>
<S,A,60>
<COMMIT S>
<START T>
<T,A,10>
<START U>
<U,B,20>
<T,C,30>
<START V>
<U,D,40>
<V,F,70>
<COMMIT U>
<T,E,50>
<COMMIT T>
<V,B,80>
<COMMIT V>.

Tegyük fel továbbá, hogy a működés közbeni ellenőrzőpont-képzést kezdjük alkalmazni,
közvetlenül az alábbi naplóbejegyzések (memóriában való) megjelenésétől kezdve:
a) <S,A,60>.
b) <T,A,10>.
c) <U,B,20>.
d) <U,D,40>.
e) <T,E,50>.

Mindegyik fenti esetre adjuk meg, hogy:
 i) Mikor íródik fel az <END CKPT> naplóbejegyzés, és
ii) Bármelyik lehetséges pillanatban, ha hiba lép fel, meddig kell a naplóban visszafelé tekinteni
    ahhoz, hogy minden befejezetlen tranzakciókra vonatkozó bejegyzést megtaláljunk.
  
Molina-Ullman 8.3. fejezete: Redo naplózás
 
8.3.1 Feladat - REDO naplóbejegyzések 
Adjuk meg a 8.1.1. feladatban szereplő tranzakciók helyreállítási (REDO) típusú
naplóbejegyzéseit. Tegyük fel, hogy kezdetben A = 5 és B = 10.
 
8.3.2. Feladat - REDO naplózás szabályai (tevékenységek és naplóbejegyzéseik)
Ismételjük meg a 8.2.2. feladatot REDO naplózást használva.

8.3.3. Feladat - Helyreállítás REDO naplózás használatával 
Ismételjük meg a 8.2.4. feladatot REDO naplózást használva.

8.3.5. Feladat - REDO naplózás ellenőrzőponttal 
A 8.2.7. feladat adatait használva az a)–e) helyzetek mindegyikére válaszoljuk meg
az alábbi kérdéseket:
 i) Mely pontokban fordulhat elő az <END CKPT> felírása, és
ii) Minden lehetséges hibabekövetkezési ponthoz adjuk meg, hogy a naplóban med­dig kell
    visszatekintenünk ahhoz, hogy megtaláljuk az összes befejezetlen tranzakciót.
    Vegyük figyelembe mindkét lehetőséget, azt is, hogy a hibát megelőzően az
    <END CKPT> felíródott a naplóba és azt is, ha nem.
 
Molina-Ullman 8.4. fejezete: Undo/redo naplózás
 
8.4.1. Feladat - UNDO/REDO naplóbejegyzések
Adjuk meg a 8.1.1 feladatban szereplő tranzakciók undo/redo típusú naplóbejegyzéseit.
Tegyük fel, hogy kezdetben A = 5 és B = 10.
 
8.4.2. Feladat - UNDO/REDO naplózás szabályai (tevékenységek és naplóbejegyzéseik)
Az alábbi naplóbejegyzés-sorozatok valamely T tranzakció tevékenységeit tükrözik.
Állapítsuk meg az UNDO/REDO naplózás szabályainak megfelelően a naplóbejegyzések és
az adatbáziselemeket tartalmazó blokkok lemezre írási lehetőségeit, figyelembe véve, hogy
naplóbejegyzést nem lehet addig a lemezre írni, amíg a megelőző bejegyzés nem került lemezre.

a)
<START T>
<T,A,10,11>
<T,B,20,21>
<COMMIT T>;

b)
<START T>
<T,A,10,21>
<T,B,20,21>
<T,C,30,31>
<COMMIT T>

8.4.3. Feladat - Helyreállítás UNDO/REDO naplózás használatával 
A következő UNDO/REDO naplóbejegyzés-sorozat a T és U két tranzakcióra vonatkozik:
<START  T>
<T, A, 10, 11>
<START  U>
<U, B, 20, 21>
<T, C, 30, 31>
<U, D, 40, 41>
<COMMIT  U>
<T, E, 50, 51>
<COMMIT  T>
 
Adjuk meg a helyreállítás-kezelő tevékenységeit, ha az utolsó lemezre került naplóbejegyzés:
a) <START  U>
b) <COMMIT  U>
c) <T, E, 50, 51>
d) <COMMIT T>
   
8.4.5. Feladat - UNDO/REDO naplózás ellenőrzőponttal
Tegyük fel, hogy a napló a következő bejegyzéssorozatot tartalmazza:
<START S>
<S,A,60,61>
<COMMIT S>
<START T>
<T,A,61,62>
<START U>
<U,B,20,21>
<T,C,30,31>
<START V>
<U,D,40,41>
<V,F,70,71>
<COMMIT U>
<T,E,50,51>
<COMMIT T>
<V,B,21,22>
<COMMIT V>.
 
Tegyük fel továbbá, hogy a működés közbeni ellenőrzőpont-képzést kezdjük alkalmazni,
közvetlenül az alábbi bejegyzések (memóriában való) megjelenésétől kezdve:
a) <S,A,60,61>.
b) <T,A,61,62>.
c) <U,B,20,21>.
d) <U,D,40,41>.
e) <T,E,50,51>.

Mindegyik fenti esetre adjuk meg, hogy:
 i) Mikor írható fel az <END CKPT> naplóbejegyzés, és
ii) Bármelyik lehetséges pillanatban, ha hiba lép fel, meddig kell a naplóban visszafelé tekinteni
ahhoz, hogy minden, be nem fejezett tranzakciókra vonatkozó bejegyzést megtaláljunk.
Fontoljuk meg mindkét lehetőséget is, hogy a hiba az <END CKPT> naplóbejegyzés felírása
előtt vagy az után jelentkezik.
 
 
További gyakorló feladat (ellenőrzésként a megoldás: itt)
Itt látható egy napló, melyet az UNDO/REDO protokoll szerint képeztünk.
Állítsuk vissza a konzisztens helyzetet!
(T1, BEGIN)
(T1; A; 4; 5)
(T2, BEGIN)
(T1, COMMIT)
(T2; B; 9; 10)
(START CHECKPOINT (T2))
(T2; C; 14; 15)
(T3, BEGIN)
(T3; D; 19; 20)
(T3; A; 5; 6)
(T3; E; 10; 15)
(T4, BEGIN)
(T4; F; 15; 16)
(END CHECKPOINT)
(T2, COMMIT)
HIBA
 
 _______________________________________________________
10. gyak. - Oracle konkurenciavezérlési technikája 
      
6.4. Az Oracle konkurenciavezérlési technikája
 
Segédanyagok:
>> Az Oracle konkurenciavezérlési technikája: ORA_Zarolas.pdf (jelszóval)
>> Oracle Online Documentation -  Administrator's Guide: HTML   PDF
>> Nikovits Tibor összefoglalói: tranzakciok.txt     tranz_peldak.txt
     lek_dinam_nez.txt   dinam_nezetek.txt   zarolasok.txt   autonom_tranz.txt
 
Feladatok - Nikovits Tibor Információkezelés gyakorlatai alapján
lásd  tranz_peldak.txt (megoldásokkal)
 
64konk_1
   - Tranzakció-kezelés alapjai. COMMIT, ROLLBACK,SAVEPOINT
   - Nyissunk meg egyszerre két SQLPLUS ablakot (vagy sqldevelopert),
     tiltsuk le az automatikus commit-ot (SET AUTOCOMMIT OFF) és
     végezzünk olvasó és módosító műveleteket a két ablakból felváltva.
     Az előző 61dcl_2 feladatban létrehozott táblákat és nézeteket használjuk.
   - Az aktív tranzakciók futása közben adjuk meg a rendszerkatalógusok alapján
     a következő információkat a saját magunk által futtatott tranzakciókról.
     (Lásd az alábbi feladatokat itt is:  tranz_peldak.txt, megoldásokkal)
   - Melyek az aktiv tranzakciók, mikor indultak el, és ki futtatja azokat?
   - A tranzakció melyik utasítást futtatja éppen?

64konk_2
   - Melyik rollback szegmenst használják épp az aktív tranzakciók?
   - Melyik adatfájlba írják a tranzakciók a rollback blokkjaikat?

64konk_3
   - Holtpont kipróbálása
   - Adjunk meg két utasítássorozatot a két ablakban úgy, hogy DEADLOCK alakuljon ki.
     (Lásd például itt is:  tranz_peldak.txt, megoldásokkal)

64konk_4
   - Az Oracle tranzakcióelkülönítési szintjei
   - Adjunk meg két utasítássorozatot a két ablakban úgy, hogy az egyik ablak
     a következő hibaüzenetet kapja:
     "ORA-08177: Cannot serialize access for this transaction"
     (Tipp: SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;)

64konk_5
   - Zárolások megnézése
   - Melyik session milyen típusú (sor->TX, tabla->TM) és milyen módú  
      zárolást tart fenn éppen? (RS->2, RX->3, S->4, SRX->5, X->6)
      (SID, USERNAME, TYPE, LMODE)

64konk_6
   - Melyik session vár épp egy zárolásra
      (SID, USERNAME, TYPE, LMODE, REQUEST),
      illetve melyik zárolasra vár épp valaki
      (SID, USERNAME, TYPE, LMODE, BLOCK)?

64konk_7
   - Milyen régen tartja fenn a rendszer a zárolasokat, illetve
      milyen régen vár valaki egy zárolásra?
      (SID, USERNAME, TYPE, LMODE, CTIME, REQUEST)

64konk_8
   - Mely objektumokat tartja zárolás alatt valamelyik session jelen pillanatban?

64konk_9
   - Derítsük ki (megfelelő manuális lock-oló utasítások segítségével), hogy a
     Row Exclusive (RX) módú zárolást milyen módú zárolásokkal egyidejűleg
     engedélyezi a rendszer, és mely módú zárolások esetén kell várnia a
     későbbi kérelmezőnek.
 
62log_3
  - Az előző heti utolsó feladat módosítása, most a trigger akkor is naplózzon,  
     ha a túl nagy összfizetés miatt visszautasítja a módosító műveletet.
     (TIPP: autonóm tranzakció, lásd  autonom_tranz.txt)
   
_______________________________________________________
11. gyak. - Konkurenciavezérlés, zárak  (zöld könyv feladatai) 
      
6.5. Feladatok sorolhatóságra és zárakra
 
Segédanyagok:  
>> Molina-Ullman-Widom: Adatbázisrendszerek megvalósítása, Panem, 2001.
     Konkurenciavezérlés fejezet feladatai
  
Feladatok -  (Molina-Ullman-Widom tankönyv) 9.1-9.9 és 10.3 fejezetek végén
 
További példák (feladatok - megoldással) a tranzakciókezelésre
>> 2MU09f_Konkvez_feladatok.pdf (Kiss Attila, ELTE)
>> ppea25.pdf (Katona Gyula, BME)

Molina-Ullman 9.1. fejezete: Soros és sorolható ütemezések
  
9.1.2 Feladat (ehhez hasonló)
Adott az alábbi három tranzakció. Adjuk meg az X adatbáziselem lehetséges
értékeit a tranzakciók lefutása után, feltéve, hogy a tranzakciók ütemezése soros,
és X kezdeti értéke 100.
T1: READ(X,t); t:=t+100; WRITE(X,t);
T2: READ(X,t); t:=t*2; WRITE(X,t);
T3: READ(X,t); t:=t+10; WRITE(X,t);
a.) Hányféle soros ütemezése van a fenti 3 tranzakciónak?   
b.) Hányféle különböző ütemezése van a fenti 3 tranzakciónak?
 
Molina-Ullman 9.2. fejezete: Konfliktus sorolhatóság
 
9.2.1 Feladat 
Adott az alábbi két tranzakció. 
T1: READ(A,t); t:=t+2; WRITE(A,t); READ(B,t); t:=t*3; WRITE(B,t);
T2: READ(B,s); s:=s*2; WRITE(B,s); READ(A,s); s:=s+3; WRITE(A,s);
a.) Igazoljuk, hogy a (T1,T2) és (T2,T1) soros ütemezések ekvivalensek,
     vagyis az adatbázison való hatásuk azonos. A két tranzakció hatását
     tetszőleges A=a és B=b kezdeti adatbázis-állapotból vizsgáljuk meg!
b.) Adjunk példát a fenti műveletek sorolható és nem sorolható ütemezésére is.
 
9.2.2 Feladat 
Az előző feladat tranzakcióiban csak az írási és olvasási műveleteket jelölve
a következő két tranzakciót kapjuk:
T1: R1(A); W1(A); R1(B); W1(B);
T2: R2(B); W2(B); R2(A); W2(A);
A fenti 8 művelet ütemezései közül hány darab konfliktusekvivalens
a (T1,T2) soros sorrenddel?
 
9.2.3 Feladat
Adjuk meg a konfliktus-sorolható ütemezések számát az alábbi tranzakciókra:
T1: R1(A); W1(A); R1(B); W1(B);
T2: R2(A); W2(A); R2(B); W2(B);
 
9.2.4 Feladat 
Adjuk meg az alábbi ütemezések megelőzési gráfját.
Állapítsuk meg, hogy konfliktus-sorolható-e az ütemezés?
Ha igen, akkor melyek az ekvivalens soros ütemezések?
Válasszunk ki egyet és alakítsuk át konfliktus-mentes cserékkel
az ütemezést a kiválasztott soros ütemezéssé:
a.) R1(A); R2(A); R3(B); W1(A); R2(C); R2(B); W2(B); W1(C);
b.) R1(A); R2(A); W1(B); W2(B); R1(B); R2(B); W2(C); W1(D);
c.) R1(A); R2(A); R1(B); R2(B); R3(A); R4(B); W1(A); W2(B);
 
Molina-Ullman 9.3. fejezete: A sorolhatóság biztosítása zárakkal
 
9.3.2 Feladat 
T1: l1(A); R1(A); W1(A); l1(B); R1(B); W1(B); u1(A); u1(B);
T2: l2(B); R2(B); W2(B); l2(A); R2(A); W2(A); u2(B); u2(A);
a.) Kétfázisú-e a fenti két tranzakció?
b.) Hány jogszerű ütemezést tudunk készíteni a fenti tranzakciók
      írási és olvasási műveleteiből?
 
9.3.4 Feladat 
Tekintsük a következő, két műveletből álló tranzakciót: r1(A), w1(B),
valamint a szükséges l1(A), u1(A), l1(B), u1(B) zárkezelő műveleteket.
Adjuk meg, hogy a műveleteknek hányféle lehetséges sorrendje lehet úgy,
hogy a tranzakció
a) konzisztens legyen
b) konzisztens de nem kétfázisú legyen
c) konzisztens és kétfázisú legyen
d) kétfázisú legyen
e) se nem konzisztens, se nem kétfázisú legyen
 
Molina-Ullman 9.4. fejezete: Osztott és kizárólagos zárak
 
9.4.1 Feladat 
A T1, T2 és T3 tranzakciók minden alábbi ütemezésére:
a) r1(A); r2(B); r3(C); w1(B); w2(C); w3(D);
b) r1(A); r2(B); r3(C); w1(B); w2(C); w3(A);
c) r1(A); r2(B); r3(C); r1(B); r2(C); r3(D); w1(C); w2(D); w3(E);
d) r1(A); r2(B); r3(C); r1(B); r2(C); r3(D); w1(A); w2(B); w3(C);
e) r1(A); r2(B); r3(C); r1(B); r2(C); r3(A); w1(A); w2(B); w3(C);
 
Végezzük el a következőket:
 
i) Illesszük be az osztott és a kizárólagos zárakat, és illesszük be a zárak feloldási
mű­veleteit! Helyezzünk osztott zárat közvetlenül minden olyan olvasási művelet elé,
amelyik után nem következik ugyanannak a tranzakciónak ugyanarra az elemre való
írási művelete! Helyezzünk kizárólagos zárat minden más olvasási és írási művelet elé!
Helyezzük el minden tranzakció végére a szükséges zárfelol­dásokat!
ii) Adjuk meg mi történik, amikor minden ütemezést osztott és kizárólagos zárakat
támogató ütemező futtat!
iii) Illesszük be az osztott és kizárólagos zárakat oly módon, amely lehetővé teszi
a felminősítést. Helyezzünk osztott zárat minden olvasás elé, és kizárólagos zárat
minden írás elé, és helyezzük el a szükséges zárfeloldásokat a tranzakciók végére.
iv) Adjuk meg mi történik, amikor az iii)-ból minden ütemezést osztott, kizárólagos
zárakat és felminősítést támogató ütemező futtat.
v) Illesszük be az osztott, kizárólagos és módosítási zárakat a feloldási műveletekkel
együtt. Helyezzünk osztott zárat minden olyan olvasási művelet elé, amelyiket
nem fogunk felminősíteni, helyezzünk módosítási zárat minden olyan olvasási művelet
elé, amelyeket felminősítünk, és helyezzünk kizárólagos zárat min­den írási művelet elé!
 Helyezzük el a zárfeloldásokat a tranzakciók végére, mint rendszerint!
vi) Adjuk meg mi történik, amikor az v)-ből minden ütemezést osztott, kizárólagos és
módosítási zárakat támogató ütemező futtat!
 
9.4.7 Feladat 
Az alábbi ütemezésből egy művelet hiányzik a kérdőjelek helyén:
R1(A); R2(B); ???; W1(C); W2(A);
a) Adjunk meg egy olyan olvasási műveletet ide, amely esetén az ütemezés nem sorolható.
b) Adjunk meg egy olyan írási műveletet ide, amely esetén az ütemezés nem sorolható.
 
További feladatok
 Rajzoljuk fel a következő ütemezéshez tartozó várakozási gráfot a 7., és 9. lépés után.
l1(A); l2(B); l3(C); l1(D); l2(A); l3(D); l3(B); u1(A); l2(C); ...
 
Rajzoljuk fel a következő ütemezéshez tartozó várakozási gráfot a 10. lépés után (S/X modell).
rl1(A); wl2(B); wl3(C); wl3(D); rl1(B); wl4(C); rl2(D); rl4(A); rl1(D); u3(D); ...
 
Molina-Ullman 10.3. fejezete: Holtpontkezelés
 
10.3.1 Feladat 
Tegyük fel, hogy az alábbi műveletsorozatokban minden egyes olvasás illetve
írásműveletet közvetlenül megelőzi az osztott, illetve kizárólagos zár igénylése.
Tegyük fel továbbá, hogy a zárak feloldása rögtön a tranzakció utolsó művelete
után történik meg. Adjuk meg azokat a műveleteket, amelyeknek a végrehajtását
az ütemező megtagadja, és mondjuk meg, hogy létrejön-e holtpont vagy sem!
Adjuk meg, hogy hogyan alakul a műveletek végrehajtása során a várakozási gráf!
Ha holtpont jön létre, akkor szakítsuk meg (abort) az egyik tranzakciót, és
mutassuk meg hogyan folytatódik a műveletsorozat!
 
a) r1(A); r2(B); w1(C); r3(D); r4(E); w3(B); w2(C); w4(A); w1(D);
b) r1(A); r2(B); r3(C); w1(B); w2(C); w3(D);
c) r1(A); r2(B); r3(C); w1(B); w2(C); w3(A);
d) r1(A); r2(B); w1(C); w2(D); r3(C); w1(B); w4(D); w2(A);
 
Molina-Ullman további 9.6-9.9. fejezetei a konkurenciavezérlésről
 
9.6.1 Feladat 
Tekintsünk a változatosság kedvéért egy objektumorientált adatbázist. A C osztály
objektumait két blokkban tároljuk, a B1-ben és a B2-ben. A B1 tartalmazza
az O1 és O2 objektumokat, míg a B2 tartalmazza az O3, O4 és O5 objektumokat.
Az osztálykiterjedések, a blokkok és az objektumok zárolható adatbáziselemekből álló
hierarchiát alkotnak. Adjuk meg a zárolási kérések sorozatát és a figyelmeztető protokoll
alapú ütemező feladatát az alábbi kérési sorozatokhoz. Feltehetjük, hogy minden kérés
éppen azelőtt fordul elő, mint amikor szükségünk van rá, és minden zárfeloldás a tranzakció
befejeztével történik.
 
a) r1(O1); w2(O2); r2(O3); w1(O4);
b) r1(O5); w2(O5); r2(O3); w1(O4);
c) r1(O1); r1(O3); r2(O1); w2(O4); w2(O5);
d) r1(O1); r2(O2); r3(O1); w1(O3); w2(O4);w3(O5); w1(O2);
 
KÖV.HÉTEN II.ZH (12.gyak)