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

11.gyak.
>> 6.1. Adatbázisok biztonsága és felhasználói jogosultságok
>> 6.2. Oracle naplózási és archiválási rendszere
>> !! 6.3. Feladatok undo és redo naplózásra és helyreállításra

12.gyak.
>> 6.4. Az Oracle konkurenciavezérlési technikája
>> !! 6.5. Feladatok sorolhatóságra és zárakra

13.gyak. 
>> 6.6. További feladatok a tranzakciókezelés témakörében
>> 6.7. Tranzakciókezelés és zárolás az Oracle-ben
_______________________________________________________
11. gyak. - A rendszerhibák kezelése, naplózás és helyreállítás

Haladó témák a relációs adatbázisok tárgykörében
>> 6.1. Adatbázisok biztonsága és felhasználói jogosultságok
>> 6.2. Oracle naplózási és archiválási rendszere
>> !! 6.3. Feladatok undo és redo naplózásra és helyreállításra

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?

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.

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

8.1.1. Feladat - A tranzakciók korrekt végrehajtása (könyv 463. old.)
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 (könyv 463. old.)
(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.
 
 
8.2.1. Feladat - UNDO naplóbejegyzések (könyv 476. old.)
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 (könyv 476. old.)
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 (könyv 477. old.)
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.
 
 
8.3.1 Feladat - REDO naplóbejegyzések (könyv 483. old.)
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 (könyv 476. old.)
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 (könyv 477. old.)
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.


8.4.1. Feladat - UNDO/REDO naplóbejegyzések(könyv 489. old.)
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 (könyv 489. old.)
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 (könyv 490. old.)
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
 
____________________________________________________
12. gyak. - Konkurens hozzáférés vezérlése, zárak kezelése
 
>> 6.4. Az Oracle konkurenciavezérlési technikája
>> !! 6.5. Feladatok sorbarendezhetőségre és zárakra
  
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)
 
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.6 é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)
   
9.1.2 Feladat (könyv 505.old.) (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?
 
9.2.1 Feladat (könyv 511-512. old.)
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 (könyv 512. old.)
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 (könyv 512.old.)
Adjuk meg a konfliktus-sorbarendezhető ütemezések számát az alábbi két tranzakcióra.
T1: R1(A); W1(A); R1(B); W1(B);
T2: R2(A); W2(A); R2(B); W2(B);

9.2.4 Feladat (könyv 512.old.)
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);

9.3.2 Feladat (könyv 520.old.)
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.4.1 Feladat (könyv 529.old.)
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űvele­tek­ke
l 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 (könyv 531.old.)
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ó.

9.6.1 Feladat (könyv 543.old.)
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ő pro­to­kol
l 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);

10.3.1 Feladat (könyv 594.old.)
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ű­ve­lete után történik m.eg
. 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 továbbá,
hogy hogyan alakul a műveletek végrehajtása során a várakozási gráf!
Ha létrejön egy holtpont, abortáltassuk 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);

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

_______________________________________________________
13. gyak.  - További feladatok tranzakciókezelésre
   
6.6. További feladatok a tranzakciókezelés témakörében
 
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.7-9.9 fejezetek végén
   
6.7. Tranzakciókezelés és zárolás az Oracle-ben 
   
Segédanyagok:
>> Az Oracle naplózási és archiválási rendszere: ORA_Naplozas.pdf (jelszóval)
>> Az Oracle konkurenciavezérlési technikája: ORA_Zarolas.pdf (jelszóval)
>> Oracle Online Documentation -  Administrator's Guide: HTML   PDF
   
Mai gyakorlaton az Oracle konkurenciavezérlési és zárolási technikáit nézzük meg:
lásd >> 6.4. Az Oracle konkurenciavezérlési technikája