func transferMoney(ctx context.Context, conn *pgx.Conn, fromAccount, toAccount string, amount float64) error {
    tx, err := conn.BeginTx(ctx, pgx.TxOptions{})
    if err != nil {
        return fmt.Errorf("starting transaction: %w", err)
    }
    // Defer a rollback in case anything fails
    defer tx.Rollback(ctx)

    // Perform the transfer operations
    if _, err := tx.Exec(ctx, "UPDATE accounts SET balance = balance - $1 WHERE id = $2", amount, fromAccount); err != nil {
        return fmt.Errorf("deducting amount: %w", err)
    }

    if _, err := tx.Exec(ctx, "UPDATE accounts SET balance = balance + $1 WHERE id = $2", amount, toAccount); err != nil {
        return fmt.Errorf("adding amount: %w", err)
    }

    // Commit the transaction
    if err := tx.Commit(ctx); err != nil {
        return fmt.Errorf("committing transaction: %w", err)
    }

    return nil
}

func processBatchWithSavepoints(ctx context.Context, tx pgx.Tx) error {
    for i, item := range items {
        // Create a savepoint before processing each item
        savepoint := fmt.Sprintf("sv_%d", i)
        if _, err := tx.Exec(ctx, "SAVEPOINT "+savepoint); err != nil {
            return err
        }

        if err := processItem(ctx, tx, item); err != nil {
            // Rollback to savepoint if processing fails
            _, rbErr := tx.Exec(ctx, "ROLLBACK TO SAVEPOINT "+savepoint)
            if rbErr != nil {
                return rbErr
            }
            continue
        }

        // Release savepoint if successful
        if _, err := tx.Exec(ctx, "RELEASE SAVEPOINT "+savepoint); err != nil {
            return err
        }
    }
    return nil
}

tx, err := conn.BeginTx(ctx, pgx.TxOptions{
    IsoLevel: pgx.Serializable,
})

func executeTransaction(ctx context.Context, conn *pgx.Conn) error {
    tx, err := conn.BeginTx(ctx, pgx.TxOptions{})
    if err != nil {
        return fmt.Errorf("begin transaction: %w", err)
    }

    defer func() {
        if err := recover(); err != nil {
            tx.Rollback(ctx)
            panic(err) // re-panic after rollback
        }
    }()

    // Transaction operations here...

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