Transaksi & konsistensi

Transaksi adalah alat yang menjamin "semuanya terjadi atau tidak sama sekali". Yang tidak dijamin siapa pun adalah apa yang terjadi saat dua transaksi menyentuh baris yang sama pada saat yang sama.

Pola yang benar

func (r *Repo) Pindah(ctx context.Context, dari, ke int64, jumlah int64) error {
	tx, err := r.db.BeginTx(ctx, nil)
	if err != nil {
		return fmt.Errorf("mulai transaksi: %w", err)
	}
	// Aman dipanggil setelah Commit: ia mengembalikan ErrTxDone yang diabaikan.
	// Ini yang menjamin tidak ada jalur keluar yang meninggalkan transaksi
	// menggantung — termasuk panic.
	defer func() { _ = tx.Rollback() }()

	var saldo int64
	err = tx.QueryRowContext(ctx,
		`SELECT saldo FROM akun WHERE id = $1 FOR UPDATE`, dari).Scan(&saldo)
	if err != nil {
		return fmt.Errorf("kunci akun %d: %w", dari, err)
	}
	if saldo < jumlah {
		return ErrSaldoKurang
	}

	if _, err := tx.ExecContext(ctx,
		`UPDATE akun SET saldo = saldo - $1 WHERE id = $2`, jumlah, dari); err != nil {
		return fmt.Errorf("kurangi saldo: %w", err)
	}
	if _, err := tx.ExecContext(ctx,
		`UPDATE akun SET saldo = saldo + $1 WHERE id = $2`, jumlah, ke); err != nil {
		return fmt.Errorf("tambah saldo: %w", err)
	}

	if err := tx.Commit(); err != nil {
		return fmt.Errorf("commit: %w", err)
	}
	return nil
}

Membungkusnya jadi fungsi bantu

func DalamTx(ctx context.Context, db *sql.DB, f func(*sql.Tx) error) error {
	tx, err := db.BeginTx(ctx, nil)
	if err != nil {
		return err
	}
	defer func() {
		if p := recover(); p != nil {
			_ = tx.Rollback()
			panic(p)          // panic tetap naik, tapi transaksinya bersih
		}
	}()

	if err := f(tx); err != nil {
		_ = tx.Rollback()
		return err
	}
	return tx.Commit()
}

// Pemakaian
err := DalamTx(ctx, r.db, func(tx *sql.Tx) error {
	if err := simpanPesanan(ctx, tx, p); err != nil {
		return err
	}
	return kurangiStok(ctx, tx, p.Item)
})

Apa yang tidak boleh ada di dalam transaksi

Tingkat isolasi

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

Deadlock

Transaksi A: kunci akun 1 → minta kunci akun 2
Transaksi B: kunci akun 2 → minta kunci akun 1
              ↳ keduanya menunggu selamanya; database mematikan salah satu

// Pencegahan: SELALU kunci dengan urutan yang sama, apa pun arah transfernya.
pertama, kedua := dari, ke
if pertama > kedua {
	pertama, kedua = kedua, pertama
}

tx.ExecContext(ctx, `SELECT 1 FROM akun WHERE id = $1 FOR UPDATE`, pertama)
tx.ExecContext(ctx, `SELECT 1 FROM akun WHERE id = $1 FOR UPDATE`, kedua)

Deadlock tidak bisa dihilangkan sepenuhnya, jadi kode yang menyentuh beberapa baris sekaligus juga perlu retry:

func denganRetry(ctx context.Context, maks int, f func() error) error {
	var err error
	for i := range maks {
		if err = f(); err == nil {
			return nil
		}

		var pgErr *pgconn.PgError
		// 40P01 deadlock_detected, 40001 serialization_failure
		if !errors.As(err, &pgErr) ||
			(pgErr.Code != "40P01" && pgErr.Code != "40001") {
			return err          // bukan error yang layak diulang
		}

		select {
		case <-time.After(time.Duration(1<<i) * 10 * time.Millisecond):
		case <-ctx.Done():
			return ctx.Err()
		}
	}
	return err
}

Transaksi baca-saja

// Untuk laporan yang butuh beberapa kueri dari SATU snapshot data
tx, _ := db.BeginTx(ctx, &sql.TxOptions{
	Isolation: sql.LevelRepeatableRead,
	ReadOnly:  true,
})
defer tx.Rollback()

Ini menjamin semua kueri di dalamnya melihat keadaan database yang sama — penting untuk laporan yang totalnya harus konsisten dengan rinciannya. ReadOnly: true juga memungkinkan database mengarahkannya ke replica.