Aufbau einer robusten SQL-Transaktionsausführung in Go mit einem generischen Framework

Bei der Arbeit mit SQL-Datenbanken in Go kann es eine Herausforderung sein, die Atomizität sicherzustellen und Rollbacks bei mehrstufigen Transaktionen zu verwalten. In diesem Artikel werde ich Sie durch die Erstellung eines robusten, wiederverwendbaren und testbaren Frameworks für die Ausführung von SQL-Transaktionen in Go führen und dabei Generics für mehr Flexibilität verwenden.

Wir erstellen ein SqlWriteExec-Dienstprogramm zum Ausführen mehrerer abhängiger Datenbankoperationen innerhalb einer Transaktion. Es unterstützt sowohl zustandslose als auch zustandsbehaftete Vorgänge und ermöglicht anspruchsvolle Arbeitsabläufe wie das Einfügen verwandter Entitäten bei gleichzeitiger nahtloser Verwaltung von Abhängigkeiten.

Warum brauchen wir ein Framework für SQL-Transaktionen?

In realen Anwendungen sind Datenbankoperationen selten isoliert. Betrachten Sie diese Szenarien:

Einen Benutzer einfügen und sein Inventar atomar aktualisieren.
Erstellen einer Bestellung und Bearbeiten der Zahlung, um Konsistenz sicherzustellen.
Da mehrere Schritte erforderlich sind, ist die Verwaltung von Rollbacks bei Ausfällen von entscheidender Bedeutung, um die Datenintegrität sicherzustellen.

Zusammenarbeit mit go im Txn-Management.

Wenn Sie eine Datenbank-TXN schreiben, müssen Sie möglicherweise mehrere Grundbausteine ​​berücksichtigen, bevor Sie die Kernlogik schreiben. Während diese TXN-Verwaltung von Spring Boot in Java verwaltet wird und Sie sich beim Schreiben von Code in Java nie viel darum gekümmert haben, ist dies in Golang nicht der Fall. Ein einfaches Beispiel finden Sie unten

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
}

Wir können nicht erwarten, den Rollback-/Commit-Code für jede Funktion zu wiederholen. Wir haben hier zwei Möglichkeiten: Entweder erstellen Sie eine Klasse, die eine Funktion als Rückgabetyp bereitstellt, die bei Ausführung im Defer TXN festschreibt/rollbackt, oder Sie erstellen eine Wrapper-Klasse, die alle TXN-Funktionen zusammenfasst und auf einmal ausführt.

Ich habe mich für die spätere Option entschieden und die Änderung im Code ist unten zu sehen.

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
}

Dieser Code wird sehr viel präziser und prägnanter sein.

Wie die Kernlogik implementiert wird

Die Idee besteht darin, den Txn in einer einzelnen Go-Struktur zu isolieren, sodass er mehrere Txns akzeptieren kann. Mit txn meine ich Funktionen, die mit dem txn, den wir für die Klasse erstellt haben, Aktionen ausführen.

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

Bei diesen beiden handelt es sich um Funktionstypen, die einen Txn annehmen, um etwas zu verarbeiten. Erstellen Sie nun in der Datenschicht eine Funktion wie diese und übergeben Sie sie an die Executor-Klasse, die sich um das Einfügen der Argumente und das Ausführen der Funktion kümmert.

// 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
}

Hier speichern wir alle txn_fn-Details und wir werden über die Commit()-Methode verfügen, um zu versuchen, den txn festzuschreiben.

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
}

Weitere Beispiele und Tests finden Sie im Repo -
https://github.com/mahadev-k/go-utils/tree/main/examples

Obwohl wir heutzutage auf verteilte Systeme und Konsensprotokolle setzen, verwenden wir immer noch SQL und es existiert immer noch.

Lassen Sie mich wissen, wenn jemand dazu beitragen und darauf aufbauen möchte!!
Danke, dass du bis hierher gelesen hast!!
https://in.linkedin.com/in/mahadev-k-934520223
https://x.com/mahadev_k_

Das obige ist der detaillierte Inhalt vonAufbau einer robusten SQL-Transaktionsausführung in Go mit einem generischen Framework. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!