Transacties
Commit en rol terug
Transacties is een gratis Go Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Go Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Go Academy bevat in totaal 4 lessen.
Waarom transacties
Een transactie groepeert meerdere statements, zodat ze allemaal slagen of allemaal samen mislukken. Zo blijven gegevens consistent, bijvoorbeeld wanneer je geld tussen twee rekeningen verplaatst zonder het halverwege kwijt te raken.
- Atomair: alles of niets
- Consistente toestand
- Geïsoleerd van andere transacties
db.Begin
Begin start een transactie en geeft een *sql.Tx terug. Je voert statements uit op de Tx, niet op de pool, zodat ze dezelfde verbinding en dezelfde transactie gebruiken.
tx, err := db.Begin()
if err != nil {
log.Fatal(err)
}Statements op de Tx
Roep tx.Exec en tx.Query net als op de db aan, maar alles wordt binnen de transactie uitgevoerd totdat je de transactie vastlegt of terugdraait.
_, err = tx.Exec("UPDATE accounts SET balance = balance - $1 WHERE id = $2", 100, 1)Commit
tx.Commit() maakt alle wijzigingen permanent en zichtbaar voor anderen. Als de aanroep een fout teruggeeft, is de transactie niet toegepast.
if err := tx.Commit(); err != nil {
log.Fatal(err)
}Rollback
Als een stap mislukt, roep je tx.Rollback() aan om alle wijzigingen sinds Begin te verwijderen. De database keert terug naar de vorige toestand, alsof er niets is gebeurd.
if err != nil {
tx.Rollback()
return err
}Het defer-Rollbackpatroon
Een robuust idioom stelt Rollback direct na Begin uit met defer. Rollback na een geslaagde Commit doet niets en veroorzaakt geen problemen, dus zo wordt opruimen op elk foutpad gegarandeerd.
tx, err := db.Begin()
if err != nil { return err }
defer tx.Rollback()
// ... do work ...
return tx.Commit()Voorbeeld van een atomische overboeking
Twee updates vormen één logische bewerking: trek een bedrag van de ene rekening af en tel het op bij een andere. Beide moeten samen worden vastgelegd, anders mag geen van beide worden toegepast.
Een uitvoerbare transactiesimulatie
Echte transacties hebben een database nodig. Dit uitvoerbare voorbeeld simuleert het starten van een transactie, twee updates en het vastleggen of terugdraaien ervan met een map in het geheugen.
package main
import (
"errors"
"fmt"
)
func transfer(bal map[string]int, from, to string, amt int) error {
if bal[from] < amt {
return errors.New("insufficient funds")
}
snapshot := map[string]int{from: bal[from], to: bal[to]}
bal[from] -= amt
bal[to] += amt
if bal[from] < 0 {
bal[from], bal[to] = snapshot[from], snapshot[to]
return errors.New("rolled back")
}
return nil
}
func main() {
bal := map[string]int{"alice": 100, "bob": 20}
if err := transfer(bal, "alice", "bob", 30); err != nil {
fmt.Println("error:", err)
} else {
fmt.Println("committed:", bal)
}
}Isolatieniveaus
db.BeginTx accepteert opties, waaronder een isolatieniveau zoals sql.LevelSerializable. Een hoger isolatieniveau voorkomt meer anomalieën, maar kan de gelijktijdigheid verminderen.
tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})Houd transacties kort
Een transactie houdt een verbinding vast en kan vergrendelingen vasthouden. Voer alle SQL snel uit, vermijd netwerkoproepen of gebruikersinvoer binnen de transactie en leg de transactie snel vast om concurrentie om resources te verminderen.
Meng db en tx nooit
Voer binnen een transactie statements alleen uit op de tx. Als je daar db.Exec aanroept, gebruikt dat een andere verbinding buiten de transactie. Die wijzigingen maken er dan geen deel van uit en worden niet teruggedraaid.
Korte controle
Test je kennis van transacties.
Samenvatting
Je hebt geleerd wat transacties zijn:
- Begin geeft een *sql.Tx terug; voer statements daarop uit
- Commit bewaart wijzigingen; Rollback verwijdert alle wijzigingen
- defer tx.Rollback() garandeert opruimen bij een fout
- BeginTx stelt isolatie in; houd transacties kort
- Meng db en tx nooit binnen één transactie
Leer Go met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 51
- Lessen
- 203
Veelgestelde vragen
Is de les “Transacties” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “Transacties”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Go Academy bevat in totaal 4 lessen.
Wat leer ik in “Transacties”?
Commit en rol terug Je oefent met Go Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Go Academy te beginnen?
Ervaring vooraf is niet nodig. Go Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Transacties”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Go Academy?
Ja. Elke les over Go Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.