Sisteme de gestiune a bazelor de date, 2013-2014
description
Transcript of Sisteme de gestiune a bazelor de date, 2013-2014
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