database/sql Tx - rilevamento Commit o rollback

Question

Utilizzando i pacchetti database/sql e driver e Tx, non è possibile che venga rilevato se una transazione è stata eseguita o rollback senza tentare un altro e ricevere un errore come risultato e quindi esaminare l'errore per determinare il tipo di errore. Mi piacerebbe essere in grado di determinare dall'oggetto Tx se commesso o meno. Certo, posso definire e impostare un'altra variabile nella funzione che utilizza Tx, ma ne ho un bel numero, ed è volta 2 ogni volta (variabile e assegnazione). Ho anche una funzione differita per fare un rollback, se necessario, e deve essere passato la variabile bool.

Sarebbe accettabile impostare la variabile Tx su nil dopo un commit o rollback, e il GC recupererà la memoria, o è un no-no, o c'è un'alternativa migliore?

Answer 1

Perché dovresti averne bisogno? La funzione che chiama Begin() dovrebbe anche chiamare Commit() o Rollback() e restituire un errore appropriato.

Ad esempio, questo codice fa un commit o rollback a seconda se viene restituito un errore:

func (s Service) DoSomething() (err error) { 
    tx, err := s.db.Begin() 
    if err != nil { 
     return 
    } 
    defer func() { 
     if err != nil { 
      tx.Rollback() 
      return 
     } 
     err = tx.Commit() 
    }() 
    if _, err = tx.Exec(...); err != nil { 
     return 
    } 
    if _, err = tx.Exec(...); err != nil { 
     return 
    } 
    // ... 
    return 
} 

Notate come sto controllando error per vedere se o non dovrei commit o rollback. L'esempio sopra non, tuttavia, gestisce il panico.

Non mi piace eseguire la logica di commit/rollback su ogni routine di database, quindi di solito li incorporo in un gestore di transazioni. Qualcosa sulla falsariga di questo:

func Transact(db *sql.DB, txFunc func(*sql.Tx) error) (err error) { 
    tx, err := db.Begin() 
    if err != nil { 
     return 
    } 
    defer func() { 
     if p := recover(); p != nil { 
      tx.Rollback() 
      panic(p) // re-throw panic after Rollback 
     } else if err != nil { 
      tx.Rollback() 
     } else { 
      err = tx.Commit() 
     } 
    }() 
    err = txFunc(tx) 
    return err 
} 

Questo mi permette di fare questo, invece:

func (s Service) DoSomething() error { 
    return Transact(s.db, func (tx *sql.Tx) error { 
     if _, err := tx.Exec(...); err != nil { 
      return err 
     } 
     if _, err := tx.Exec(...); err != nil { 
      return err 
     } 
    }) 
} 

Si noti che se qualcosa dentro la mia transazione panico è gestito automaticamente dal gestore delle transazioni.

Nella mia implementazione effettiva passaggio un'interfaccia invece di * sql.Tx per impedire chiamate indesiderate a Commit() o Rollback().

Ecco un semplice frammento di dimostrare come defer opere (stampe 4, non 5):

package main 

func test() (i int) { 
    defer func() { 
     i = 4 
    }() 
    return 5 
} 

func main() { 
    println(test()) 
} 

http://play.golang.org/p/0OinYDWFlx