Use BeginTx() to enable transactions to support context control; 2. Exec, Query and other methods of sql.Tx to perform in-transaction operations to avoid mixing with sql.DB methods; 3. Call Commit() to commit after all operations, and call Rollback() to rollback when failure. It is recommended to use defer to ensure rollback; 4. Check for errors after each step of operation to avoid sharing transactions across goroutines, and set timeouts to prevent blocking; 5. Use transactions when atomic writes, read and write association operations or maintain data integrity, but long-term running should be avoided to reduce lock contention; Go provides a concise and reliable transaction management mechanism through sql.Tx. The key is to correctly enable, use, commit or roll back transactions, and always handle errors properly to ensure data consistency.

Managing database transactions in Go is essential when you need to ensure data consistency across multiple operations—like inserts, updates, or deletes—that should either all succeed or all fail together. The Go database/sql package provides robust support for transactions through the sql.DB and sql.Tx types.

Here's how to properly manage database transactions in Go.

1. Starting a Transaction

To begin a transaction, use the Begin() or BeginTx() method on a *sql.DB instance. This returns a *sql.Tx representing the transaction context.

 tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}

Or with context (recommended for timeouts and cancellation):

 ctx := context.Background()
tx, err := db.BeginTx(ctx, nil)
if err != nil {
    log.Fatal(err)
}

You can also pass transaction options:

 tx, err := db.BeginTx(ctx, &sql.TxOptions{
    Isolation: sql.LevelSerializable,
    ReadOnly: false,
})

2. Executing Queries Within a Transaction

Once you have a *sql.Tx , use its methods ( Exec , Query , QueryRow , etc.) instead of the *sql.DB ones. All operations will run within the same transaction.

 _, err = tx.Exec("INSERT INTO users (name, email) VALUES (?, ?)", "Alice", "alice@example.com")
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

_, err = tx.Exec("UPDATE accounts SET balance = balance - 100 WHERE user_id = ?", 1)
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

?? Important: Never mix db.Exec() with tx.Exec() in the same logical transaction—only use the transaction's methods.

3. Commit or Rollback

After all operations succeed, call Commit() to persist changes:

 err = tx.Commit()
if err != nil {
    log.Fatal(err)
}

If any error occurs, call Rollback() to undo all changes:

 if err != nil {
    tx.Rollback()
    return err
}

Even if Commit() fails, you should still treat the transaction as failed. Some databases commit partially, but the behavior is not reliable.

? Best Practice: Use defer to ensure rollback if the transaction doesn't commit:

 tx, err := db.BeginTx(ctx, nil)
if err != nil {
    return err
}
defer func() {
    if p := recover(); p != nil {
        tx.Rollback()
        panic(p)
    } else if err != nil {
        tx.Rollback()
    }
}()

// ... perform operations

err = tx.Commit()
return err

Alternatively, a cleaner pattern using a helper function:

 func withTransaction(db *sql.DB, fn func(*sql.Tx) error) error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer tx.Rollback()

    err = fn(tx)
    if err != nil {
        return err
    }

    return tx.Commit()
}

// Usage:
err := withTransaction(db, func(tx *sql.Tx) error {
    _, err := tx.Exec("INSERT INTO...")
    return err
})

4. Handling Errors and Concurrency

• Always check errors after each query in the transaction.
• Transactions are not safe for concurrent use . Don't share a *sql.Tx across goroutines.
• Use context-aware methods ( BeginTx , QueryContext ) to support timeouts and prevent hanging queries.

Example with timeout:

 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

tx, err := db.BeginTx(ctx, nil)

5. When to Use Transactions

Use transactions when:

• Multiple related writes must be atomic.
• You're reading data to make a decision and then writing (eg, check balance before withdrawal).
• Maintaining referential integrity across tables.

Avoid long-running transactions—they can lock rows and hurt performance.

In short, Go makes transaction handling straightforward with sql.Tx . Just remember:

• Start with BeginTx()
• Use tx.* methods for queries
• Always Commit() or Rollback()
• Handle errors and use defer wisely

Basically, keep it simple, clean, and always error-aware.

The above is the detailed content of Managing Database Transactions in Go. For more information, please follow other related articles on the PHP Chinese website!