Transazione

1. Introduzione alle transazioni e alla coerenza dei dati

Una transazione è un'unità logica nel processo di esecuzione di un sistema di gestione di database, composta da una serie di operazioni. Queste operazioni vengono completate tutte insieme oppure tutte falliscono e sono trattate come un'entità indivisibile. Le principali caratteristiche di una transazione possono essere riassunte come ACID:

• Atomicità: Tutte le operazioni in una transazione vengono completate interamente o non completate affatto; il completamento parziale non è possibile.
• Coerenza: Una transazione deve far transitare il database da uno stato coerente a un altro stato coerente.
• Isolamento: L'esecuzione di una transazione deve essere isolata da interferenze da parte di altre transazioni, e i dati tra più transazioni concorrenti devono essere isolati.
• Durabilità: Una volta che una transazione viene confermata, le modifiche apportate da essa permarranno nel database.

Coerenza dei dati si riferisce al mantenimento di uno stato dati corretto e valido in un database dopo una serie di operazioni. In scenari che coinvolgono accessi concorrenti o guasti di sistema, la coerenza dei dati è particolarmente importante, e le transazioni forniscono un meccanismo per garantire che la coerenza dei dati non venga compromessa nemmeno in caso di errori o conflitti.

2. Panoramica del Framework ent

ent è un framework di gestione delle entità che, attraverso la generazione di codice nel linguaggio di programmazione Go, fornisce un'API type-safe per operare su database. Questo rende le operazioni sui database più intuitive e sicure, in grado di evitare problemi di sicurezza come le iniezioni SQL. Per quanto riguarda l'elaborazione delle transazioni, il framework ent fornisce un forte supporto, consentendo agli sviluppatori di eseguire operazioni di transazione complesse con codice conciso e garantire che le proprietà ACID delle transazioni siano soddisfatte.

3. Avviare una Transazione

3.1 Come Avviare una Transazione in ent

Nel framework ent, una nuova transazione può essere facilmente avviata all'interno di un contesto specifico utilizzando il metodo client.Tx, restituendo un oggetto di transazione Tx. L'esempio di codice è il seguente:

tx, err := client.Tx(ctx)
if err != nil {
    // Gestire gli errori durante l'avvio della transazione
    return fmt.Errorf("Si è verificato un errore durante l'avvio della transazione: %w", err)
}
// Eseguire operazioni successive utilizzando tx...

3.2 Eseguire Operazioni all'interno di una Transazione

Una volta che l'oggetto Tx è stato creato con successo, può essere utilizzato per eseguire operazioni sul database. Tutte le operazioni di creazione, eliminazione, aggiornamento e interrogazione eseguite sull'oggetto Tx diventeranno parte della transazione. L'esempio seguente dimostra una serie di operazioni:

hub, err := tx.Group.
    Create().
    SetName("Github").
    Save(ctx)
if err != nil {
    // Se si verifica un errore, annullare la transazione
    return rollback(tx, fmt.Errorf("Impossibile creare il Gruppo: %w", err))
}
// È possibile aggiungere operazioni aggiuntive qui...
// Confermare la transazione
tx.Commit()

4. Gestione degli Errori e Annullamento in Transazioni

4.1 Importanza della Gestione degli Errori

Nel lavoro con i database, possono verificarsi vari errori come problemi di rete, conflitti di dati o violazioni di vincoli in qualsiasi momento. Gestire correttamente questi errori è cruciale per mantenere la coerenza dei dati. In una transazione, se un'operazione fallisce, la transazione deve essere annullata per garantire che operazioni parzialmente completate, che potrebbero compromettere la coerenza del database, non rimangano in sospeso.

4.2 Come Implementare l'Annullamento

Nel framework ent, è possibile utilizzare il metodo Tx.Rollback() per annullare l'intera transazione. Tipicamente, viene definita una funzione ausiliaria rollback per gestire l'annullamento e gli errori, come mostrato di seguito:

func rollback(tx *ent.Tx, err error) error {
    if rerr := tx.Rollback(); rerr != nil {
        // Se il rollback fallisce, restituire l'errore originale e l'errore di rollback insieme
        err = fmt.Errorf("%w: Si è verificato un errore durante l'annullamento della transazione: %v", err, rerr)
    }
    return err
}

Con questa funzione rollback, possiamo gestire in modo sicuro gli errori e l'annullamento della transazione ogni volta che un'operazione all'interno della transazione fallisce. Ciò garantisce che anche in caso di errore, non avrà un impatto negativo sulla coerenza del database.

5. Uso del client transazionale

Nelle applicazioni pratiche, potrebbero verificarsi scenari in cui è necessario trasformare rapidamente del codice non transazionale in codice transazionale. Per questi casi, possiamo utilizzare un client transazionale per migrare senza soluzione di continuità il codice. Di seguito è riportato un esempio di come trasformare del codice client non transazionale esistente per supportare le transazioni:

// In questo esempio, incapsuliamo la funzione Gen originale all'interno di una transazione.
func WrapGen(ctx context.Context, client *ent.Client) error {
    // Per prima cosa, creiamo una transazione
    tx, err := client.Tx(ctx)
    if err != nil {
        return err
    }
    // Otteniamo il client transazionale dalla transazione
    txClient := tx.Client()
    // Eseguiamo la funzione Gen utilizzando il client transazionale senza modificare il codice Gen originale
    if err := Gen(ctx, txClient); err != nil {
        // In caso di errore, annulliamo la transazione
        return rollback(tx, err)
    }
    // Se tutto va a buon fine, confermiamo la transazione
    return tx.Commit()
}

Nel codice sopra, viene utilizzato il client transazionale tx.Client(), consentendo alla funzione Gen originale di essere eseguita sotto la garanzia della transazione. Questo approccio ci consente di trasformare comodamente del codice non transazionale esistente in codice transazionale con un impatto minimo sulla logica originale.

6. Migliori pratiche per le transazioni

6.1 Gestione delle transazioni con funzioni di callback

Quando la nostra logica di codice diventa complessa e coinvolge diverse operazioni di database, diventa particolarmente importante gestire in modo centralizzato queste operazioni all'interno di una transazione. Di seguito è riportato un esempio di gestione delle transazioni attraverso funzioni di callback:

func WithTx(ctx context.Context, client *ent.Client, fn func(tx *ent.Tx) error) error {
    tx, err := client.Tx(ctx)
    if err != nil {
        return err
    }
    // Utilizziamo defer e recover per gestire scenari potenziali di panic
    defer func() {
        if v := recover(); v != nil {
            tx.Rollback()
            panic(v)
        }
    }()
    // Chiamiamo la funzione di callback fornita per eseguire la logica di business
    if err := fn(tx); err != nil {
        // In caso di errore, annulliamo la transazione
        if rerr := tx.Rollback(); rerr != nil {
            err = fmt.Errorf("%w: annullamento della transazione: %v", err, rerr)
        }
        return err
    }
    // Se la logica di business è priva di errori, confermiamo la transazione
    return tx.Commit()
}

Utilizzando la funzione WithTx per incapsulare la logica di business, possiamo garantire che anche se si verificano errori o eccezioni all'interno della logica di business, la transazione verrà gestita correttamente (confermata o annullata).

6.2 Utilizzo degli hooks di transazione

Analogamente agli hooks dello schema e agli hooks in tempo di esecuzione, possiamo anche registrare hooks all'interno di una transazione attiva (Tx) che verranno attivati al momento di Tx.Commit o Tx.Rollback:

func Do(ctx context.Context, client *ent.Client) error {
    tx, err := client.Tx(ctx)
    if err != nil {
        return err
    }
    tx.OnCommit(func(next ent.Committer) ent.Committer {
        return ent.CommitFunc(func(ctx context.Context, tx *ent.Tx) error {
            // Logica prima di confermare la transazione
            err := next.Commit(ctx, tx)
            // Logica dopo la conferma della transazione
            return err
        })
    })
    tx.OnRollback(func(next ent.Rollbacker) ent.Rollbacker {
        return ent.RollbackFunc(func(ctx context.Context, tx *ent.Tx) error {
            // Logica prima di annullare la transazione
            err := next.Rollback(ctx, tx)
            // Logica dopo l'annullamento della transazione
            return err
        })
    })
    // Eseguiamo altre logiche di business
    //
    // 
    //
    return err
}

Aggiungendo hooks durante il commit e l'annullamento della transazione, possiamo gestire logiche aggiuntive, come la registrazione o la pulizia delle risorse.

7. Comprensione dei diversi livelli di isolamento delle transazioni

In un sistema di database, impostare il livello di isolamento delle transazioni è fondamentale per prevenire vari problemi di concorrenza (come letture sporche, letture non ripetibili e letture fantasmi). Ecco alcuni livelli di isolamento standard e come impostarli nel framework ent:

• READ UNCOMMITTED: Il livello più basso, consente la lettura delle modifiche ai dati che non sono state confermate, il che può portare a letture sporche, letture non ripetibili e letture fantasmi.
• READ COMMITTED: Consente la lettura e la conferma dei dati, impedendo letture sporche, ma le letture non ripetibili e le letture fantasmi possono comunque verificarsi.
• REPEATABLE READ: Garantisce che la lettura degli stessi dati più volte all'interno della stessa transazione produca risultati consistenti, impedendo letture non ripetibili, ma le letture fantasmi possono comunque verificarsi.
• SERIALIZABLE: Il livello di isolamento più rigoroso, cerca di impedire letture sporche, letture non ripetibili e letture fantasmi bloccando i dati coinvolti.

In ent, se il driver del database supporta l'impostazione del livello di isolamento delle transazioni, è possibile impostarlo come segue:

// Imposta il livello di isolamento della transazione su repeatable read
tx, err := client.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelRepeatableRead})

Comprendere i livelli di isolamento delle transazioni e la loro applicazione nei database è fondamentale per garantire la coerenza dei dati e la stabilità del sistema. Gli sviluppatori dovrebbero scegliere un livello di isolamento appropriato in base ai requisiti specifici dell'applicazione per ottenere la migliore prassi nella garanzia della sicurezza dei dati e nell'ottimizzazione delle prestazioni.