Création d'une exécution de transactions SQL robuste en Go avec un framework générique

Lorsque vous travaillez avec des bases de données SQL dans Go, garantir l'atomicité et gérer les restaurations lors de transactions en plusieurs étapes peut s'avérer difficile. Dans cet article, je vais vous guider dans la création d'un cadre robuste, réutilisable et testable pour exécuter des transactions SQL dans Go, en utilisant des génériques pour plus de flexibilité.

Nous allons créer un utilitaire SqlWriteExec pour exécuter plusieurs opérations de base de données dépendantes au sein d'une transaction. Il prend en charge les opérations sans état et avec état, permettant des flux de travail sophistiqués tels que l'insertion d'entités associées tout en gérant les dépendances de manière transparente.

Pourquoi avons-nous besoin d'un cadre pour les transactions SQL ?

Dans les applications du monde réel, les opérations de base de données sont rarement isolées. Considérez ces scénarios :

Insérer un utilisateur et mettre à jour son inventaire de manière atomique.
Créer une commande et traiter son paiement en garantissant sa cohérence.
Avec plusieurs étapes impliquées, la gestion des restaurations en cas de panne devient cruciale pour garantir l'intégrité des données.

Travailler avec Go dans la gestion Txn.

Si vous écrivez une base de données txn, vous devrez peut-être prendre en compte plusieurs plaques passe-partout avant d'écrire la logique de base. Bien que cette gestion txn soit gérée par Spring Boot en Java et que vous ne vous en souciiez jamais beaucoup lors de l'écriture de code en Java, ce n'est pas le cas en Golang. Un exemple simple est fourni ci-dessous

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
}

Nous ne pouvons pas nous attendre à répéter le code de restauration/commit pour chaque fonction. Nous avons deux options ici : soit créer une classe qui fournira une fonction comme type de retour qui, une fois exécutée dans le defer, validera/annulera txn, soit créera une classe wrapper qui encapsulera toutes les fonctions txn ensemble et s'exécutera en une seule fois.

J'ai opté pour le choix ultérieur et le changement de code est visible ci-dessous.

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
}

Ce code sera beaucoup plus précis et concis.

Comment la logique de base est mise en œuvre

L'idée est d'isoler le txn dans une seule structure go de telle sorte qu'il puisse accepter plusieurs txns. Par txn, j'entends les fonctions qui feront une action avec le txn que nous avons créé pour la classe.

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

Ces deux sont des types de fonctions qui prendront un txn pour traiter quelque chose. Maintenant, dans la couche de données implémentant a, créez une fonction comme celle-ci et transmettez-la à la classe exécuteur qui se charge d'injecter les arguments et d'exécuter la fonction.

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

C'est ici que nous stockons tous les détails du txn_fn et nous aurons la méthode Commit() pour essayer de valider le 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
}

Vous pouvez trouver plus d'exemples et de tests dans le dépôt -
https://github.com/mahadev-k/go-utils/tree/main/examples

Bien que nous préférions aujourd'hui les systèmes distribués et les protocoles de consensus, nous utilisons toujours SQL et il existe toujours.

Faites-moi savoir si quelqu'un souhaite contribuer et construire sur cette base !!
Merci d'avoir lu jusqu'ici !!
https://in.linkedin.com/in/mahadev-k-934520223
https://x.com/mahadev_k_

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!