使用BeginTx() 開啟事務(wù)以支持上下文控制；2. 通過sql.Tx 的Exec、Query 等方法執(zhí)行事務(wù)內(nèi)操作，避免與sql.DB 方法混用；3. 所有操作成功後調(diào)用Commit() 提交，失敗時調(diào)用Rollback() 回滾，推薦使用defer 確?；貪L；4. 每步操作後檢查錯誤，避免跨goroutine 共享事務(wù)，並使用上下文設(shè)置超時以防止阻塞；5. 在需要原子性寫入、讀寫關(guān)聯(lián)操作或維護數(shù)據(jù)完整性時使用事務(wù)，但應(yīng)避免長時間運行以減少鎖爭用；Go 通過sql.Tx 提供了簡潔可靠的事務(wù)管理機制，關(guān)鍵在於正確開啟、使用、提交或回滾事務(wù)，並始終妥善處理錯誤，從而確保數(shù)據(jù)一致性。

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.

以上是在GO中管理數(shù)據(jù)庫交易的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！