Membina Perlaksanaan Transaksi SQL yang Teguh dalam Go dengan Rangka Kerja Generik

Apabila bekerja dengan pangkalan data SQL dalam Go, memastikan atomicity dan menguruskan rollback semasa transaksi berbilang langkah boleh menjadi mencabar. Dalam artikel ini, saya akan membimbing anda membuat rangka kerja yang teguh, boleh diguna semula dan boleh diuji untuk melaksanakan transaksi SQL dalam Go, menggunakan generik untuk fleksibiliti.

Kami akan membina utiliti SqlWriteExec untuk melaksanakan berbilang operasi pangkalan data bergantung dalam transaksi. Ia menyokong kedua-dua operasi tanpa status dan stateful, membolehkan aliran kerja yang canggih seperti memasukkan entiti berkaitan sambil menguruskan kebergantungan dengan lancar.

Mengapa Kita Memerlukan Rangka Kerja untuk Transaksi SQL?

Dalam aplikasi dunia nyata, operasi pangkalan data jarang diasingkan. Pertimbangkan senario ini:

Memasukkan pengguna dan mengemas kini inventori mereka secara atom.
Membuat pesanan dan memproses pembayarannya, memastikan ketekalan.
Dengan berbilang langkah yang terlibat, mengurus pemulangan semasa kegagalan menjadi penting untuk memastikan integriti data.

Bekerja dengan go in Txn management.

Jika anda menulis pangkalan data txn mungkin terdapat beberapa plat dandang yang mungkin anda perlu pertimbangkan sebelum menulis logik teras. Walaupun pengurusan txn ini diuruskan oleh spring boot di java dan anda tidak pernah mempedulikan mereka semasa menulis kod dalam java tetapi ini tidak berlaku dalam golang. Contoh mudah disediakan di bawah

func basicTxn(db *sql.DB) error {
    // start a transaction
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()
        } else if err != nil {
            tx.Rollback()
        } else {
            tx.Commit()
        }
    }()

    // insert data into the orders table
    _, err = tx.Exec("INSERT INTO orders (id, customer_name, order_date) VALUES (1, 'John Doe', '2022-01-01')")
    if err != nil {
        return err
    }
    return nil
}

Kami tidak boleh mengharapkan untuk mengulangi kod rollback/commit untuk setiap fungsi. Kami mempunyai dua pilihan di sini sama ada mencipta kelas yang akan menyediakan fungsi sebagai jenis pulangan yang apabila dilaksanakan dalam penangguhan akan melakukan/mengembalikan txn atau mencipta kelas pembalut yang akan membungkus semua fungsi txn bersama-sama dan melaksanakan sekali gus.

Saya menggunakan pilihan kemudian dan perubahan dalam kod boleh dilihat di bawah.

func TestSqlWriteExec_CreateOrderTxn(t *testing.T) {

    db := setupDatabase()
    // create a new SQL Write Executor
    err := dbutils.NewSqlTxnExec[OrderRequest, OrderProcessingResponse](context.TODO(), db, nil, &OrderRequest{CustomerName: "CustomerA", ProductID: 1, Quantity: 10}).
        StatefulExec(InsertOrder).
        StatefulExec(UpdateInventory).
        StatefulExec(InsertShipment).
        Commit()
    // check if the transaction was committed successfully
    if err != nil {
        t.Fatal(err)
        return
    }
    verifyTransactionSuccessful(t, db)
    t.Cleanup(
        func() { 
            cleanup(db)
            db.Close() 
        },
    )
}

func InsertOrder(ctx context.Context, txn *sql.Tx, order *OrderRequest, orderProcessing *OrderProcessingResponse) error {
    // Insert Order
    result, err := txn.Exec("INSERT INTO orders (customer_name, product_id, quantity) VALUES (, , )", order.CustomerName, order.ProductID, order.Quantity)
    if err != nil {
        return err
    }
    // Get the inserted Order ID
    orderProcessing.OrderID, err = result.LastInsertId()
    return err
}

func UpdateInventory(ctx context.Context, txn *sql.Tx, order *OrderRequest, orderProcessing *OrderProcessingResponse) error {
    // Update Inventory if it exists and the quantity is greater than the quantity check if it exists
    result, err := txn.Exec("UPDATE inventory SET product_quantity = product_quantity -  WHERE id =  AND product_quantity >= ", order.Quantity, order.ProductID)
    if err != nil {
        return err
    }
    // Get the number of rows affected
    rowsAffected, err := result.RowsAffected()
    if rowsAffected == 0 {
        return errors.New("Insufficient inventory")
    }
    return err
}

func InsertShipment(ctx context.Context, txn *sql.Tx, order *OrderRequest, orderProcessing *OrderProcessingResponse) error {
    // Insert Shipment
    result, err := txn.Exec("INSERT INTO shipping_info (customer_name, shipping_address) VALUES (, 'Shipping Address')", order.CustomerName)
    if err != nil {
        return err
    }
    // Get the inserted Shipping ID
    orderProcessing.ShippingID, err = result.LastInsertId()
    return err
}

Kod ini akan menjadi lebih tepat dan ringkas.

Bagaimana logik teras dilaksanakan

Ideanya adalah untuk mengasingkan txn kepada satu struct go supaya ia boleh menerima berbilang txn. Dengan txn yang saya maksudkan fungsi yang akan melakukan tindakan dengan txn yang kami buat untuk kelas.

type TxnFn[T any] func(ctx context.Context, txn *sql.Tx, processingReq *T) error
type StatefulTxnFn[T any, R any] func(ctx context.Context, txn *sql.Tx, processingReq *T, processedRes *R) error

Kedua-dua ini adalah jenis fungsi yang akan mengambil txn untuk memproses sesuatu. Kini dalam lapisan data melaksanakan cipta fungsi seperti ini dan hantarkannya kepada kelas pelaksana yang menguruskan menyuntik args dan melaksanakan fungsi.

// SQL Write Executor is responsible when executing write operations
// For dependent writes you may need to add the dependent data to processReq and proceed to the next function call
type SqlTxnExec[T any, R any] struct {
    db               *sql.DB
    txn              *sql.Tx
    txnFns         []TxnFn[T]
    statefulTxnFns []StatefulTxnFn[T, R]
    processingReq    *T
    processedRes     *R
    ctx              context.Context
    err              error
}

Di sinilah kami menyimpan semua butiran txn_fn dan kami akan mempunyai kaedah Commit() untuk mencuba melakukan txn.

func (s *SqlTxnExec[T, R]) Commit() (err error) {
    defer func() {
        if p := recover(); p != nil {
            s.txn.Rollback()
            panic(p)
        } else if err != nil {
            err = errors.Join(err, s.txn.Rollback())
        } else {
            err = errors.Join(err, s.txn.Commit())
        }
        return
    }()

    for _, writeFn := range s.txnFns {
        if err = writeFn(s.ctx, s.txn, s.processingReq); err != nil {
            return
        }
    }

    for _, statefulWriteFn := range s.statefulTxnFns {
        if err = statefulWriteFn(s.ctx, s.txn, s.processingReq, s.processedRes); err != nil {
            return
        }
    }
    return
}

Anda boleh mendapatkan lebih banyak contoh dan ujian dalam repo -
https://github.com/mahadev-k/go-utils/tree/main/examples

Walaupun kami berat sebelah terhadap sistem teragih dan protokol konsensus pada masa kini, kami masih menggunakan sql dan ia masih wujud.

Beri tahu saya jika sesiapa ingin menyumbang dan membina di atas perkara ini!!
Terima kasih kerana membaca sejauh ini!!
https://in.linkedin.com/in/mahadev-k-934520223
https://x.com/mahadev_k_

Atas ialah kandungan terperinci Membina Perlaksanaan Transaksi SQL yang Teguh dalam Go dengan Rangka Kerja Generik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!