{"canonical_url":"https://engineer.company/sv/glossary/transaction/","content_markdown":"# Transaktion\n\n## Vad det är\n\nEn transaktion är en grupp ändringar som en databas genomför som en enhet:\nantingen får alla verkan eller ingen av dem. När den behöver hållas isär från en\nbetalning, som också kallas transaktion, skriver man databastransaktion.\nPostgreSQL-handledningen beskriver idén så här: flera steg samlas i en enda\noperation där allt eller inget sker, och ingen annan ser något av det som ligger\ndäremellan.\n\nI PostgreSQL öppnas en transaktion med `BEGIN` och avslutas antingen med\n`COMMIT`, som gör ändringarna beständiga och synliga för andra sessioner, eller\nmed `ROLLBACK`, som kastar dem. En sats som skickas ensam körs också i en\ntransaktion: PostgreSQL lägger ett implicit `BEGIN` runt den och, om den lyckas,\nett implicit `COMMIT`. En lång transaktion kan sätta en sparpunkt med\n`SAVEPOINT` och senare gå tillbaka till den med `ROLLBACK TO`, så att arbetet\nefter punkten kastas medan allt före den behålls.\n\nGarantierna en transaktion ger sammanfattas som ACID. Atomicitet betyder att\ntransaktionen genomförs som en enhet eller inte alls och att inget halvfärdigt\nresultat överlever en krasch. Konsistens betyder att integritetsvillkoren som\ndefinierats för datan gäller när den committas, och att en transaktion som\nskulle bryta mot något av dem rullas tillbaka i stället. Isolering betyder att\ndess ändringar är osynliga för samtidiga transaktioner tills den har committats.\nHållbarhet betyder att en committad ändring överlever att servern kraschar.\n\nIsolering finns i nivåer, och SQL-standarden definierar fyra: Read Uncommitted, Read Committed, Repeatable Read och Serializable. PostgreSQL startar varje transaktion på Read Committed om inget annat anges, och dess Read Uncommitted beter sig exakt som Read Committed. På Read Committed ser varje sats de data som committats innan satsen började, så två frågor i samma transaktion kan se olika siffror. På Repeatable Read arbetar hela transaktionen utifrån en ögonblicksbild, tagen när dess första sats som inte styr transaktionen körs. Serializable går längre och ser till att samtidiga transaktioner ger samma resultat som om de hade körts en i taget.\n\n## Varför det spelar roll\n\nNästan varje handling som är värd att registrera rör mer än en rad. En order är\nen rad i en tabell, en nedräkning av lagret i en annan och en post i en\nhuvudbok. Utan transaktion kan en krasch, en timeout eller ett brutet\nintegritetsvillkor mellan andra och tredje satsen lämna kvar en order vars lager\naldrig drogs, eller lager som dragits för en order som inte finns. Sedan hittar\nnågon det i en rapport och rättar det för hand. Med en transaktion finns det\nhalva tillståndet aldrig för någon att se, och det är databasen, inte\napplikationen, som garanterar det.\n\nDet andra skälet är samtidighet. Två anrop som kommer samtidigt körs sida vid\nsida, och isoleringsnivån avgör vad vart och ett ser medan lås avgör vilket som\nfår vänta. Det är här team oftast blir överraskade: att slå in kod i `BEGIN` och\n`COMMIT` hindrar inte i sig två anrop från att läsa samma saldo och båda\nspendera det. På Read Committed läser varje sats det som var committat när den\nstartade, så en kontroll i en sats och en skrivning i nästa kan skiljas åt av en\ncommit från en annan session. Kontrollen måste antingen låsa raden först eller\nbli en del av skrivningen.\n\nTransaktioner har också ett pris, och det betalas i tid. Radlås som tas av `UPDATE`, `DELETE` och `SELECT ... FOR UPDATE` hålls normalt tills transaktionen avslutas; en tillbakarullning till en sparpunkt frigör lås som tagits efter den sparpunkten. En session som vill ha ett konflikterande lås måste vänta om inte en tidsgräns, ett avbrott eller lösningen av ett deadlock stoppar väntan. En öppen transaktion hindrar också `VACUUM` från att ta bort gamla radversioner som den fortfarande kan behöva se, så en transaktion som står öppen i timmar får tabellerna att svälla. Designfrågan är därför aldrig bara om en transaktion ska användas, utan var dess gränser går och hur lite som händer mellan dem.\n\nSlutligen omfattar en vanlig lokal databastransaktion inte i sig externa effekter. Ett anrop till en betalleverantör, ett mejl eller ett meddelande som publicerats på en separat kö blir inte ogjort av att databasen rullas tillbaka. Samordning med andra system kräver ytterligare design; ett omgivande `BEGIN` räcker inte. Att bestämma vad som hamnar innanför gränsen, och hur omvärlden får veta om en commit, är det mesta av arbetet med att utforma en transaktion.\n\n## Så ser det ut i praktiken\n\nEn medlem i ett lojalitetsprogram löser in 250 poäng mot en biobiljett. Tre\nsaker måste ske tillsammans: plånboken förlorar poängen, huvudboken registrerar\nvarför och inlösen skapas. Skrivet som en transaktion ser det ut så här:\n\n```sql\nBEGIN;\n\nUPDATE wallet\nSET    points = points - 250\nWHERE  member_id = 42\nAND    points \u003e= 250\nRETURNING points;\n-- ingen rad tillbaka: för få poäng, så ROLLBACK och stopp här\n\nINSERT INTO points_entry (member_id, delta, reason)\nVALUES (42, -250, 'inlöst: biobiljett');\n\nINSERT INTO redemption (member_id, reward_id)\nVALUES (42, 7);\n\nCOMMIT;\n```\n\n`UPDATE` tar ett radlås på plånboken för medlem 42. Fram till `COMMIT` ser varje\nannan session som läser plånboken fortfarande det gamla saldot, eftersom radlås\ninte blockerar läsare och ändringar som inte har committats är osynliga. En\nandra inlösen för samma medlem, skickad från en annan flik ett ögonblick senare,\nnår sin egen `UPDATE` och väntar. När den första transaktionen committas\nutvärderar PostgreSQL på Read Committed den andras `WHERE`-villkor på nytt mot\nraden som den ser ut nu. Om bara 100 poäng finns kvar är villkoret inte\nuppfyllt, ingen rad kommer tillbaka och det andra anropet rullas tillbaka utan\natt ha skrivit något. Om i stället den sista `INSERT` misslyckas, till exempel\nför att belöning 7 har dragits tillbaka och en främmande nyckel avvisar den,\nrullar klienten tillbaka och poängen är exakt där de var.\n\nDet här är formen på\n[lojalitetsplånboken med ligor](/sv/portfolio/built-a-loyalty-wallet-leagues-and-badges/).\nVarje skrivoperation där tar ett radlås på plånboken innan den läses, så att det\nandra anropet väntar på att det första ska bli klart i stället för att kapplöpa\nmed det, och eftersom plånboken ligger i samma databas som allt annat committas\nsaldot och det som köptes för det tillsammans eller inte alls. Sidan säger öppet\nvad det kostar: radlåsning är det långsammare svaret, och vid trängsel får\ntransaktionerna vänta på sin tur, men alternativet är en medlem som spenderar\nsamma poäng två gånger.\n\nAnteckningen om\n[att sälja den sista biljetten exakt en gång](/sv/notes/selling-limited-stock-without-overselling/)\nprövar samma verktyg under en blixtrea. Lösningen där gör kontrollen och\nnedräkningen till en enda villkorad `UPDATE`, eftersom ett lås som hålls medan\napplikationen tänker mellan en `SELECT` och en `UPDATE` får nästa köpare att\nvänta varenda millisekund av det. Först på listan över resten av arbetet står\natt hålla allt externt utanför transaktionen: ett betalningsanrop, en\nHTTP-begäran eller ett publicerat meddelande hör hemma före den eller efter den.\n\n## Var det går fel\n\n**En session står overksam i en transaktion och allt bakom den får vänta.** En applikation öppnar en transaktion, uppdaterar en rad och väntar sedan på ett långsamt API, på användarens nästa klick eller på en bakgrundsprocess som kraschade utan att någonsin skicka `COMMIT`. Låsen ligger kvar, och med tidsgränser avstängda låter PostgreSQL en session som vill ha ett konflikterande lås vänta på obestämd tid om den inte upptäcker ett deadlock eller väntan avbryts. Dokumentationen kallar det en dålig idé att hålla en transaktion öppen medan man väntar på indata från användaren. `pg_stat_activity` visar sådana sessioner med tillståndet `idle in transaction`, och `xact_start` anger när transaktionen började:\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\nFlytta ut det långsamma arbetet ur transaktionen, och ge servern en gräns så att\nen bortglömd transaktion inte kan hålla lås i timmar.\n`idle_in_transaction_session_timeout` avslutar varje session som har stått\noverksam i en öppen transaktion längre än värdet. Standardvärdet är 0, vilket\nstänger av den, så den måste sättas, till exempel för applikationens roll med\n`ALTER ROLE app SET idle_in_transaction_session_timeout = '30s';`.\n\n**Två anrop spenderar samma saldo.** Koden läser ett värde i en sats, fattar\nbeslut i applikationen och skriver resultatet i en annan. Två sessioner läser\nsamma tal, båda klarar kontrollen och båda skriver, så den ena ändringen skriver\ntyst över den andra. Ett omgivande `BEGIN` förhindrar det inte på Read\nCommitted. Gör kontrollen till en del av skrivningen med ett villkor i `UPDATE`,\nsom i exemplet ovan, eller lås raden innan den läses med\n`SELECT ... FOR UPDATE`, så att den andra sessionen väntar på den första.\n\n**Fel dyker upp under last på Repeatable Read eller Serializable.** På de här\nnivåerna avvisar PostgreSQL en transaktion som skulle bryta nivåns löfte och\nrapporterar ett serialiseringsfel, SQLSTATE `40001`, med meddelanden som\n`could not serialize access due to concurrent update`. Det är så det är tänkt\natt fungera, och dokumentationen säger uttryckligen att applikationer som\nanvänder de här nivåerna måste vara beredda att försöka igen. Fånga `40001` och\nkör hela transaktionen igen från `BEGIN`, läsningarna inräknade, eftersom\nbeslutet den fattade byggde på data som sedan har ändrats. Att bara köra om den\nsats som misslyckades upprepar misstaget.\n\n**Två transaktioner hamnar i deadlock (baklås).** Den ena låser order 1 och\nsedan order 2, den andra låser order 2 och sedan order 1, och var och en väntar\npå den andra. PostgreSQL upptäcker cirkeln och avbryter en av transaktionerna så\natt den andra kan bli klar, och vilken den väljer är svårt att förutse.\nFörsvaret som dokumentationen anger är att alla kodvägar tar lås i samma\nordning, till exempel genom att uppdatera rader i stigande ordning efter\nprimärnyckel, och att en transaktion som avbröts på grund av deadlock körs igen.\n\n**Ett mejl går ut för en order som rullades tillbaka.** Applikationen skickar en\nbekräftelse eller publicerar en händelse inifrån transaktionen, och sedan\nmisslyckas en senare sats. Rollbacken tar bort ordern, men inget kan kalla\ntillbaka mejlet. Skriv meddelandet i en outbox-tabell i samma transaktion som\nändringen det beskriver, och låt en separat process skicka det när commiten har\nskett. Då finns meddelandet exakt när ordern finns.\n\n## Läs mer\n\n- [Transactions](https://www.postgresql.org/docs/current/tutorial-transactions.html)\n  — kapitlet i PostgreSQL-handledningen: allt-eller-inget-beteende, implicita\n  transaktioner och sparpunkter, visade med en banköverföring.\n- [Transaction Isolation](https://www.postgresql.org/docs/current/transaction-iso.html)\n  — de fyra standardnivåerna, vad var och en ser i PostgreSQL och\n  serialiseringsfelen som kräver ett nytt försök.\n- [Explicit Locking](https://www.postgresql.org/docs/current/explicit-locking.html)\n  — rad- och tabellås, hur länge de hålls och hur deadlocks upptäcks och\n  undviks.\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` och de andra gränserna för en session.\n- [Routine Vacuuming](https://www.postgresql.org/docs/current/routine-vacuuming.html)\n  — varför gamla radversioner ligger kvar så länge någon transaktion fortfarande\n  kan se dem, och vad långa öppna transaktioner gör med städningen.\n\n\u003chttps://engineer.company/sv/glossary/transaction/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hur en databastransaktion får flera ändringar att räknas som en: commit och rollback, isoleringsnivåer, radlås och fem sätt det går fel på.","formats":{"gemtext":"https://engineer.company/sv/glossary/transaction/index.gmi","gopher":"https://engineer.company/sv/glossary/transaction/gophermap","html":"https://engineer.company/sv/glossary/transaction/","json":"https://engineer.company/sv/glossary/transaction/index.json","markdown":"https://engineer.company/sv/glossary/transaction/index.md","pdf":"https://engineer.company/sv/glossary/transaction/index.pdf"},"kind":"page","language":"sv","title":"Vad är en transaktion?","url":"https://engineer.company/sv/glossary/transaction/","version":1}