Transaktiounen
Eng Transaktioun ass eng Sequenz vun Operatiounen op Daten déi en Ufank an en Enn hunn.
Eng Transaktioun ass déi sequentiell Ausféierung vu Lies- a Schreifoperatiounen. D'Enn vun enger Transaktioun kann entweder d'Ännerunge späicheren (engagéieren) oder d'Ännerungen annuléieren (Rollback). Am Zesummenhang mat enger Datebank besteet eng Transaktioun aus verschiddenen Ufroen, déi als eenzeg Ufro behandelt ginn.
Transaktioune mussen ACID Eegeschafte erfëllen
Atomitéit. D'Transaktioun ass entweder komplett oder guer net ofgeschloss.
Konsistenz. Wann Dir eng Transaktioun ofgeschloss hutt, däerfen d'Restriktiounen, déi op d'Daten opgezwong sinn (zum Beispill Contrainten an der Datebank) net verletzt ginn. Konsistenz implizéiert datt de System vun engem korrekten Zoustand an en anere korrekte Staat transferéiert gëtt.
Isoléierung. Transaktiounen, déi parallel lafen, sollen net géigesäiteg beaflossen, zum Beispill änneren Daten, déi vun enger anerer Transaktioun benotzt ginn. D'Resultat vun der Ausféierung vun parallele Transaktiounen sollt d'selwecht sinn wéi wann d'Transaktioune sequentiell ausgefouert goufen.
Nohaltegkeet. Eemol engagéiert, Ännerunge sollen net verluer ginn.
Transaktiounsprotokoll
De Log späichert Ännerungen gemaach duerch Transaktiounen, garantéiert Atomitéit a Stabilitéit vun Daten am Fall vun engem Systemausfall
De Log enthält d'Wäerter déi d'Donnéeën haten ier an nodeems se vun der Transaktioun geännert goufen. Write-ahead Log Strategie erfuerdert e Logentrée iwwer fréiere Wäerter virum Start derbäi ze ginn, an iwwer final Wäerter nodeems d'Transaktioun ofgeschloss ass. Am Fall vun engem plötzlechen Stop vum System liest d'Datebank de Log an ëmgedréint Uerdnung an annuléiert d'Ännerungen, déi duerch Transaktioune gemaach goufen. Nodeems Dir eng ënnerbrach Transaktioun begéint hutt, féiert d'Datebank se aus a mécht Ännerungen doriwwer am Logbuch. Am Staat am Moment vum Echec ze sinn, liest d'Datebank de Log an der Forward-Uerdnung a bréngt d'Ännerunge vun Transaktiounen zréck. Op dës Manéier sinn d'Stabilitéit vun den Transaktiounen, déi schonn engagéiert sinn, an d'Atomitéit vun der ënnerbrach Transaktioun bewahrt.
Einfach nei ausféieren vun gescheitert Transaktiounen ass net genuch fir Erhuelung.
Beispill. De Benotzer huet $ 500 a sengem Kont an de Benotzer decidéiert et aus engem Geldautomaten zréckzéien. Zwee Transaktioune sinn amgaang. Déi éischt liest de Gläichgewiicht Wäert a wann et genuch Fongen op der Gläichgewiicht sinn, gëtt et Suen un de Benotzer. Déi zweet subtracts déi néideg Betrag vum Gläichgewiicht. Loosst eis soen datt de System erofgefall ass an déi éischt Operatioun huet gescheitert, awer déi zweet huet. An dësem Fall kënne mir d'Suen net un de Benotzer ausginn ouni de System an säin ursprénglechen Zoustand mat engem positive Bilan zréckzekommen.
Isolatioun Niveauen
Liesen Engagéiert
Den Dirty Read Problem ass datt eng Transaktioun d'Tëscheresultat vun enger anerer Transaktioun liesen kann.
Beispill. Den initialen Gläichgewiicht Wäert ass $ 0. T1 füügt $ 50 op Är Gläichgewiicht. T2 liest de Gläichgewiicht Wäert ($ 50). T1 discards d'Ännerungen an Sortie. T2 weider Ausféierung mat falschen Gläichgewiicht Daten.
D'Léisung ass fir fix Donnéeën ze liesen (Read Committed), déi d'Liesen vun Daten verbitt, déi vun der Transaktioun geännert ginn. Wann Transaktioun A e bestëmmte Satz vun Donnéeën geännert huet, da gëtt Transaktioun B, wann Dir dës Donnéeën zougitt, gezwongen ze waarden bis Transaktioun A fäerdeg ass.
Widderhuelend Liesen
Lost Updates Problem. T1 späichert Ännerungen uewen op T2 Ännerungen.
Beispill. Den initialen Gläichgewiicht Wäert ass $ 0 an zwou Transaktiounen gläichzäiteg de Gläichgewiicht replenish. T1 an T2 liesen e Gläichgewiicht vun $ 0. T2 füügt dann $200 op $0 derbäi a späichert d'Resultat. T1 füügt $ 100 op $ 0 a späichert d'Resultat. D'Finale Resultat ass $ 100 amplaz $ 300.
Unrepetable Liesproblem. Déi selwecht Daten liesen ëmmer erëm verschidde Wäerter.
Beispill. T1 liest e Gläichgewiicht vun $ 0. T2 füügt dann $ 50 un d'Gläichgewiicht an endet. T1 liest d'Donnéeën erëm a fënnt eng Diskrepanz mam fréiere Resultat.
Repeatable Read garantéiert datt eng zweet Lies datselwecht Resultat zréckkënnt. Daten, déi vun enger Transaktioun gelies ginn, kënnen net an aneren geännert ginn bis d'Transaktioun ofgeschloss ass. Wann Transaktioun A e bestëmmte Satz vun Daten gelies huet, da gëtt Transaktioun B, wann Dir dës Donnéeën zougitt, gezwongen ze waarden bis Transaktioun A fäerdeg ass.
Bestallt Liesung (Serializéierbar)
Phantom Liest Problem. Zwou Ufroen déi Daten auswielen op Basis vun enger bestëmmter Bedingung ginn verschidde Wäerter zréck.
Beispill. T1 freet d'Zuel vun all de Benotzer deenen hir Gläichgewiicht méi wéi $ 0 awer manner wéi $ 100 ass. T2 ofgezu $1 vun engem Benotzer mat engem Balance vun $101. T1 resues d'Demande.
Bestallt Liesung (Serializéierbar). Transaktioune ginn als komplett sequentiell ausgefouert. Et ass verbueden records ze aktualiséieren oder derbäi ze ginn, déi an de Bedéngungen vun der Ufro falen. Wann Transaktioun A Daten aus dem ganzen Dësch gefrot huet, da gëtt de ganzen Dësch fir aner Transaktioune gefruer bis Transaktioun A fäerdeg ass.
Scheduler
Setzt d'Uerdnung an an där Operatiounen während parallel Transaktioune gemaach ginn.
Bitt e spezifizéierte Niveau vun Isolatioun. Wann d'Resultat vun Operatiounen net vun hirer Uerdnung hänkt, da sinn esou Operatiounen kommutativ (Permutable). Liesoperatiounen an Operatiounen op verschidden Daten si kommutativ. Lies-Schreif- a Schreif-Schreif-Operatiounen sinn net kommutativ. D'Aufgab vum Scheduler ass d'Operatiounen, déi duerch parallel Transaktioune gemaach goufen, ze interleave sou datt d'Ausféierungsresultat gläichwäerteg ass mat der sequentieller Ausféierung vun Transaktiounen.
Mechanismen fir parallel Aarbechtsplazen ze kontrolléieren (Concurrency Control)
Optimistesch baséiert op Konflikter z'entdecken an ze léisen, pessimistesch baséiert op der Verhënnerung vu Konflikter entstoe.
An der optimistescher Approche hu verschidde Benotzer Kopie vun den Donnéeën zur Verfügung. Déi éischt Persoun déi d'Ännere fäerdeg bréngt späichert d'Ännerungen, während déi aner d'Ännerunge fusionéieren mussen. En optimisteschen Algorithmus erlaabt Konflikt ze kommen, awer de System muss sech vum Konflikt erholen.
Mat enger pessimistescher Approche verhënnert den éischte Benotzer fir Daten z'erfaassen datt anerer d'Donnéeën kréien. Wann Konflikter rar sinn, ass et schlau déi optimistesch Strategie ze wielen, well et e méi héijen Niveau vu Concurrency gëtt.
Spären
Wann eng Transaktioun Daten gespaart huet, da musse aner Transaktioune waarden bis se opgespaart ginn wann se op d'Donnéeën kommen.
E Block kann op enger Datebank, Tabell, Zeil oder Attribut iwwerlagert ginn. Shared Lock kann op déiselwecht Donnéeën duerch e puer Transaktiounen imposéiert ginn, erlaabt all Transaktiounen (inklusiv deen deen et imposéiert huet) ze liesen, verbitt Ännerung an exklusiv Erfaassung. Exklusiv Spär kann duerch nëmmen eng Transaktioun imposéiert ginn, erlaabt all Aktiounen vun der imposant Transaktioun, verbitt all Aktiounen vun aneren.
En Deadlock ass eng Situatioun wou Transaktiounen an engem pendende Staat ophalen, deen onbestëmmt dauert.
Beispill. Déi éischt Transaktioun waart op d'Daten, déi vun der zweeter erfaasst ginn, fir verëffentlecht ze ginn, während déi zweet waart op d'Daten, déi vun der éischter gefaange ginn, fir verëffentlecht ze ginn.
Eng optimistesch Léisung fir den Deadlock-Problem erlaabt den Deadlock opzekommen, awer recuperéiert dann de System andeems ee vun den Transaktiounen, déi am Deadlock involvéiert ass, zréckrollt.
Deadlocks gi mat bestëmmten Intervalle gesicht. Ee vun den Detektiounsmethoden ass duerch Zäit, dat heescht, betruecht datt en Deadlock geschitt ass wann d'Transaktioun ze laang dauert fir ze kompletéieren. Wann en Deadlock fonnt gëtt, gëtt eng vun den Transaktiounen zréckgezunn, sou datt aner Transaktiounen, déi am Deadlock involvéiert sinn, fäerdeg sinn. D'Wiel vum Affer kann op de Wäert vun Transaktiounen oder hir Senioritéit baséieren (Wait-Die a Wound-Wait Scheme).
All Transaktioun T en Zäitstempel zougewisen gëtt TS mat der Startzäit vun der Transaktioun.
Waart - stierwen.
wann TS(Ti) < TS(Tj), dann Ti waart, soss Ti rullt zréck a fänkt erëm mam selwechten Zäitstempel un.
Wann eng jonk Transaktioun eng Ressource kritt huet an eng eeler Transaktioun déi selwecht Ressource freet, da kann déi eeler Transaktioun waarden. Wann eng eeler Transaktioun eng Ressource kritt huet, da gëtt déi jéngst Transaktioun, déi dës Ressource ufrot, zréckgezunn.
Wound-wait.
wann TS(Ti) < TS(Tj), dann Tj rullt zréck a fänkt erëm mam selwechten Zäitstempel un, soss Ti waarden.
Wann eng méi jonk Transaktioun eng Ressource kritt huet an eng eeler Transaktioun déi selwecht Ressource freet, da gëtt déi méi jonk Transaktioun zréckgezunn. Wann eng eeler Transaktioun eng Ressource kritt huet, dann ass déi jéngst Transaktioun déi dës Ressource freet erlaabt ze waarden. Präzedenz-baséiert Afferauswiel verhënnert Deadlocks, awer rullt Transaktiounen zréck déi net verstoppt sinn. De Problem ass datt Transaktioune vill Mol zréckgerullt kënne ginn well ... eng eeler Transaktioun kann d'Ressource fir eng laang Zäit halen.
Eng pessimistesch Léisung fir den Deadlock Problem erlaabt eng Transaktioun net auszeféieren wann et e Risiko vun engem Deadlock ass.
Fir en Deadlock z'entdecken, gëtt eng Grafik konstruéiert (waart Grafik, waart-fir-Grafik), déi Wirbelen vun deenen Transaktiounen sinn, an d'Kante gi vun Transaktiounen geriicht, déi op d'Verëffentlechung vun Daten op d'Transaktioun waarden, déi dës Donnéeën erfaasst huet. En Deadlock gëtt ugesinn als geschitt wann d'Grafik eng Loop huet. Eng Waardegrafik ze konstruéieren, besonnesch a verdeelt Datenbanken, ass eng deier Prozedur.
Zwee-Phase Sperrung - verhënnert Deadlocks andeems Dir all Ressourcen, déi vun enger Transaktioun am Ufank vun der Transaktioun benotzt ginn, seet an se um Enn befreit
All Blockéierungsoperatioune musse virun der éischter Spär viru goen. Et huet zwou Phasen - Wuesstem Phase, während där d'Grip accumuléiert, an Shrinking Phase, während där d'Grips fräigelooss ginn. Wann et onméiglech ass ee vun de Ressourcen z'erfaassen, fänkt d'Transaktioun un. Et ass méiglech datt eng Transaktioun net déi néideg Ressourcen ka kréien, zum Beispill wann verschidde Transaktioune fir déiselwecht Ressourcen konkurréiere.
Eng zwee-Phase Verpflichtung garantéiert datt de Verpflichtung op all Datebank Repliken ausgefouert gëtt
All Datebank gitt Informatiounen iwwer d'Donnéeën, déi an de Logbicher geännert ginn a reagéiert op de Koordinator OK (Wahlphase). Nodeems jiddereen OK geäntwert huet, schéckt de Koordinator e Signal dat jidderee verflicht sech ze engagéieren. Nom Engagement äntweren d'Server OK; wann op d'mannst een net OK reagéiert, da schéckt de Koordinator e Signal fir d'Ännerungen op all Server ze annuléieren (Completion Phase).
Zäitstempel Method
Eng eeler Transaktioun gëtt zréckgezunn wann Dir versicht Zougang zu Daten ze kréien, déi vun enger méi jonker Transaktioun involvéiert sinn
All Transaktioun gëtt en Zäitstempel zougewisen TS entspriechend der Startzäit vun der Ausféierung. Wann Ti eeler Tj, dann TS(Ti) < TS(Tj).
Wann eng Transaktioun zréckgerullt gëtt, gëtt se en neien Zäitstempel zougewisen. All Daten Objet Q an der Transaktioun involvéiert ass mat zwee Etiketten markéiert. W-TS(Q) - Zäitstempel vun der jéngster Transaktioun déi e Rekord erfollegräich ofgeschloss huet Q. R-TS(Q) - Zäitstempel vun der jéngster Transaktioun déi e Liesrekord gemaach huet Q.
Wann d'Transaktioun T Demande fir Donnéeën ze liesen Q Et ginn zwou Méiglechkeeten.
wann TS(T) < W-TS(Q), dat heescht, d'Donnéeën goufen duerch eng méi jonk Transaktioun aktualiséiert, dann d'Transaktioun T rullt zréck.
wann TS(T) >= W-TS(Q), da gëtt d'Liesung gemaach an R-TS(Q) ass ëmmer MAX(R-TS(Q), TS(T)).
Wann d'Transaktioun T verlaangt daten Ännerungen Q Et ginn zwou Méiglechkeeten.
wann TS(T) < R-TS(Q), dat heescht, d'Donnéeën hu scho vun enger méi jonker Transaktioun gelies a wann eng Ännerung gemaach gëtt, wäert e Konflikt entstoen. Transaktioun T rullt zréck.
wann TS(T) < W-TS(Q), dat heescht, d'Transaktioun probéiert e méi neie Wäert ze iwwerschreiwe, Transaktioun T gëtt zréckgezunn. An anere Fäll gëtt d'Ännerung duerchgefouert an W-TS(Q) gëtt gläich TS(T).
Nee deier waarden Grafiken Bau ass néideg. Eeler Transaktiounen hänke vun neier of, sou datt et keng Zyklen an der Waardegrafik sinn. Et gi keng Deadlocks well Transaktiounen net gewaart ginn, awer direkt zréckgezunn. Cascading Rollbacks sinn méiglech. Wann Ti ewechgerappt an Tj Ech liesen d'Donnéeën déi ech geännert hunn Ti, dann Tj soll och zréckrollen. Wann gläichzäiteg Tj schonn engagéiert ass, da gëtt et eng Violatioun vum Stabilitéitsprinzip.
Eng vun de Léisunge fir kaskadende Rollbacks. Eng Transaktioun fäerdeg all Schreifoperatioune um Enn, an aner Transaktioune musse waarden bis dës Operatioun fäerdeg ass. Transaktioune waarden fir engagéiert ze ginn ier se gelies ginn.
Thomas Schreifregel - eng Variatioun vun der Zäitstempelmethod, an där Daten, déi vun enger méi jonker Transaktioun aktualiséiert ginn, verbueden sinn vun enger méi aler iwwerschriwwen ze ginn
Transaktioun T verlaangt daten Ännerungen Q. Wann TS(T) < W-TS(Q), dat heescht, d'Transaktioun probéiert e méi neie Wäert ze iwwerschreiwe, Transaktioun T gëtt net zréckgeréckelt wéi an der Zäitstempelmethod.
Source: will.com