Transaktioiden samanaikaisuuden hallinta

Transaktioiden samanaikaisuuden hallinta C. Mohan, D. Haderle, B. Lindsay, H. Pirahesh & P. Schwartz: ARIES: a transaction recovery method supporting fine-granularity locking and partial rollbacks using write-ahead logging. ACM Transactions on Database Systems 17:1 (1992), 94 162; kohta 1.3 (finegranularity locking). C. Mohan: Concurrency control and recovery methods for B+-tree indexes: ARIES/KVL and ARIES/IM. Performance of Concurrency Control Mechanisms in Centralized Database Systems (V. Kumar, toim.). Prentice Hall, 1996, 248 306; kohta 10.2.1 (locks and latches); kohdat 10.3 (a simple locking algorithm) ja 10.4 (ARIES/KVL). A. Silberschatz, H. F. Korth & S. Sudarshan: Database System Concepts. Fifth Edition. McGraw-Hill, 2006; sivut 627 628, luvun 15 (transactions) kohta 15.7 (implementation of isolation); sivut 635 645, luvun 16 (concurrency control) kohdan 16.1 (lock-based protocols) alakohdat 16.1.1 (locks), 16.1.2 (granting of locks), 16.1.3 (the two-phase locking protocol) ja 16.1.4 (implementation of locking); sivut 653 656, kohta 16.4 (multiple granularity); sivut 659 669, kohdat 16.6 (deadlock handling), 16.7 (insert and delete operations) ja 16.8 (weak levels of consistency). 213

Lukot, s. 215. Lukkotaulu, s. 221. Lukon varaus ja vapautus, s. 223. Lukituskäytäntö, s. 229. Ankara kaksivaihelukitus, s. 231. Avainvälilukitus, s. 234. Monirakeisen tietokannan avainvälilukitus, s. 238. Aikomuslukot ja monirakeisuuslukitus, s. 242. Looginen vs. fyysinen lukitus, s. 251. Lukkiumat, s. 255. Lukkiumien havaitseminen, s. 259. Ehdolliset lukkopyynnöt, s. 261. Relaation avainväliselauksen toteutus, s. 265. 214

Lukot Useimmiten käytetty menettely transaktioiden eristyvyyden takaamiseksi on lukitus (locking). Lukko (lock) on aktiiviselle transaktiolle kuuluva keskusmuistialkio, joka antaa transaktiolle pääsyn tietokannan tiettyyn osaan. Transaktio voi suorittaa tietokantaan kohdistuvan operaation (luvun tai päivityksen) vain, jos se on lukinnut operaation koskettaman osan tietokannasta asianmukaisella lukolla. Lukkoon liittyy sen nimi, tyyppi, kestoaika ja omistava transaktio. Lukon nimi (lock name) ilmaisee lukituksen kohteena olevan tietoalkion tai tietoalkiojoukon tietokannasta. Lukon nimen perusteella lukko voidaan luokitella loogiseksi tai fyysiseksi. Loogisen lukon nimi ilmaisee loogisen tietokannan osan, kuten yksittäisen monikon jossakin relaatiossa tai kokonaisen relaation. 215

Relaation r(x,v ) monikon (x,v) loogisen lukon nimenä on yksilöivän avaimen arvo x, kun looginen tietokanta koostuu vain relaatiosta r, tai relaation tunnisteen ja avainarvon muodostama pari (r, x), jos loogisessa tietokannassa on useampia relaatioita. Lukko x lukitsee avainarvolla x varustetun monikon siitä riippumatta, onko relaatiossa r lukintahetkellä sellaista monikkoa vai ei. Fyysisen lukon nimi ilmaisee fyysisen tietokannan osan, kuten tietyllä tietosivulla sijaitsevan tietuepaikan tai kokonaisen sivun tai tiedoston tai tietyn solun hakemistorakenteessa. Sivun p tietuepaikan i fyysisen lukon nimenä on monikkotunniste (p,i). Lukko lukitsee tietuepaikan (p, i) siitä riippumatta, onko siinä lukintahetkellä tietuetta vai ei. 216

Lukkojen käsittely on tehokkaampaa, jos lukon nimi on vakiomittainen, lyhyt arvo, esim. nelitavuinen lukuarvo. Vaihtelevanmittaisen tai rakenteeltaan monimutkaisen lukonnimen sijasta käytetäänkin yleensä nimestä x jollakin hajauttimella h laskettua hajautusarvoa h(x). Monikon avainarvoon x varattu lukko lukitsee silloin kaikki ehdon h(y) = h(x) täyttävät, avainarvolla y varustetut monikot. Lukon tyyppi (lock mode) ilmaisee, minkä tyyppiseen operaatioon lukko oikeuttaa. Tietoalkion x lukemista varten transaktion on hankittava x:ään vähintään lukulukko (read lock) eli S-lukko (S-lock). Tietoalkion x kirjoittamista varten transaktion on hankittava x:ään kirjoituslukko eli X-lukko (X-lock). 217

Lukulukko on yhteiskäyttöinen (shared): useammalla transaktiolla voi samanaikaisesti olla lukulukko x:ään. Kirjoituslukko on poissulkeva (exclusive): kun transaktiolla on kirjoituslukko x:ään, muille transaktioille ei myönnetä mitään lukkoja x:ään. Kirjoituslukko tietoalkioon x oikeuttaa transaktion myös lukemaan x:n. Käytännössä S- ja X-lukkojen lisäksi on käytössä myös muita lukkotyyppejä, kuten päivitykseen varautumislukko U sekä monirakeisuuden hallintaan tarvittavat aikomuslukot IS, IX ja SIX, joiden merkitys selostetaan myöhemmin. 218

Kestoajaltaan (duration) lukko voi olla pitkä- tai lyhytkestoinen. Transaktion sitoutumiseen tai peruutuksen päättymiseen asti pidettävää lukkoa kutsutaan pitkäkestoiseksi lukoksi (long-duration lock) eli sitoutumiskestoiseksi lukoksi (commit-duration lock). Transaktion T hallussa olevien pitkäkestoisten lukkojen vapautus sisältyy transaktion sitoutumis- ja peruutuksen päättämiskäytäntöihin, so. operaation C suoritukseen sen viimeisenä vaiheena, lokitietueen T,C kirjaamisen ja lokin levylle pakotuksen jälkeen. Aikaisemmin vapautettavat lukot ovat lyhytkestoisia (shortduration). Lyhytkestoinen lukko vapautetaan välittömästi operaation varsinaisten toimintojen jälkeen, operaation viimeisenä toimintona, siis välittömästi sen jälkeen, kun operaation kohteena olevan tietoalkion sisältävän sivun salpaus on vapautettu. 219

Lukon omistaja (lock owner) on aina jokin transaktio. Vrt. että salvan omistaja on prosessi tai prosessin säie. Lukon täydellinen esitys on siis nelikko (T,x,m,d), missä x on lukon nimi, m on lukon tyyppi (S, X, IS, IX, SIX, U), d on lukon kestoaika (commit-duration, short-duration) ja T on lukon omistavan transaktion tunniste. Yleensä oletetaan, että transaktiolla T on kerrallaan samaan tietoalkioon x vain yksi annetun kestoajan d lukko, ts. yhtä aikaa ei voi olla varattuna kahta lukkoa (T,x,m 1,d) ja (T,x,m 2,d). Transaktiolla voi kyllä olla samaan tietoalkioon yhtäaikaa lyhytkestoinen lukko ja pitkäkestoinen lukko, esim. (T, x, S, long-duration) ja (T, x, X, short-duration). 220

Lukkotaulu Lukkoja (T, x, m, d) säilytetään lukkotauluksi (lock table) kutsutussa keskusmuistitietorakenteessa, jota ylläpitää tietokannan hallintajärjestelmän lukonhallitsin. Lukkotaulu perustetaan ja alustetaan tyhjäksi järjestelmää käynnistettäessä. Lukkotaulu on olemassa ainoastaan tietokantajärjestelmän ilmentymän (instanssin) ollessa käynnissä; häiriötilanteessa tai järjestelmää suljettaessa lukkotaulu samoin kuin muutkin järjestelmän keskusmuistirakenteet (mm. puskurit) katoavat. Lukkotaulu organisoidaan hajautustauluksi (tai tasapainoiseksi binääripuurakenteeksi), jota indeksoidaan lukon nimellä. Näin saadaan nopeasti selville, mitä lukkoja tietoalkioon on ja keiden hallussa ne ovat. 221

Lisäksi linkitetään erikseen kunkin transaktion T hallussa olevat (pitkäkestoiset) lukot ketjuksi, joka alkaa transaktiotaulun T :tä vastaavasta alkiosta. Lyhytkestoinen lukko on transaktiolla yleensä kerrallaan vain yhteen tietoalkioon. Transaktio näet suorittaa kerrallaan vain yhtä operaatiota. Pitkäkestoisia lukkoja kertyy transaktiolle sitoutumispisteeseen mennessä yleensä yhtä monta kuin on eri tietoalkioita, joihin transaktio on operoinut (kun sovelletaan täyden eristyvyyden takaavaa lukituskäytäntöä). 222

Lukon varaus ja vapautus Olkoon m lukkotyyppi. d-kestoisen m-lukon asetus eli varaus transaktiolle T tietoalkioon x tapahtuu operaatiolla lock(t,x,m,d) ja lukon vapautus operaatiolla unlock(t, x, d). Lukon asetus ja vapautus ovat atomisia operaatioita. Tietokannan hallintajärjestelmässä käytettävälle lukkotyyppijoukolle määritellään yhteensopivuus (compatibility). Olkoot m 1 ja m 2 lukkotyyppejä. Oletetaan, että transaktio T 2 pyytää m 2 -lukkoa tietoalkioon x, johon toisella transaktiolla T 1 on parhaillaan m 1 -lukko. Jos transaktiolle T 2 voidaan heti myöntää m 2 -lukko x:ään riippumatta T 1 :n m 1 -lukosta, sanomme, että lukkotyyppi m 2 on yhteensopiva (compatible) lukkotyypin m 1 kanssa. 223

Lukkotyyppien yhteensopivuudet esitetään yhteensopivuusmatriisissa. Lukkotyyppijoukon {S, X} yhteensopivuusmatriisi: Comp m 1 -lukko m 2 -lukko S X S true false X false false Comp[m 2, m 1 ] = true m 2 yhteensopiva m 1 :n kanssa. 224

Oletetaan, että transaktiolla T on ennestään d-kestoinen m-lukko tietoalkioon x. T pyytää x:ään d-kestoista m -lukkoa. Mikäli lukko voidaan myöntää, tapahtuu lukon korotus (lock upgrade) m -lukoksi, missä m on (yleensä vähiten poissulkeva) lukkotyyppi, joka on vähintään yhtä poissulkeva kuin m ja m. Lukkotyyppien S ja X keskinäinen poissulkevuusjärjestys on S < X, ts. X on poissulkevampi kuin S, eli X oikeuttaa T :lle x:ään laajemman operaatiojoukon (eli luvun ja päivityksen) kuin S (joka oikeuttaa vain luvun). 225

Lukkojen mahdolliset korotukset esitetään lukonkorotusmatriisissa. Lukkotyyppijoukon {S, X} lukonkorotusmatriisi: Upgr omistama pyytämä S X S S X X X X Upgr[m, m] = m m on vähiten poissulkeva lukkotyyppi, joka on vähintään yhtä poissulkeva kuin m ja m. 226

Lukon varausoperaation lock(t,x,m,d) toteutus transaktiossa T : 1. Selvitetään lukkotaulusta, mitä lukkoja tietoalkioon x ennestään on. 2. Jos millään toisella transaktiolla ei ole x:ään lukkotyypin m kanssa yhteensopimatonta lukkoa, myönnetään T :n pyytämä lukko välittömästi seuraavasti: (a) Jos T :llä ei ole ennestään x:ään d-kestoista lukkoa, viedään lukkotauluun lukko (T,x,m,d) ja palataan. (b) Jos T :llä on ennestään x:ään d-kestoinen m -lukko (T,x,m,d), muutetaan se lukoksi (T,x,m,d), missä m = Upgr[m,m ], ja palataan. 3. Jos jollakin toisella transaktiolla T on x:ään lukko, joka on yhteensopimaton lukkotyypin m kanssa, transaktiota T tuottava prosessi pannaan odottamaan yhteensopimattoman lukon vapautumista. 227

Lukon vapautusoperaation unlock(t,x,d) toteutus transaktiossa T : 1. Haetaan lukkotaulusta tietue (T,x,m,d) ja poistetaan se. 2. Jos x:ään pääsyä odottavien prosessien jono on epätyhjä, herätetään jonon ensimmäinen prosessi (joka nyt jatkaa kesken jäänyttä lock-kutsuaan). 228

Lukituskäytäntö Tietokantasovelluksen ohjelmoijan tai kyselyjä tekevän käyttäjän ei tarvitse huolehtia tietoalkioiden lukituksesta, vaan järjestelmä varaa tarvittavat lukot automaattisesti järjestelmässä sovellettavan lukituskäytännön mukaisesti. Lukituskäytäntö (locking protocol) sanoo, mitä lukkoja varataan mitäkin operaatiota varten ja milloin mikäkin lukko varataan ja vapautetaan. Lukituskäytännön tulee olla sellainen, että sen noudattaminen takaa transaktioiden eristyvyyden, ts. lukituskäytännön mahdollistamissa ajoituksissa transaktiot ovat niille asetetulla eristyvyystasolla. 229

Täyden eristyvyyden takaavassa lukituskäytännössä pääosa lukoista on pitkäkestoisia eli vapautetaan vasta transaktion sitouduttua tai päätettyä peruutuksensa. Tietokantasovelluksen suunnittelija voi vaikuttaa lukkojen varausaikaan yleensä vain määräämällä sovellusprosessin transaktiorajat (SQL-operaatiot commit ja rollback) sopivasti tai määrittämällä transaktion eristyvyystason sarjallistuvaa tasoa heikommaksi. Transaktiot pitäisi suunnitella mahdollisimmat lyhyiksi. 230

Ankara kaksivaihelukitus Luku-kirjoitusmalliin liittyvässä ankarassa kaksivaiheisessa lukituskäytännössä (strict two-phase locking protocol, strict 2PL) transaktion T operaatioiden R ja W suoritukseen sisältyy lukkojen varauksia ja vapautuksia seuraavasti. T :n etenemisoperaatiossa R[x, v] varataan pitkäkestoinen S-lukko luettavan monikon (x,v) avainarvoon x. T :n etenemisoperaatiossa W[x, u, v] varataan pitkäkestoinen X- lukko kirjoitettavan monikon avainarvoon x. Käänteisoperaatioitaan varten ei peruuntuvan tai osittaisperuutusta suorittavan transaktion tarvitse hankkia mitään uusia lukkoja. Käänteisoperaation W 1 [x,u,v] transaktio T saa suorittaa avainarvoon x hankitun pitkäkestoisen X-lukon turvin. 231

Käytäntö estää eristyvyysanomaliat, sillä selvästikin (1) pitkäkestoiset X-lukot estävät likaiset kirjoitukset...w 1 [x]...w 2 [x]...c 1, (2) pitkäkestoiset X-lukot ja lyhytkestoiset S-lukot estävät likaiset luvut...w 1 [x]...r 2 [x]...c 1 ja (3) lyhytkestoiset X-lukot ja pitkäkestoiset S-lukot estävät toistokelvottomat luvut...r 1 [x]...w 2 [x]...c 1. 232

Samanaikaisuudenhallinnan kirjallisuudessa perinteisesti esitetty kaksivaihelukitus (two-phase locking, 2PL), siis ilman ankara - attribuuttia, tarkoittaa seuraavanlaista luku-kirjoitusmalliin liittyvää lukituskäytäntöä. Transaktion on operaatiota R[x] varten varattava S-lukko x:ään ja operaatiota W[x] varten X-lukko x:ään. Lukkojen ei kuitenkaan tarvitse olla pitkäkestoisia, kunhan vain T ei jonkin lukon vapautettuaan enää varaa mitään uusia lukkoja. Tällaista käytäntöä noudattavan transaktion T lukonkäsittelyoperaatiot jakaantuvat siten kahteen erilliseen vaiheeseen: (1) lukkojoukon kasvuvaiheeseen, jossa varataan lukkoja, ja (2) lukkojoukon supistumisvaiheeseen, jossa vapautetaan lukkoja. Käytäntö ei estä eristyvyysanomalioita, mutta takaa, että ajoituksen mille tahansa transaktioille T 1 ja T 2 korkeintaan toinen ehdoista T 1 < T 2 ja T 2 < T 1 on voimassa. 233

Avainvälilukitus Avainvälilukituskäytännössä (key-range locking protocol) eli avainarvolukituskäytännössä (key-value locking protocol) transaktion T operaatioiden R, I ja D suoritukseen sisältyy lukkojen varauksia ja vapautuksia seuraavasti. T :n etenemisoperaatiossa R[x, θz, v] varataan pitkäkestoinen S- lukko luettavan monikon (x,v) avainarvoon x. T :n etenemisoperaatiossa I[x, v] varataan pitkäkestoinen X-lukko lisättävän monikon avainarvoon x ja lyhytkestoinen X-lukko x:n seuraajaan y, so. pienimpään ehdon y > x täyttävään avainarvoon y tietokannassa (tai avainarvoon, mikäli x on tietokannan suurin avainarvo). Kun (x,v) on saatu lisätyksi, y:n lukko vapautetaan. T :n etenemisoperaatiossa D[x, v] varataan lyhytkestoinen X-lukko poistettavan monikon avainarvoon x ja pitkäkestoinen X-lukko x:n seuraajaan y. Kun (x,v) on saatu poistetuksi, x:n lukko vapautetaan. 234

Käänteisoperaatioita varten ei avainvälilukituksessakaan varata mitään uusia lukkoja. Käänteisoperaation I 1 [x,v] transaktio saa suorittaa avainarvoon x hankitun pitkäkestoisen X-lukon turvin. Käänteisoperaation D 1 [x,v] transaktio saa suorittaa avainarvon x seuraajaan y hankitun pitkäkestoisen X-lukon turvin. Transaktion peruutuksesta tai osittaisperuutuksesta ei siten koskaan voi aiheutua lukkiumaa. 235

Esimerkiksi tietokannassa D = {(1,10)} ajetussa transaktioiden T 1 = BR[x, 1,u]R[y,>x,v]C ja T 2 = BR[x, 1,u]I[2,u + 10]C ajoituksessa H = B 1 R 1 [1, 1,10]B 2 R 2 [1, 1,10]I 2 [2,20]C 2 R 1 [2,>1,20]C 1 varataan ja vapautetaan lukkoja seuraavasti: R 1 [1, 1,10]: pitkäkestoinen S-lukko T 1 :lle avainarvoon 1. R 2 [1, 1,10]: pitkäkestoinen S-lukko T 2 :lle avainarvoon 1. I 2 [2,20]: T 2 :lle pitkäkestoinen X-lukko avainarvoon 2 ja lyhytkestoinen X-lukko avainarvoon. C 2 : vapautetaan sitoutumiskäytännön lopuksi T 2 :n hallussa vielä olevat lukot (so. avainarvojen 1 ja 2 pitkäkestoiset lukot). R 1 [2,>1,20]: pitkäkestoinen S-lukko T 1 :lle avainarvoon 2. C 1 : vapautetaan sitoutumiskäytännön lopuksi T 1 :n hallussa vielä olevat lukot (so. avainarvojen 1 ja 2 lukot). Kaikki lukot voidaan myöntää välittömästi niiden pyyntöjärjestyksessä, joten ajoitus H on siis mahdollinen avainvälilukituskäytännössä. 236

Voidaan näyttää, että avainvälilukituskäytäntö estää kaikki eristyvyysanomaliat. Esimerkiksi seuraava ajoitus, jossa on toistokelvoton luku, ei ole mahdollinen avainvälilukituskäytännössä: B 1 R 1 [3,>1,w]B 2 I 2 [2,v] Tietokannan sisältönä on tässä aluksi {(1,u),(3,w)}. Lukkoja varattaisiin tässä seuraavasti: R 1 [3,>1,w]: T 1 :lle pitkäkestoinen S-lukko avainarvoon 3. I 2 [2,v]: T 2 :lle pitkäkestoinen X-lukko avainarvoon 2 ja lyhytkestoinen X-lukko avainarvon 2 seuraajaan 3. Jälkimmäisen X-lukon varaus ei onnistu, vaan T 2 joutuu odottamaan T 1 :n varaaman S-lukon vapautumista, ts. T 1 :n sitoutumista (tai peruutuksen päättymistä). 237

Monirakeisen tietokannan avainvälilukitus Monirakeisen loogisen tietokannan tapauksessa avainvälilukituskäytäntöä sovelletaan kaikilla rakeisuustasolla. Lukkoja voidaan nyt varata (1) koko järjestelmään s, (2) järjestelmän tietokantoihin b, (3) tietokannan b relaatioihin r ja (4) tietokannan b relaation r monikoiden avainarvoihin x. Lukkojen nimet ovat vastaavasti s, b, (b,r) ja (b,r,x) (tai niistä lasketut hajautusarvot). Tietokannan b relaatioiden kaavioiden selailua R[b,r,θr,R ] varten transaktion T on varattava pitkäkestoinen S-lukko relaatioon (b,r ). Relaation luontia I[b, r, R] varten T :n on varattava pitkäkestoinen X-lukko relaatioon (b,r) ja lyhytkestoinen X-lukko relaatioon (b,r ), missä r on relaation r seuraaja tietokannassa b. Relaation poistoa D[b, r, R] varten T :n on varattava lyhytkestoinen X-lukko relaatioon (b,r) ja pitkäkestoinen X-lukko seuraajaan (b,r ). Näin estetään relaatioiden likaiset luonnit ja poistot sekä likaiset ja toistokelvottomat kaavioselailut (haamurelaatioineen). 238

Järjestelmän tietokantojen b tunniste- ja omistajatietojen selailua R[b,θb,w ] varten T :n on varattava pitkäkestoinen S-lukko tietokantaan b. Tietokannan luontia I[b, w] varten T :n on varattava pitkäkestoinen X-lukko tietokantaan b ja lyhytkestoinen X-lukko b:n seuraajaan b. Tietokannan hävitystä D[b, w] varten T :n on varattava lyhytkestoinen X-lukko tietokantaan b ja pitkäkestoinen X-lukko seuraajaan b. Näin estetään tietokantojen likaiset luonnit ja hävitykset sekä likaiset ja toistokelvottomat tietokantojen tunniste- ja omistajatietojen selailut (haamutietokantoineen). 239

Eristyvyysanomaliat on nyt määriteltävä myös kokonaisuuteen ja sen osiin kohdistuvien operaatioiden välille. Esim. transaktio T 1 luo tietokantaan b uuden relaation r tai poistaa relaation r. T 1 :n ollessa vielä aktiivinen toinen transaktio T 2 lukee relaation r monikon tai lisää r:ään monikoita tai poistaa r:stä monikoita. T 2 :n lukuoperaatio pitää määritellä likaiseksi luvuksi ja lisäys- ja poisto-operaatiot likaisiksi kirjoituksiksi. T 1 suojaa operaationsa varaamalla asianmukaiset X-lukot relaatioon (b,r) ja seuraajaan (b,r ). T 1 :n hankkiman X-lukon relaatioon (b,r) täytyy merkitä, että T 1 on X-lukinnut (implisiittisesti) myös kaikki r:n monikot. Vastaavasti relaatioon (b, r) hankitun S-lukon täytyy merkitä, että kaikki r:n monikot on S-lukittu. 240

Miten havaitaan relaatioon (b, r) ja avainarvoon (b, r, x) otettujen lukkojen yhteensopimattomuus? Lukkotaulu voitaisiin yrittää organisoida tietorakenteeksi, joka säilyttää rakeisuushierarkian polut: Kun transaktio T pyytää m-lukkoa relaatioon (b, r), lukonhallitsin tarkistaa, ettei millään toisella transaktiolla ennestään ole m:n kanssa yhteensopimatonta lukkoa tietoalkioihin s, b, (b,r) tai (b,r,x), missä x on jokin r:stä parhaillaan lukittuna oleva avainarvo. Tällaista järjestelyä ei ole mahdollista saada riittävän tehokkaaksi. Olemme sitä paitsi jo aiemmin todenneet, että tehokkuussyistä monikon avainarvoonkin varattavan lukon nimenä käytetään mieluummin avainarvosta laskettua lyhyttä (nelitavuista) hajautusarvoa kuin alkuperäistä (vaihtelevanmittaista) avainarvoa. 241

Aikomuslukot ja monirakeisuuslukitus Lähtökohtana on pidettävä, että kaikkia lukkoja säilytetään yhdessä ja samassa, lukittavan tietoalkion nimen mukaan indeksoidussa yksinkertaisessa hajautusrakenteessa. Rakeisuushierarkian eri tasoilla varattavien lukkojen yhteensopimattomuuden havaitsemiseksi otetaan käyttöön uusia lukkotyyppejä, ns. aikomuslukot (intention locks). Aikomuslukkotyyppejä on kolme: IS (lukuaikomuslukko), IX (kirjoitusaikomuslukko) ja SIX (kirjoitusaikomus- ja lukulukko). 242

(1) Aikomusyhteiskäyttöinen eli lukuaikomuslukko (intentionshared) IS: T :n IS-lukko kokonaisuuteen c merkitsee, että T :n on lupa varata c:n yksittäisiin osiin S-lukkoja (ja IS-lukkoja, mikäli c:n osatkin jakaantuvat vielä osiin). (2) Aikomuspoissuljettu eli kirjoitusaikomuslukko (intention-exclusive) IX: T :n IX-lukko kokonaisuuteen c merkitsee, että T :n on lupa varata c:n yksittäisiin osiin X- ja S-lukkoja (ja IX-, IS- ja SIX-lukkoja, mikäli c:n osatkin jakaantuvat vielä osiin). (3) Yhteiskäyttöinen ja aikomuspoissuljettu eli kirjoitusaikomus- ja lukulukko (shared and intention-exclusive) SIX: Lukko on S-lukon ja IX-lukon yhdelmä. T :n SIX-lukko kokonaisuuteen c merkitsee, että T :n on lupa lukea koko c (SIX:iin sisältyvän S-lukon turvin) ja hankkia c:n yksittäisiin osiin X- ja IX-lukkoja (SIX:iin sisältyvän IX-lukon turvin). 243

Kokonaisuuteen c varattu X-lukko lukitsee implisiittisesti X-lukolla kaikki c:n osat hienojakoisimpaan osaan asti ilman, että niitä tarvitsisi lukita eksplisiittisesti. Vastaavasti kokonaisuuteen c varattu S-lukko lukitsee implisiittisesti S-lukolla kaikki c:n osat hienojakoisimpaan osaan asti ilman, että niitä tarvitsisi lukita eksplisiittisesti. Monirakeisuuslukituskäytäntö (multiple-granularity locking protocol) yhdistettynä avainvälilukitukseen toimii seuraavasti. Kullakin rakeisuushierarkian tasolla noudatetaan avainvälilukituskäytäntöä. Kun transaktio T haluaa eksplisiittisesti lukita kokonaisuuden c d- kestoisella lukolla, täytyy sen ensin hankkia asianmukaiset d-kestoiset aikomuslukot jokaiseen kokonaisuuteen rakeisuushierarkian juuresta c:hen johtavalla polulla. 244

Esim. järjestelmän s tietokannan b relaation r avainarvolla x varustettu monikko X-lukitaan T :lle d-kestoisella lukolla operaatioin lock(t,s,ix,d); lock(t,(s,b),ix,d); lock(t,(s,b,r),ix,d); lock(t,(s,b,r,x),x,d). Lukot hankitaan siis aina ensin suurempaan kokonaisuuteen ja sitten vasta pienempään, rakeisuushierarkiaa noudattaen. T voi vapauttaa kokonaisuuteen c hankkimansa d-kestoisen lukon vain, jos T :llä ei ole c:n osiin enää yhtään d-kestoista lukkoa. Lukot vapautetaan siis rakeisuushierarkian käänteisjärjestyksessä: unlock(t,(s,b,r,x),d); unlock(t,(s,b,r),d); unlock(t,(s,b),d); unlock(t, s, d). 245

Monirakeisuuslukituksen lukkotyyppien yhteensopivuusmatriisi: Comp m 1 -lukko m 2 -lukko IS IX S SIX X IS true true true true false IX true true false false false S true false true false false SIX true false false false false X false false false false false 246

Lukonkorotusmatriisi: Upgr omistama pyytämä IS IX S SIX X IS IS IX S SIX X IX IX IX SIX SIX X S S SIX S SIX X SIX SIX SIX SIX SIX X X X X X X X Lukkotyyppien keskinäinen poissulkevuusjärjestys on osittaisjärjestys, tarkemmin sanottuna hila, jonka huipulla on X (poissulkevin lukkotyyppi) ja pohjalla IS (vähiten poissulkeva lukkotyyppi). IS < IX < SIX < X. IS < S < SIX < X. Lukkotyyppien IX ja S välillä ei ole järjestysrelaatiota; niiden pienin yhteinen yläraja hilassa on SIX. 247

Esimerkiksi seuraavat kaksi tilannetta ovat sallittuja monirakeisuuslukituskäytännössä: (1) Transaktiolla T 1 on IS-lukko relaatioon r ja S-lukko r:n monikon avainarvoon x. Samanaikaisesti transaktiolla T 2 on IX-lukko r:ään, S- lukko x:ään ja X-lukko r:n toisen monikon avainarvoon y, ja transaktiolla T 3 on IX-lukko r:ään ja X-lukko r:n kolmannen monikon avainarvoon z. T 1 : IS(r). T 2 : IX(r). T 3 : IX(r). T 1 : S(r,x). T 2 : S(r,x). T 2 : X(r,y). T 3 : X(r,z). (2) Transaktioilla T 1 ja T 2 on IS-lukot relaatioon r ja S-lukot r:n monikon avainarvoon x. Transaktiolla T 3 on samaan aikaan SIX-lukko r:ään ja X-lukko r:n toisen monikon avainarvoon y. T 1 : IS(r). T 2 : IS(r). T 3 : SIX(r). T 1 : S(r,x). T 2 : S(r,x). T 3 : X(r,y). 248

Esimerkki kielletystä tilanteesta: (3) Transaktiolla T 1 on IX-lukko relaatioon r ja X-lukko r:n monikon avainarvoon x. Samaan aikaan T 2 :lla on SIX-lukko r:ään. T 1 : IX(r). T 2 : SIX(r). T 1 : X(r,x). 249

Rakeisuushierarkia voi myös koostua fyysisen tietokannan osakokonaisuuksista tai sekaisin loogisista ja fyysisistä osakokonaisuuksista. Esim. järjestelmä, tietokanta, tiedosto, sivu, monikko. Yleensä ei aikomuslukkoja vaadita aivan hierarkian juuresta eli tietokantajärjestelmästä asti. Mikäli tietokannan luonti ja hävitys ovat käyttäjän transaktioiden ulkopuolisia, tietokannan valvojan toimintoja, ei tietokantatasokaan kuulu käyttäjän transaktion monirakeisuuslukituksen piiriin. Järjestelmän tietokannan valvojan oppaasta yleensä ilmenee, mihin kokonaisuuksiin minkäkintyyppisiä lukkoja varataan mitäkin operaatiota varten. 250

Looginen vs. fyysinen lukitus Looginen lukitus on luonnollinen, koska lukituksen tehtävänä on suojata transaktioiden loogisen tietokannan tietoalkioihin kohdistamat luku- ja päivitysoperaatiot. Looginen lukko ei millään tavoin riipu lukitun tietoalkion sijaintipaikasta fyysisessä tietokannassa. Loogisesti lukittua tietoalkiota voidaan siirrellä paikasta toiseen tarvitsematta tehdä mitään muutosta lukkoon: lukon nimi säilyy. Kun transaktion T loogisesti lukitsema monikko (x, v) B-puun lehtisivulla siirtyy joko T :n itsensä tai jonkin toisen transaktion aiheuttamassa rakennemuutoksessa toiselle sivulle T :n ollessa vielä aktiivisena, säilyy T :n lukko avainarvoon x muuttumattomana. 251

Tarvittava looginen lukko voidaan usein myös varata ennen kuin itse tietoalkio on paikannettu fyysisessä tietokannassa. Kirjoitusperaatiota W[x, u, v] varten tarvittava pitkäkestoinen X- lukko voidaan varata heti operaation suorituksen alkaessa, ennen kuin monikon (x,u) sijaintipaikka on selvitetty. Lisäysoperaatiota I[x, v] varten tarvittava pitkäkestoinen X-lukko voidaan sekin varata heti operaation suorituksen alkaessa, mutta avainarvon x seuraajaan tarvittava lyhytkestoinen X-lukko saadaan vasta, kun avainarvon x peittävä tietosivu on naulittu ja kirjoitussalvattu ja x:n seuraaja on selvitetty. Looginen lukitus voidaan perustaa monikon varsinaisen attribuuttiarvon sijasta myös järjestelmän tuottamaan loogiseen keinoavaimeen (surrogate), jollaisena voi olla esimerkiksi järjestysnumero, joka ilmoittaa, monentenako monikko on relaatioon lisätty. Keinoavaimeen perustuvassa lukituksessa lukko voidaan kuitenkin varata vasta, kun monikko on saatu kokonaisuudessaan esille ja keinoavainattribuuttiin päästy käsiksi. 252

Monissa järjestelmissä sovelletaan kuitenkin fyysistä lukitusta: lukitaan esim. tietosivuja tai tietosivuilla sijaitsevia tietuepaikkoja. Sivulukituksessa (page locking) lukon nimenä on sivutunniste tai siitä laskettu hajautusarvo. Tietosivuun p varattu lukko lukitsee kaikki sivulla p sijaitsevat tai sille kuuluvat loogisen tietokannan tietoalkiot. Tietuelukituksessa (record locking) eli tietuetunnistelukituksessa (RID locking) lukon nimenä on tietuetunniste, siis sivutunnisteen ja tietuepaikan indeksin muodostama pari (p, i), tai siitä laskettu hajautusarvo. Tietuetunnisteeseen (p, i) varattu lukko lukitsee sivun p tietuepaikassa i olevan tai siihen kuuluvan tietoalkion. Tietuelukitus vastaa rakeisuudeltaan yksilöivän avaimen lukitusta. Sivulukitus on tarpeettoman karkearakeista, mikäli operoinnin kohteena on vain yksittäinen tietue sivulla. 253

Sivu- tai tietuelukko voidaan varata vasta, kun operoinnin kohteena olevan tietoalkion sijaintipaikka on selvitetty. Transaktion T omistamia sivu- tai tietuelukkoja on muutettava, jos tietoalkioita siirretään toiseen paikkaan T :n ollessa aktiivisena. Esim. T lisää joukon monikoita relaatioon, jonka rakenteena on harva B-puu. Lehtisivun täytyttyä osa sivun monikoista siirretään toiselle sivulle. Hienorakeista fyysistä lukitusta (tietuelukitusta) käytettäessä monikot on syytä sijoittaa sellaiseen perusrakenteeseen (esim. kasaan), jossa niiden sijainti ei muutu normaaleissa päivitysoperaatioissa. Perusrakenteeseen luodaan tiheä hakemisto, esim. tiheä B-puu, jonka lehtisivut sisältävät monikoihin osoittavia tietueita. Perusrakenteen uudelleen järjestelyä varten taas varataan tietueiden sijainnista riippumaton karkearakeinen lukko (relaatiolukko). 254

Lukkiumat Lukitukseen perustuvassa samanaikaisuuden hallintakäytännössä voi esiintyä lukkiumia (deadlock). Olkoot T 1 ja T 2 aktiivisia transaktioita. 1. T 1 lukee tietoalkion x; sitä varten T 1 varaa S-lukon x:ään. 2. T 2 lukee tietoalkion y; sitä varten T 2 varaa S-lukon y:hyn. 3. T 1 haluaa päivittää y:tä; sitä varten T 1 pyytää X-lukkoa y:hyn. Lukkoa ei voida myöntää välittömästi, vaan T 1 joutuu odottamaan T 2 :n varaaman lukon vapautumista. 4. T 2 haluaa päivittää x:ää; sitä varten T 2 pyytää X-lukkoa x:ään. Lukkoa ei voida myöntää välittömästi, vaan T 2 joutuu odottamaan T 1 :n varaaman lukon vapautumista. Kumpikin transaktio joutuu odottamaan toistaan ikuisesti. Tässä lukkiuma johtuu siitä, että kaksi transaktiota operoi kahteen monikkoon eri järjestyksissä ja lukitsee tietoalkiot yhteensopimattomilla lukoilla. 255

Myös lukon korotus lukulukosta kirjoituslukoksi voi johtaa lukkiumaan: 1. T 1 lukee tietoalkion x; sitä varten T 1 varaa S-lukon x:ään. 2. Myös T 2 lukee x:n; sitä varten T 2 varaa S-lukon x:ään. 3. T 1 haluaa päivittää x:ää; sitä varten T 1 pyytää S-lukkonsa korotusta X-lukoksi. Korotusta ei voida myöntää välittömästi, vaan T 1 joutuu odottamaan T 2 :n varaaman lukon vapautumista. 4. Myös T 2 haluaa päivittää x:ää; sitä varten T 2 pyytää S-lukkonsa korotusta X-lukoksi. Korotusta ei voida myöntää välittömästi, vaan T 2 joutuu odottamaan T 1 :n varaaman lukon vapautumista. 256

Itse asiassa lukon korotus on käytännössä tärkein lukkiuman syy. Seuraava toimintosarja näet esiintyy transaktioissa hyvin usein. 1. Varataan S-lukko monikon tietoalkioon x ja luetaan monikko. 2. Tutkitaan, pitääkö tietoalkiota päivittää. 3. Jos tietoalkiota pitää päivittää, korotetaan x:n S-lukko X-lukoksi ja suoritetaan päivitys. Jos tietoalkio on ns. hotspot-tietoalkio eli sitä päivitetään hyvin usein eri transaktioista, on lukkiuman vaara suuri. 257

Yleisesti: järjestelmä on lukkiutunut (in deadlock), jos joillekin aktiivisille transaktioille T 1,..., T n pätee: T 1 odottaa pääsyä T 2 :n varaamaan tietoalkioon. T 2 odottaa pääsyä T 3 :n varaamaan tietoalkioon. T n odottaa pääsyä T 1 :n varaamaan tietoalkioon. Tällainen toisiaan odottavien transaktioiden sykli voi syntyä ainoastaan lukituskäytännöissä. Aikaleimakäytännöissä (timestamp protocol) ei lukkiumia voi esiintyä, koska myöhästyneet operaatiot ratkaistaan peruuttamalla operaatiota yrittävä transaktio. Lukkiuman sattuessa jokin lukkiutuneista transaktioista täytyy peruuttaa. Lukkiumien käsittelyssä on kaksi peruslähestymistapaa: (1) Lukkiuman havaitsemis- ja purkumenetelmä (deadlockdetection and recovery scheme). (2) Lukkiumat estävä käytäntö (deadlock-prevention protocol). 258

Lukkiumien havaitseminen Tarkastellaan lukkiuman havaitsemismenetelmiä. Perusratkaisuna on pitää yllä toisiaan odottavien transaktioiden odotusverkkoa (wait-for graph). Odotusverkkoon lisätään kaari T T, kun transaktio T pyytää lukkoa transaktion T varaamaan tietoalkioon ja joutuu odottamaan. Verkosta poistetaan kaari T T, kun T ei enää odota pääsyä mihinkään T :n varaamaan tietoalkioon. Järjestelmä on lukkiutunut silloin ja vain silloin, kun odotusverkko on syklinen. Lukkiuman havaitsemiseksi on aika ajoin käynnistettävä algoritmi, joka tutkii, onko odotusverkossa syklejä. Lukkiuma puretaan peruuttamalla sykleihin sisältyviä transaktioita, kunnes odotusverkossa ei enää ole syklejä. 259

Esimerkki lukkiuman sisältävästä odotusverkosta: T 1 T 2 T 3 T 4 T 5 T 6 T 7 T 8 T 9 T 10 T 11 260

Ehdolliset lukkopyynnöt Transaktioiden tietokannan tietoalkioihin varaaminen lukkojen ohella tietokantajärjestelmän lukkiuman syynä voivat olla myös transaktioita tuottavien prosessien varaamat salvat tietokannan sivuihin. Esim. transaktiota T 1 tuottava palvelinprosessin säie lukusalpaa sivun p ja transaktiota T 2 tuottava säie lukusalpaa sivun q. Sitten T 1 :tä tuottava säie pyytää kirjoitussalpaa q:hun ja T 2 :ta tuottava säie kirjoitussalpaa p:hen. 261

Lukkiumia voi syntyä myös lukkojen ja salpojen kesken. Esim. T 1 on suorittanut tietosivulle p operaation I[x,v] ja sitä varten lukinnut avainarvon x pitkäkestoisella X-lukolla; T 1 :tä tuottava säie on vapauttanut p:n kirjoitussalvan. T 2 haluaa suorittaa operaation R[x,> z,v]. Sen vuoksi T 2 :tä tuottava säie lukusalpaa p:n, määrää hakuehdon täyttävän avainarvon x ja pyytää sitten T 2 :lle S-lukkoa x:ään. Koska x on X-lukittu T 1 :lle, T 2 :ta tuottava säie joutuu odottamaan. T 1 on vielä aktiivinen ja haluaa suorittaa operaation I[y,w], missä avainarvon y peittävä tietosivu on sekin p. Sen vuoksi T 1 :ta tuottava säie pyytää kirjoitussalpaa p:hen. Koska p on lukusalvattuna T 2 :ta tuottavalle säikeelle, T 1 :tä tuottava säie joutuu odottamaan. 262

Salpojen varauksen ja vapautuksen täytyy olla mahdollisimman nopeata. Sen vuoksi normaali käytäntö on, ettei prosessien varaamista salvoista pidetä yllä odotusverkkoa mahdollisten lukkiumien havaitsemiseksi. Prosessien noudattaman salpauskäytännön täytyy siis olla lukkiumat estävä. Jos prosessi tai säie joutuu pitämään samalla kertaa useampaa kuin yhtä sivua salvattuna (esim. B-puussa isä- ja lapsisivua), on salvat varattava aina samassa järjestyksessä (isäsivun salpa ensin lapsisivun salpaa). Salpojen ja lukkojen keskiset lukkiumat estetään vaatimalla, ettei prosessi (tai säie) saa koskaan pitää hallussaan salpaa mihinkään sivuun silloin, kun prosessin (tai säikeen) tuottama transaktio jotain lukkoa pyydettyään joutuu odottamaan. Transaktiota tuottavalle prosessille (tai säikeelle) sallitaan siis lukon odotus vain, jos sillä ei ole hallussaan yhtään salpaa. 263

Menettely vaatii, että lukonhallitsin pystyy käsittelemään tavanomaisten ehdottomien (ja niin muodoin mahdollisesti odotukseen johtavien) lukkopyyntöjen lisäksi myös ehdollisia lukkopyyntöjä (conditional lock request): Transaktiota T tuottava säie voi kutsulla conditionally-lock(t, x, m, d) pyytää T :lle ehdollisesti d-kestoista m-lukkoa tietoalkioon x, jolloin lukko myönnetään vain, jos se voidaan myöntää välittömästi, ts. x ei ole parhaillaan lukittuna m:n kanssa yhteensopimattomalla lukolla millekään toiselle transaktiolle. Muutoin lukonhallitsin vastaa T :n pyyntöön, ettei pyydettyä lukkoa voida myöntää. 264

Relaation avainväliselauksen toteutus Oletetaan, että looginen tietokanta jakaantuu relaatioihin ja että jokaisen relaation fyysisenä rakenteena on relaation pääavaimeen perustuva harva B-puu (sparse primary B-tree), jonka lehtisivut ovat relaation tietosivut eli siis sisältävät r:n monikot. Lehtisivut on linkitetty sivuttaissuunnassa vasemmalta oikealle niin, että kunkin lehtisivun otsikkotietueessa on sivun seuraajasivun tunniste. Tarkastellaan luku- tai päivitysoperaatiota, joka kohdistuu relaation r(x,v ) tietylle avainvälille (x,y). Kun relaation tunniste r ja avainarvo x on annettu, kutsu traversefor-read(r, x, p) konttaa r:n B-puussa lukusalvoin avainarvon x peittävälle lehtisivulle p; kutsusta palattaessa p on lukusalvattu. Kutsu traverse-for-update(r, x, p) konttaa r:n B-puussa lukusalvoin avainarvon x peittävälle lehtisivulle p siten, että sivulle p varataan lukusalvan asemesta kirjoitussalpa. 265

Avainväliselausta varten asiakassovellusta palveleva palvelinprosessin säie luo keskusmuistiin kohdistinrakenteen (cursor structure) c, joka sisältää mm. seuraavat komponentit: (1) Selattavan relaation tunniste c.relation. (2) Selausvuorossa olevan sivun tunniste c.page-id. (3) Selausvuorossa olevan sivun Page-LSN c.page-lsn. (4) Selausvuorossa oleva avainarvo c.key-value. Näitä tietoja tarvitaan, kun selausvuorossa olevan sivun salpa joudutaan selauksen kuluessa välillä vapauttamaan. Näin tapahtuu, kun ehdollinen lukkopyyntö ei johda lukon varaamiseen tai kun selausvuorossa olevan monikon päivittäminen riippuu sovellusohjelmassa laskettavasta ehdosta. 266

Tarkastellaan transaktion T suorittamaa SQL-kyselyä, jossa luetaan kaikki avainvälin (y,z) monikot: select from r where y < X and X < z Kysely tuottaa jonon monikoiden lukuoperaatioita: R[x 1,> y,v 1 ]R[x 2,> x 1,v 2 ]...R[x n, x n 1,v n ]. Oletetaan, että kyselynoptimoija on arvioinut luettavien monikoiden lukumäärän niin pieneksi, että monikkorakeista lukintaa kannattaa käyttää. 267

1. Lock(T, r, IS, commit-duration). Luo kohdistin c relaation r selausta varten; c.relation := r; c.key-value := y. 2. Traverse-for-read(r, y, p). 3. c.page-id := p; c.page-lsn := Page-LSN(p). 4. Suorita jokaiselle ehdon y < x < z täyttävälle sivun p avainarvolle x kutsu conditionally-lock(t, (r, x), S, commit-duration). Jos sivu p peittää välin (y,z) seuraajan z, suorita lisäksi kutsu conditionallylock(t, (r,z ), S, commit-duration) (tässä z =, jos avainarvoavaruus luettiin loppuun). Jos jokin näistä kutsuista ei johda lukon myöntämiseen, niin ul(p) ja suorita kutsu lock(t, (r, x), S, commit-duration) kyseisille avainarvoille x ja siirry askeleeseen 7. 5. Tulosta sivulta p ehdon y < x < z täyttävillä avainarvoilla x varustetut monikot. Aseta c.key-value := x, missä x on suurin palautettu avainarvo. 6. Jos väli (y,z) on luettu loppuun, niin ul(p) ja lopeta. Muutoin q := p:n seuraajasivun page-id, rl(q), ul(p), p := q ja siirry askeleeseen 3. 7. p := c.page-id; rl(p); y := c.key-value. Jos Page-LSN(p) = c.page-lsn tai jos p on edelleen r:n tietosivu ja p:n nähdään peittävän y:n, niin siirry askeleeseen 4. Muutoin ul(p) ja siirry askeleeseen 2. 268

Tarkastellaan sitten transaktion T päivitysoperaatiota, jossa luetaan relaation r(x,v ) avainvälin (y, z) monikot ja päivitetään niistä joitakin. exec sql declare c cursor for select from r where :y < X and X < :z for update; exec sql open c; while (true) { exec sql fetch c into :x, :v; if (sqlstate = monikoita riittää ) if ((:x, :v) täyttää ehdon C(:x, :v)) exec sql update r set V = E(:v) where current of c; else break }. 269

Oletetaan, että kyselynoptimoija on arvioinut välin (y, z) monikoiden lukumäärän niin pieneksi, että relaatioon kannattaa varata IXlukko SIX-lukon asemesta. Lauseen exec sql open c toteutus: 1. Lock(T, r, IX, commit-duration). Luo kohdistin c relaation r selausta varten; c.relation := r; c.key-value := y. 2. Traverse-for-update(r, y, p). 3. c.page-id := p; c.page-lsn := Page-LSN(p); ul(p). 270

Lauseen exec sql fetch c into :x, :v toteutus: 1. y := c.key-value; p := c.page-id; wl(p). Jos Page-LSN(p) = c.page-lsn tai jos p on edelleen r:n tietosivu ja p:n nähdään peittävän y:n, niin siirry askeleeseen 4. 2. ul(p); traverse-for-update(r,y, p). 3. c.page-id := p; c.page-lsn := Page-LSN(p). 4. Määrää pienin ehdon y < x < z täyttävä avainarvo x sivulla p. Mikäli tällainen avainarvo x löytyy, siirry askeleeseen 6. 5. Jos välin (y, z) monikoita voi olla p:n seuraajasivulla q, niin wl(q), ul(p), p := q ja siirry askeleeseen 3. Muutoin x := välin (y,z) seuraaja (mahdollisesti ) ja conditionally-lock(t, (r, x), S, commit-duration). Jos lukko myönnetään, aseta sqlstate := monikot loppu, ul(p) ja lopeta. Muutoin ul(p), lock(t, (r,x), S, commit-duration) ja siirry askeleeseen 1. 6. Conditionally-lock(T,(r,x),S,commit-duration). Jos lukko myönnetään, (x, v) := avainarvolla x varustettu monikko sivulta p, ul(p), c.key-value := x, c.page-lsn := Page-LSN(p), aseta sqlstate := monikoita riittää ja palauta (x,v). Muutoin ul(p), lock(t, (r,x), S, commitduration) ja siirry askeleeseen 1. 271

Lauseen exec sql update r set V = E(:v) where current of c toteutus: 1. x := c.key-value; lock(t,(r, x),x,commit-duration); p := c.pageid; wl(p). 2. Jos Page-LSN(p) = c.page-lsn tai jos p on edelleen avainarvolla x varustetun monikon sisältävä r:n tietosivu, niin siirry askeleeseen 5. 3. ul(p); traverse-for-update(r,x, p). 4. c.page-id := p; c.page-lsn := Page-LSN(p). 5. Korvaa sivulla p tietuepaikassa i oleva monikko (x, v) monikolla (x,v ), missä v = E(:v). 6. log(n, T,W, p,i,x,v,v,n ), missä n = Undo-Next-LSN(T ); Undo-Next-LSN(T ) := n; Page-LSN(p) := n; ul(p). 272