{"canonical_url":"https://engineer.company/nb/glossary/transaction/","content_markdown":"# Transaksjon\n\n## Hva det er\n\nEn transaksjon er en gruppe endringer som en database utfører som én enhet:\nenten får alle virkning, eller så får ingen av dem det. Når den må holdes\nadskilt fra en betaling, som også kalles en transaksjon, skriver folk\ndatabasetransaksjon. PostgreSQL-veiledningen forklarer det slik: flere steg\nsamles i én operasjon der alt eller ingenting skjer, og ingen andre ser noe av\ndet som ligger imellom.\n\nI PostgreSQL åpnes en transaksjon med `BEGIN` og avsluttes enten med `COMMIT`,\nsom gjør endringene permanente og synlige for andre økter, eller med `ROLLBACK`,\nsom forkaster dem. En setning som sendes alene, kjører også inne i en\ntransaksjon: PostgreSQL legger en implisitt `BEGIN` rundt den og, hvis den\nlykkes, en implisitt `COMMIT`. En lang transaksjon kan sette et lagringspunkt\nmed `SAVEPOINT` og senere gå tilbake til det med `ROLLBACK TO`, slik at arbeidet\netter punktet forkastes mens alt før det beholdes.\n\nGarantiene en transaksjon gir, oppsummeres som ACID. Atomisitet betyr at\ntransaksjonen fullføres som én enhet eller ikke i det hele tatt, og at ikke noe\nhalvferdig resultat overlever et krasj. Konsistens betyr at integritetsreglene\nsom er definert på dataene, holder når den committes, og at en transaksjon som\nville brutt en av dem, rulles tilbake i stedet. Isolasjon betyr at endringene er\nusynlige for samtidige transaksjoner til den er committet. Varighet betyr at en\ncommittet endring overlever at serveren krasjer.\n\nIsolasjon kommer i nivåer, og SQL-standarden definerer fire: Read Uncommitted, Read Committed, Repeatable Read og Serializable. PostgreSQL starter hver transaksjon på Read Committed med mindre noe annet er angitt, og Read Uncommitted oppfører seg der nøyaktig som Read Committed. På Read Committed ser hver setning dataene som var committet før setningen startet, så to spørringer i samme transaksjon kan se forskjellige tall. På Repeatable Read arbeider hele transaksjonen ut fra ett øyeblikksbilde, tatt når den første setningen som ikke er en transaksjonskontrollsetning, kjører. Serializable går lenger og sørger for at samtidige transaksjoner gir samme resultat som om de hadde kjørt én etter én.\n\n## Hvorfor det er viktig\n\nNesten enhver handling som er verdt å registrere, berører mer enn én rad. En\nordre er en rad i én tabell, en nedtelling av lageret i en annen og en post i en\nhovedbok. Uten transaksjon kan et krasj, et tidsavbrudd eller en brutt\nintegritetsregel mellom andre og tredje setning etterlate en ordre der lageret\naldri ble trukket, eller lager trukket for en ordre som ikke finnes. Så finner\nnoen det i en rapport og retter det for hånd. Med en transaksjon finnes den\nhalve tilstanden aldri for noen å se, og det er databasen, ikke applikasjonen,\nsom garanterer det.\n\nDen andre grunnen er samtidighet. To forespørsler som kommer samtidig, kjører\nside om side, og isolasjonsnivået avgjør hva hver av dem ser, mens låser avgjør\nhvem som venter. Her blir team oftest overrasket: å pakke kode inn i `BEGIN` og\n`COMMIT` hindrer ikke i seg selv at to forespørsler leser samme saldo og begge\nbruker den. På Read Committed leser hver setning det som var committet da den\nstartet, så en sjekk i én setning og en skriving i den neste kan skilles av en\ncommit fra en annen økt. Sjekken må enten låse raden først eller bli en del av\nskrivingen.\n\nTransaksjoner har også en pris, og den betales i tid. Radlåser som tas av `UPDATE`, `DELETE` og `SELECT ... FOR UPDATE`, varer normalt til transaksjonen avsluttes; en tilbakerulling til et lagringspunkt frigir låser tatt etter det lagringspunktet. En økt som vil ha en motstridende lås, må vente med mindre et tidsavbrudd, en avbrytelse eller løsning av en vranglås stopper ventingen. En åpen transaksjon hindrer også `VACUUM` i å fjerne gamle radversjoner den fortsatt kan trenge å se, så en transaksjon som står åpen i timevis, får tabellene til å svulme opp. Designspørsmålet er derfor aldri bare om man skal bruke en transaksjon, men hvor grensene går og hvor lite som skjer mellom dem.\n\nTil slutt omfatter ikke en vanlig lokal databasetransaksjon i seg selv eksterne virkninger. Et kall til en betalingsleverandør, en e-post eller en melding publisert på en separat kø blir ikke ugjort ved å rulle databasen tilbake. Koordinering med andre systemer krever ytterligere utforming; en omsluttende `BEGIN` er ikke nok. Å bestemme hva som skal ligge innenfor grensen, og hvordan verden utenfor får vite om en commit, er det meste av arbeidet med å utforme en transaksjon.\n\n## Slik ser det ut i praksis\n\nEt medlem av et lojalitetsprogram bruker 250 poeng på en kinobillett. Tre ting\nmå skje sammen: lommeboken mister poengene, hovedboken registrerer hvorfor, og\ninnløsningen opprettes. Skrevet som én transaksjon ser det slik ut:\n\n```sql\nBEGIN;\n\nUPDATE wallet\nSET    points = points - 250\nWHERE  member_id = 42\nAND    points \u003e= 250\nRETURNING points;\n-- ingen rad tilbake: for få poeng, så ROLLBACK og stopp her\n\nINSERT INTO points_entry (member_id, delta, reason)\nVALUES (42, -250, 'innløst: kinobillett');\n\nINSERT INTO redemption (member_id, reward_id)\nVALUES (42, 7);\n\nCOMMIT;\n```\n\n`UPDATE` tar en radlås på lommeboken til medlem 42. Fram til `COMMIT` ser enhver\nannen økt som leser lommeboken, fortsatt den gamle saldoen, fordi radlåser ikke\nblokkerer lesere og endringer som ikke er committet, er usynlige. En ny\ninnløsning for samme medlem, sendt fra en annen fane et øyeblikk senere, når sin\negen `UPDATE` og venter. Når den første transaksjonen committes, evaluerer\nPostgreSQL på Read Committed `WHERE`-betingelsen til den andre på nytt mot raden\nslik den står nå. Er det bare 100 poeng igjen, er betingelsen ikke oppfylt,\ningen rad kommer tilbake, og den andre forespørselen rulles tilbake uten å ha\nskrevet noe. Feiler i stedet den siste `INSERT`, for eksempel fordi belønning 7\ner trukket tilbake og en fremmednøkkel avviser den, ruller klienten tilbake, og\npoengene er nøyaktig der de var.\n\nDette er formen på\n[lojalitetslommeboken med ligaer](/nb/portfolio/built-a-loyalty-wallet-leagues-and-badges/).\nHver endring der tar en radlås på lommeboken før den leses, slik at den andre\nforespørselen venter til den første er ferdig i stedet for å kappes med den, og\nfordi lommeboken ligger i samme database som alt annet, committes saldoen og det\nden kjøpte, sammen eller ikke i det hele tatt. Siden legger ikke skjul på\nprisen: radlåsing er det tregere svaret, og skrivingene må vente på tur, men\nalternativet er et medlem som bruker de samme poengene to ganger.\n\nNotatet om\n[å selge den siste billetten nøyaktig én gang](/nb/notes/selling-limited-stock-without-overselling/)\nsetter det samme verktøyet på prøve under et lynsalg. Løsningen der gjør sjekken\nog nedtellingen til én betinget `UPDATE`, fordi en lås som holdes mens\napplikasjonen tenker mellom en `SELECT` og en `UPDATE`, får den neste kjøperen\ntil å vente hvert eneste millisekund av det. Først på listen over resten av\narbeidet står å holde alt eksternt utenfor transaksjonen: et betalingskall, en\nHTTP-forespørsel eller en publisert melding hører hjemme før den eller etter\nden.\n\n## Hvor det går galt\n\n**En økt står inaktiv i en transaksjon, og alt bak den må vente.** En applikasjon åpner en transaksjon, oppdaterer en rad og venter så på et tregt API, på brukerens neste klikk eller på en bakgrunnsprosess som krasjet uten å sende `COMMIT`. Låsene blir stående, og med tidsavbrudd slått av lar PostgreSQL en økt som vil ha en motstridende lås, vente på ubestemt tid med mindre den oppdager en vranglås eller ventingen avbrytes. Dokumentasjonen kaller det en dårlig idé å holde en transaksjon åpen mens man venter på input fra brukeren. `pg_stat_activity` viser disse øktene med tilstanden `idle in transaction`, og `xact_start` forteller når transaksjonen begynte:\n\n```sql\nSELECT pid, now() - xact_start AS open_for, state, query\nFROM pg_stat_activity\nWHERE state LIKE 'idle in transaction%'\nORDER BY xact_start;\n```\n\nFlytt det trege arbeidet ut av transaksjonen, og gi serveren en grense slik at\nen glemt transaksjon ikke kan holde låser i timevis.\n`idle_in_transaction_session_timeout` avslutter enhver økt som har stått inaktiv\ni en åpen transaksjon lenger enn verdien. Standardverdien er 0, som slår den av,\nså den må settes, for eksempel for applikasjonens rolle med\n`ALTER ROLE app SET idle_in_transaction_session_timeout = '30s';`.\n\n**To forespørsler bruker den samme saldoen.** Koden leser en verdi i én setning,\nbestemmer seg i applikasjonen og skriver resultatet i en annen. To økter leser\nsamme tall, begge består sjekken, og begge skriver, så den ene endringen\noverskriver den andre uten et ord. En `BEGIN` rundt det hele hindrer det ikke på\nRead Committed. Gjør sjekken til en del av skrivingen med en betingelse i\n`UPDATE`, som i eksempelet over, eller lås raden før den leses med\n`SELECT ... FOR UPDATE`, slik at den andre økten venter på den første.\n\n**Feil dukker opp under last på Repeatable Read eller Serializable.** På disse\nnivåene avviser PostgreSQL en transaksjon som ville brutt nivåets løfte, og\nmelder en serialiseringsfeil, SQLSTATE `40001`, med meldinger som\n`could not serialize access due to concurrent update`. Slik er det ment å virke,\nog dokumentasjonen sier rett ut at applikasjoner som bruker disse nivåene, må\nvære forberedt på å prøve igjen. Fang `40001`, og kjør hele transaksjonen på\nnytt fra `BEGIN`, lesingene inkludert, siden avgjørelsen den tok, bygde på data\nsom har endret seg siden. Prøver man bare setningen som feilet på nytt, gjentar\nman feilen.\n\n**To transaksjoner havner i vranglås (deadlock).** Den ene låser ordre 1 og så\nordre 2, den andre låser ordre 2 og så ordre 1, og hver venter på den andre.\nPostgreSQL oppdager sirkelen og avbryter én av transaksjonene slik at den andre\nkan bli ferdig, og hvilken den velger, er vanskelig å forutsi. Forsvaret\ndokumentasjonen anbefaler, er at alle kodestier tar låser i samme rekkefølge,\nfor eksempel ved å oppdatere rader i stigende rekkefølge etter primærnøkkel, og\nat en transaksjon som ble avbrutt på grunn av vranglås, prøves på nytt.\n\n**En e-post går ut for en ordre som ble rullet tilbake.** Applikasjonen sender\nen bekreftelse eller publiserer en hendelse inne fra transaksjonen, og så feiler\nen senere setning. Rollbacken fjerner ordren, men ingenting kan kalle tilbake\ne-posten. Skriv meldingen i en outbox-tabell i samme transaksjon som endringen\nden beskriver, og la en egen prosess sende den når commiten har skjedd. Da\nfinnes meldingen nøyaktig når ordren gjør det.\n\n## Les mer\n\n- [Transactions](https://www.postgresql.org/docs/current/tutorial-transactions.html)\n  — kapittelet i PostgreSQL-veiledningen: alt-eller-ingenting-oppførsel,\n  implisitte transaksjoner og lagringspunkter, vist med en bankoverføring.\n- [Transaction Isolation](https://www.postgresql.org/docs/current/transaction-iso.html)\n  — de fire standardnivåene, hva hvert av dem ser i PostgreSQL, og\n  serialiseringsfeilene som krever et nytt forsøk.\n- [Explicit Locking](https://www.postgresql.org/docs/current/explicit-locking.html)\n  — rad- og tabellåser, hvor lenge de holdes, og hvordan vranglåser oppdages og\n  unngås.\n- [Client Connection Defaults](https://www.postgresql.org/docs/current/runtime-config-client.html)\n  — `default_transaction_isolation`, `idle_in_transaction_session_timeout`,\n  `lock_timeout` og de andre grensene for en økt.\n- [Routine Vacuuming](https://www.postgresql.org/docs/current/routine-vacuuming.html)\n  — hvorfor gamle radversjoner blir liggende så lenge en transaksjon fortsatt\n  kan se dem, og hva lange åpne transaksjoner gjør med oppryddingen.\n\n\u003chttps://engineer.company/nb/glossary/transaction/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hvordan en databasetransaksjon får flere endringer til å telle som én: commit og rollback, isolasjonsnivåer, radlåser og fem måter det går galt på.","formats":{"gemtext":"https://engineer.company/nb/glossary/transaction/index.gmi","gopher":"https://engineer.company/nb/glossary/transaction/gophermap","html":"https://engineer.company/nb/glossary/transaction/","json":"https://engineer.company/nb/glossary/transaction/index.json","markdown":"https://engineer.company/nb/glossary/transaction/index.md","pdf":"https://engineer.company/nb/glossary/transaction/index.pdf"},"kind":"page","language":"nb","title":"Hva er en transaksjon?","url":"https://engineer.company/nb/glossary/transaction/","version":1}