C9.Recuperare. Rezistenta la defecte (cont.)

Sisteme de gestiune a bazelor de date, 2014-2015

• Recuperare. Rezistenta la defecte▫Fisierul jurnal▫Tipuri de RM / algoritmi de recuperare

UNDO / REDO UNDO / NO-REDO NO-UNDO / REDO NO-UNDO / NO-REDO

▫Exemplu recuperare

C9. SGBD

• Fisierul jurnal – fisier secvential, in memoria externa

• Fisierul jurnal contine datele necesare anularii / recuperarii

• => este posibil ca, la un moment dat, baza de date stabila sa contina valori scrise de tranzactii necomise si / sau sa nu contina valori scrise de tranzactii comise.

• => in cazul unei caderi de sistem, RM (operatia Restart) trebuie sa detina informatie suficienta pentru:▫ a anula modificarile efectuate de tranzactii necomise in baza de

date stabila – operatii de tip UNDO▫ a reconstitui modificarile efectuate de tranzactii comise care inca

nu au fost scrise in baza de date stabila – operatii de tip REDO

C9. SGBDTransaction Log

• Inregistrarile din jurnal:

▫ <Ti, Start> - inceputul tranzactiei Ti▫ <Ti, O, x, v1, v2> - operatie O asupra lui x: v1 =

imaginea anterioara, v2 = imaginea ulterioara▫ <Ti, Commit> - comiterea lui Ti▫ <Ti, Abort> - anularea lui Ti

• Observatie: Ordinea in care apar inregistrarile in jurnal este ordinea in care au avut loc operatiile (deoarece este un fisier secvential)

• Observatii: Gestiunea jurnalului, a spatiului ocupat de inregistrarile din jurnal.

C9. SGBDTransaction Log

Regula UNDO (Write-Ahead-Log Rule, WAL): Daca in baza de date stabila locatia lui x contine ultima valoare comisa a acestuia, atunci aceasta valoare trebuie salvata in memoria secundara (in jurnal) inainte ca valoarea sa fie supra-scrisa de o valoare necomisa.

Regula REDO (Save-Log-at-Commit Rule): Inainte ca o tranzactie sa fie comisa, trebuie ca toate valorile scrise de aceasta sa fie scrise in memoria stabila (baza de date stabila sau jurnal).

C9. SGBDRegulile UNDO si REDO

• Sunt permise actualizari in bd stabila inainte de comiterea tranzactiei si comiteri ale tranzactiilor inainte ca modificarile acestora sa fie scrise in bd stabila; intrarile din jurnal corespunzatoare modificarilor contin imaginile anterioare si ulterioare.

• Este cel mai complex tip de algoritm de recuperare; este eficient in inregistrarea datelor in memoria stabila; este mai putin eficient in operatia de recuperare fata de alte categorii de algoritmi.

• RM nu solicita CM-ului sa scrie intrarea din cache in baza de date stabila. CM elibereaza acel spatiu cand are nevoie de acesta => CM decide cand inregistreaza o modificare in baza de date stabila.

• Restart: sunt efectuate 2 parcurgeri ale jurnalului:▫ cap (prima inreg) < - - - - - Jurnal - - - - - > coada (ultima inreg) ▫ 1 – UNDO (coada – cap)▫ 2 – REDO (cap – coada)

C9. SGBDAlgoritmul UNDO / REDO

• (Permite) Scrierea imediata in bd stabila a noilor valori, dar numai dupa ce imaginile anterioare au fost salvate in jurnal.

• Situatia in care RM nu trebuie sa efectueze operatii de tip REDO este aceea in care toate actualizarile asupra datelor sunt scrise in bd stabila inainte de comiterea tranzactiilor => chiar daca la comitere sunt date modificate inca in cache, se forteaza scrierea acestora in bd stabila inainte de efectuarea comiterii tranzactiei. In rest, similar algoritmului UNDO/REDO.

• Restart: In timpul operatiei de recuperare, se ignora din jurnal inregistrarile tranzactiilor pentru care exista o inregistrare de comitere / anulare si se executa doar operatii UNDO pentru tranzactiile care erau active in momentul aparitiei defectului (posibil si pt altele).

• => se efectueaza o parcurgere coada – cap a jurnalului.

C9. SGBDAlgoritmul UNDO / NO-REDO

• Amanarea scrierilor in bd stabila pana la comiterea tranzactiilor; doar imaginile ulterioare sunt salvate in jurnal.

• Pentru a evita operatiile de tip UNDO (si a executa, daca e cazul, numai operatii de tip REDO), nu se scriu modificarile necomise in baza de date stabila.

• Restart: In timpul operatiei de recuperare, se refac modificarile tranzactiilor comise, iar inregistrarile tranzactiilor necomise se ignora (sunt sterse din jurnal) => doar REDO.

• => se efectueaza o parcurgere cap – coada a jurnalului.

C9. SGBDAlgoritmul NO-UNDO / REDO

• RM care nu necesita UNDO si / sau REDO => shadowing• Baza de date stabila contine intotdeauna ultimele valori

comise

C9. SGBDAlgoritmul NO-UNDO / NO-REDO

T1 T2---------------------------

R(x), R(z)W(x, 150)

(*1)R(u)R(y)W(u, 200)

R(v)

(*2)W(z, 100)

W(y, 300)W(v, 300)

C

(*3)W(v, 310)

(*4)C

(*5)

Fie {T1, T2}

Valorile initiale:

u:=300

v:=400

x:=100

y:=200

z:=50

C9. SGBDExemplu recuperare

Jurnal + Recuperare, UNDO/REDO

Executie cu succes {T1, T2}<T2, Start><T2, x, 100, 150><T1, Start><T1, u, 300, 200><T2, z, 50, 100><T1, y, 200, 300><T2, v, 400, 300><T1, Commit><T2, v, 300, 310><T2, Commit>

Executie + defect (*1)<T2, Start><T2, x, 100, 150>=> UNDO T2

Executie + defect (*2)<T2, Start><T2, x, 100, 150><T1, Start><T1, u, 300, 200>=> UNDO T1, T2

Executie + defect (*3)<T2, Start><T2, x, 100, 150><T1, Start><T1, u, 300, 200><T2, z, 50, 100><T1, y, 200, 300><T2, v, 400, 300><T1, Commit>=> REDO T1, UNDO T2

Executie + defect (*4)=> REDO T1, UNDO T2

Executie + defect (*5)=> REDO T1, REDO T2

C9. SGBDExemplu recuperare

Jurnal + Recuperare, UNDO/NO-REDO

Executie cu succes {T1, T2}<T2, Start><T2, x, 100><T1, Start><T1, u, 300><T2, z, 50><T1, y, 200><T2, v, 400><T1, Commit><T2, v, 300><T2, Commit>

Executie + defect (*1)<T2, Start><T2, x, 100>=> UNDO T2

Executie + defect (*2)<T2, Start><T2, x, 100><T1, Start><T1, u, 300>=> UNDO T1, T2

Executie + defect (*3)<T2, Start><T2, x, 100><T1, Start><T1, u, 300><T2, z, 50><T1, y, 200><T2, v, 400><T1, Commit>=> IGNORE T1, UNDO

T2

Executie + defect (*4)=> IGNORE T1, UNDO

T2

Executie + defect (*5)=> IGNORE T1, IGNORE T2

C9. SGBDExemplu recuperare

Jurnal + Recuperare, NO-UNDO/REDO

Executie cu succes {T1, T2}<T2, Start><T2, x, 150><T1, Start><T1, u, 200><T2, z, 100><T1, y, 300><T2, v, 300><T1, Commit><T2, v, 310><T2, Commit>

Executie + defect (*1)<T2, Start><T2, x, 150>=> IGNORE T2

Executie + defect (*2)<T2, Start><T2, x, 150><T1, Start><T1, u, 200>=> IGNORE T1, T2

Executie + defect (*3)<T2, Start><T2, x, 150><T1, Start><T1, u, 200><T2, z, 100><T1, y, 300><T2, v, 300><T1, Commit>=> REDO T1, IGNORE T2

Executie + defect (*4)=> REDO T1, IGNORE T2

Executie + defect (*5)=> REDO T1, REDO T2

C9. SGBDExemplu recuperare

Next – C10. SGBD

• Recuperare. Rezistenta la defecte• Puncte de reluare• Recuperare in urma defectelor media