{"canonical_url":"https://engineer.company/da/glossary/transaction/","content_markdown":"# Transaktion\n\n## Hvad det er\n\nEn transaktion er en gruppe ændringer, som en database udfører som én enhed:\nenten får de alle virkning, eller også gør ingen af dem. Man skriver\ndatabasetransaktion, når det skal være tydeligt, at der ikke er tale om en\nbetaling, som også kaldes en transaktion. PostgreSQL's tutorial beskriver den\nsom en alt-eller-intet-operation, der samler flere trin til ét, og ingen andre\nkan se tilstandene undervejs.\n\nI PostgreSQL begynder en transaktion med `BEGIN` og slutter enten med `COMMIT`,\nder gør ændringerne permanente og synlige for andre sessioner, eller med\n`ROLLBACK`, der kasserer dem. En sætning, der sendes alene, kører også i en\ntransaktion: PostgreSQL omgiver den med et implicit `BEGIN` og, hvis den lykkes,\net implicit `COMMIT`. En lang transaktion kan sætte et `SAVEPOINT` og senere\nvende tilbage til det med `ROLLBACK TO`, så arbejdet siden da forkastes, mens\nalt før bevares.\n\nDe garantier, en transaktion giver, kaldes under ét ACID. Atomicitet betyder, at\ntransaktionen gennemføres som én enhed eller slet ikke, og at intet halvfærdigt\nresultat overlever et nedbrud. Konsistens betyder, at de constraints, der er\nerklæret på dataene, holder, når den committer, og at en transaktion, der ville\nbryde en af dem, rulles tilbage i stedet. Isolation betyder, at dens ændringer\ner usynlige for samtidige transaktioner, indtil den committer. Holdbarhed\nbetyder, at en committet ændring overlever, at serveren går ned.\n\nIsolation findes i flere niveauer, og SQL-standarden definerer fire: Read Uncommitted, Read Committed, Repeatable Read og Serializable. PostgreSQL starter hver transaktion på Read Committed, medmindre andet er angivet, og dens Read Uncommitted opfører sig præcis som Read Committed. På Read Committed ser hver sætning de data, der var committet, før netop den sætning begyndte, så to forespørgsler i samme transaktion kan se forskellige tal. På Repeatable Read arbejder hele transaktionen ud fra ét øjebliksbillede, taget når dens første sætning, som ikke styrer transaktionen, kører. Serializable går videre og får samtidige transaktioner til at give samme resultat, som hvis de var kørt én ad gangen.\n\n## Hvorfor det betyder noget\n\nNæsten enhver handling, der er værd at registrere, rører mere end én række. En\nordre er en række i én tabel, en nedskrivning af lageret i en anden og en\npostering i en hovedbog. Uden en transaktion kan et nedbrud, en timeout eller en\nconstraint, der fejler mellem anden og tredje sætning, efterlade en ordre, hvis\nvarer aldrig blev trukket fra lageret, eller varer trukket fra til en ordre, der\nikke findes. Nogen opdager det senere i en rapport og retter det i hånden. Med\nen transaktion opstår den halve tilstand aldrig for nogen at se, og det er\ndatabasen, ikke applikationen, der står inde for det.\n\nDen anden grund er samtidighed. To requests, der ankommer på samme tid, kører\nside om side, og isolationsniveauet afgør, hvad hver af dem ser, mens låse\nafgør, hvem der må vente. Her bliver teams oftest overraskede: at pakke koden\nind i `BEGIN` og `COMMIT` forhindrer ikke i sig selv, at to requests læser den\nsamme saldo og begge bruger den. På Read Committed læser hver sætning det, der\nvar committet, da den startede, så et tjek i én sætning og en skrivning i den\nnæste kan blive skilt ad af en anden sessions commit. Tjekket skal enten låse\nrækken først eller være en del af selve skrivningen.\n\nTransaktioner har også en pris, og den betales i tid. Rækkelåse fra `UPDATE`, `DELETE` og `SELECT ... FOR UPDATE` holdes normalt, til transaktionen slutter; en rollback til et savepoint frigiver låse, der blev taget efter det savepoint. En session, der ønsker en modstridende lås, må vente, medmindre en tidsoverskridelse, en annullering eller løsningen af en deadlock afbryder ventningen. En åben transaktion forhindrer desuden `VACUUM` i at fjerne gamle rækkeversioner, som den stadig kan få brug for at se, så en transaktion, der står åben i timevis, lader tabellerne svulme op. Spørgsmålet er derfor aldrig kun, om man skal bruge en transaktion, men hvor dens grænser skal gå, og hvor lidt der sker mellem dem.\n\nEndelig omfatter en almindelig lokal databasetransaktion ikke i sig selv eksterne virkninger. Et kald til en betalingsudbyder, en e-mail eller en besked sendt til en separat kø trækkes ikke tilbage ved at rulle databasen tilbage. Koordinering med andre systemer kræver et yderligere design; en omgivende `BEGIN` er ikke nok. At afgøre, hvad der hører til inden for grænsen, og hvordan omverdenen får besked om et commit, er det meste af arbejdet, når man designer en transaktion.\n\n## Sådan ser det ud i praksis\n\nEt medlem af en loyalitetsordning bruger 250 point på en biografbillet. Tre ting\nskal ske samlet: walleten mister pointene, en postering registrerer hvorfor, og\nindløsningen oprettes. Skrevet som én transaktion ser det sådan ud:\n\n```sql\nBEGIN;\n\nUPDATE wallet\nSET    points = points - 250\nWHERE  member_id = 42\nAND    points \u003e= 250\nRETURNING points;\n-- ingen række tilbage: for få point, så ROLLBACK og stop her\n\nINSERT INTO points_entry (member_id, delta, reason)\nVALUES (42, -250, 'indløst: biografbillet');\n\nINSERT INTO redemption (member_id, reward_id)\nVALUES (42, 7);\n\nCOMMIT;\n```\n\n`UPDATE` tager en rækkelås på medlem 42's wallet. Indtil `COMMIT` ser enhver\nanden session, der læser walleten, stadig den gamle saldo, fordi rækkelåse ikke\nblokerer læsere, og fordi ændringer, der ikke er committet, er usynlige. En\nanden indløsning for det samme medlem, sendt fra en anden fane et øjeblik\nsenere, når frem til sin egen `UPDATE` og venter. Når den første transaktion\ncommitter, evaluerer PostgreSQL på Read Committed den andens `WHERE`-betingelse\nigen mod rækken, som den ser ud nu. Er der kun 100 point tilbage, holder\nbetingelsen ikke, ingen række kommer tilbage, og den anden request rulles\ntilbage uden at have skrevet noget. Fejler den sidste `INSERT` i stedet, for\neksempel fordi belønning 7 er trukket tilbage, og en fremmednøgle afviser\nrækken, ruller klienten tilbage, og pointene står præcis, hvor de stod.\n\nDet er netop formen på\n[loyalitetspoint med ligaer og badges](/da/portfolio/built-a-loyalty-wallet-leagues-and-badges/).\nHver ændring af en wallet tager dér en row lock på den, før den læses, så en\nanden request venter på, at den første bliver færdig, i stedet for at kappes med\nden. Og fordi walleten ligger i samme database som alt det andet, committes en\nsaldo og det, den købte, sammen eller slet ikke. Siden lægger ikke skjul på\nprisen: row locking er det langsommere svar, og medlemmerne må vente på tur i\nstedet for at bruge de samme point to gange.\n\nNoten om\n[at sælge den sidste billet præcis én gang](/da/notes/selling-limited-stock-without-overselling/)\nsætter det samme værktøj under pres i et flash-salg. Dens rettelse gør\nlagertjekket og nedskrivningen til én betinget `UPDATE`, fordi en lås, der\nholdes, mens applikationen tænker mellem en `SELECT` og en `UPDATE`, lader den\nnæste køber vente hvert eneste millisekund af det. Øverst på dens liste over\nresten af arbejdet står at holde alt eksternt ude af transaktionen: et\nbetalingskald, en HTTP-forespørgsel eller en udsendt besked hører til før\ntransaktionen eller efter den.\n\n## Hvor det går galt\n\n**En session står inaktiv i en transaktion, og alt bag den må vente.** En applikation åbner en transaktion, opdaterer en række og venter så på et langsomt API, på en brugers næste klik eller på en worker, der gik ned uden nogensinde at sende `COMMIT`. Låsene bliver hængende, og med timeouts slået fra lader PostgreSQL en session, der ønsker en modstridende lås, vente på ubestemt tid, medmindre den opdager en deadlock, eller ventningen afbrydes. Dokumentationen kalder det en dårlig idé at holde en transaktion åben, mens man venter på input fra en bruger. `pg_stat_activity` viser den slags sessioner med tilstanden `idle in transaction`, og `xact_start` fortæller, hvornår transaktionen begyndte:\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\nFlyt det langsomme arbejde ud af transaktionen, og giv serveren en grænse, så en\nglemt transaktion ikke kan holde låse i timevis.\n`idle_in_transaction_session_timeout` afslutter enhver session, der har stået\ninaktiv i en åben transaktion længere end den angivne værdi. Standardværdien er\n0, som slår den fra, så den skal sættes eksplicit, for eksempel for\napplikationens rolle med\n`ALTER ROLE app SET idle_in_transaction_session_timeout = '30s';`.\n\n**To requests bruger den samme saldo.** Koden læser en værdi i én sætning,\ntræffer beslutningen i applikationen og skriver resultatet i en anden sætning.\nTo sessioner læser det samme tal, begge består tjekket, og begge skriver, så den\nene ændring i stilhed overskriver den anden. Et omsluttende `BEGIN` forhindrer\ndet ikke på Read Committed. Gør tjekket til en del af skrivningen med en\nbetingelse i `UPDATE`, som i eksemplet ovenfor, eller lås rækken, før den læses,\nmed `SELECT ... FOR UPDATE`, så den anden session venter på den første.\n\n**Der dukker fejl op under belastning på Repeatable Read eller Serializable.**\nPå de niveauer afviser PostgreSQL en transaktion, der ville bryde niveauets\nløfte, og melder en serialiseringsfejl, SQLSTATE `40001`, med beskeder som\n`could not serialize access due to concurrent update`. Det er ikke en bug, men\ndesignet, der virker, og dokumentationen siger, at applikationer, der bruger\ndisse niveauer, skal være forberedt på at prøve igen. Fang `40001`, og kør hele\ntransaktionen igen fra `BEGIN`, også dens læsninger, for beslutningen byggede på\ndata, der siden har ændret sig. Kører man kun den sætning, der fejlede, igen,\ngentager man fejlen.\n\n**To transaktioner ender i deadlock.** Den ene låser ordre 1 og derefter ordre\n2, den anden låser ordre 2 og derefter ordre 1, og hver venter på den anden.\nPostgreSQL opdager kredsløbet og afbryder en af transaktionerne, så den anden\nkan blive færdig, og hvilken den vælger, er svært at forudsige. Det\ndokumenterede forsvar er, at alle kodestier tager deres låse i samme rækkefølge,\nfor eksempel ved at opdatere rækker i stigende orden efter primærnøgle, og at en\ntransaktion, der blev afbrudt på grund af en deadlock, prøves igen.\n\n**Der går en e-mail ud om en ordre, der blev rullet tilbage.** Applikationen\nsender en bekræftelse eller publicerer en hændelse inde fra transaktionen, og\nbagefter fejler en senere sætning. Rollbacken fjerner ordren, men intet kan\nkalde e-mailen tilbage. Gem i stedet beskeden i en outbox-tabel i samme\ntransaktion som den ændring, den beskriver, og lad en separat proces sende den,\nnår commit er sket. Så findes beskeden præcis, når ordren gør.\n\n## Læs mere\n\n- [Transactions](https://www.postgresql.org/docs/current/tutorial-transactions.html)\n  — kapitlet i PostgreSQL's tutorial: alt-eller-intet, implicitte transaktioner\n  og savepoints, vist med en bankoverførsel.\n- [Transaction Isolation](https://www.postgresql.org/docs/current/transaction-iso.html)\n  — de fire standardniveauer, hvad hvert af dem ser i PostgreSQL, og de\n  serialiseringsfejl, der kræver et nyt forsøg.\n- [Explicit Locking](https://www.postgresql.org/docs/current/explicit-locking.html)\n  — række- og tabellåse, hvor længe de holdes, og hvordan deadlocks opdages og\n  undgå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 øvrige grænser for en session.\n- [Routine Vacuuming](https://www.postgresql.org/docs/current/routine-vacuuming.html)\n  — hvorfor gamle rækkeversioner bliver liggende, så længe en transaktion stadig\n  kan se dem, og hvad lange åbne transaktioner gør ved oprydningen.\n\n\u003chttps://engineer.company/da/glossary/transaction/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hvordan en databasetransaktion får flere ændringer til at tælle som én: commit og rollback, isolationsniveauer, rækkelåse og fem måder, det går galt.","formats":{"gemtext":"https://engineer.company/da/glossary/transaction/index.gmi","gopher":"https://engineer.company/da/glossary/transaction/gophermap","html":"https://engineer.company/da/glossary/transaction/","json":"https://engineer.company/da/glossary/transaction/index.json","markdown":"https://engineer.company/da/glossary/transaction/index.md","pdf":"https://engineer.company/da/glossary/transaction/index.pdf"},"kind":"page","language":"da","title":"Hvad er en transaktion?","url":"https://engineer.company/da/glossary/transaction/","version":1}