- implement retry to Tx function

v2/gen_dbq.go

@@ -119,11 +119,11 @@ type Options struct {
 // MustE is a wrapper around the E function. It will panic upon encountering an error.
 // This can erradicate boiler-plate error handing code.
 func MustE(ctx context.Context, db ExecContexter, query string, options *Options, args ...interface{}) sql.Result {
-	EkXBAk, jQZLCt := E(ctx, db, query, options, args...)
-	if jQZLCt != nil {
-		panic(jQZLCt)
+	BmyArK, Ctzkjk := E(ctx, db, query, options, args...)
+	if Ctzkjk != nil {
+		panic(Ctzkjk)
 	}
-	return EkXBAk
+	return BmyArK
 }
 
 // E is a wrapper around the Q function. It is used for "Exec" queries such as insert, update and delete.
@@ -141,11 +141,11 @@ func E(ctx context.Context, db ExecContexter, query string, options *Options, ar
 // MustQ is a wrapper around the Q function. It will panic upon encountering an error.
 // This can erradicate boiler-plate error handing code.
 func MustQ(ctx context.Context, db interface{}, query string, options *Options, args ...interface{}) interface{} {
-	TMtTCo, aNatyy := Q(ctx, db, query, options, args...)
-	if aNatyy != nil {
-		panic(aNatyy)
+	ZIvaBj, MkXVbW := Q(ctx, db, query, options, args...)
+	if MkXVbW != nil {
+		panic(MkXVbW)
 	}
-	return TMtTCo
+	return ZIvaBj
 }
 
 // Q is a convenience function that is used for inserting, updating, deleting, and querying a SQL database.

v2/gen_interfaces.go

@@ -31,12 +31,6 @@ type SQLBasic interface {
 	QueryContexter
 }
 
-// Txer represents a transaction.
-type Txer interface {
-	Commit() error
-	Rollback() error
-}
-
 // BeginTxer is an object than can begin a transaction.
 type BeginTxer interface {
 	BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)

v2/gen_tx.go

@@ -10,19 +10,45 @@ import (
 	"fmt"
 
 	rlSql "github.com/rocketlaunchr/mysql-go"
+	"gopkg.in/cenkalti/backoff.v4"
+	// "github.com/cenkalti/backoff/v4"
 )
 
+type txer interface {
+	Commit() error
+	Rollback() error
+}
+
 // QFn is shorthand for Q. It will automatically use the appropriate transaction.
 type QFn func(ctx context.Context, query string, options *Options, args ...interface{}) (interface{}, error)
 
 // EFn is shorthand for E. It will automatically use the appropriate transaction.
 type EFn func(ctx context.Context, query string, options *Options, args ...interface{}) (sql.Result, error)
 
+// TxCommit will commit the transaction.
+type TxCommit func() error
+
 // Tx is used to perform an arbitrary operation and not have to worry about rolling back a transaction.
-// The transaction is automatically rolled back unless it is explicitly committed.
+// The transaction is automatically rolled back unless committed by calling txCommit.
+// tx is only exposed for performance purposes. Do not use it to commit or rollback.
 //
 // NOTE: Until this note is removed, this function is not necessarily backward compatible.
-func Tx(ctx context.Context, db interface{}, fn func(tx Txer, Q QFn, E EFn)) error {
+//
+// Example:
+//
+//  ctx := context.Background()
+//  pool, _ := sql.Open("mysql", "user:password@tcp(localhost:3306)/db")
+//
+//  dbq.Tx(ctx, pool, func(tx interface{}, Q dbq.QFn, E dbq.EFn, txCommit dbq.TxCommit) {
+//  	stmt := dbq.INSERT("test", []string{"name", "age", "created_at"}, 1)
+//  	res, err := E(ctx, stmt, nil, "test name", 34, time.Now())
+//  	if err != nil {
+//  		return // Automatic rollback
+//  	}
+//  	txCommit()
+//  })
+//
+func Tx(ctx context.Context, db interface{}, fn func(tx interface{}, Q QFn, E EFn, txCommit TxCommit), retryPolicy ...backoff.BackOff) error {
 
 	var (
 		alreadyTx bool
@@ -50,7 +76,7 @@ func Tx(ctx context.Context, db interface{}, fn func(tx Txer, Q QFn, E EFn)) err
 
 	defer func() {
 		if r := recover(); r != nil {
-			tx.(Txer).Rollback()
+			tx.(txer).Rollback()
 			panic(r)
 		}
 	}()
@@ -67,10 +93,32 @@ func Tx(ctx context.Context, db interface{}, fn func(tx Txer, Q QFn, E EFn)) err
 		return E(ctx, tx.(ExecContexter), query, options, args...)
 	}
 
-	fn(tx.(Txer), qFn, eFn)
-	err = tx.(Txer).Rollback()
-	if err == sql.ErrTxDone {
-		return nil
+	completed := false
+	txCommit := func() error {
+		err := tx.(txer).Commit()
+		if err == nil || err == sql.ErrTxDone {
+			completed = true
+			return nil
+		}
+		return err
+	}
+
+	operation := func() error {
+		fn(tx, qFn, eFn, txCommit)
+		if completed {
+			return nil
+		}
+		err = tx.(txer).Rollback()
+		if err == sql.ErrTxDone {
+			return nil
+		}
+		return err
+	}
+
+	if !(len(retryPolicy) > 0 && retryPolicy[0] != nil) {
+
+		return operation()
 	}
-	return err
+
+	return backoff.Retry(operation, backoff.WithContext(retryPolicy[0], ctx))
 }

v2/interfaces.igo

@@ -29,12 +29,6 @@ type SQLBasic interface {
 	QueryContexter
 }
 
-// Txer represents a transaction.
-type Txer interface {
-	Commit() error
-	Rollback() error
-}
-
 // BeginTxer is an object than can begin a transaction.
 type BeginTxer interface {
 	BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)

v2/tx.igo

@@ -8,19 +8,45 @@ import (
 	"fmt"
 
 	rlSql "github.com/rocketlaunchr/mysql-go"
+	"gopkg.in/cenkalti/backoff.v4"
+	// "github.com/cenkalti/backoff/v4"
 )
 
+type txer interface {
+	Commit() error
+	Rollback() error
+}
+
 // QFn is shorthand for Q. It will automatically use the appropriate transaction.
 type QFn func(ctx context.Context, query string, options *Options, args ...interface{}) (interface{}, error)
 
 // EFn is shorthand for E. It will automatically use the appropriate transaction.
 type EFn func(ctx context.Context, query string, options *Options, args ...interface{}) (sql.Result, error)
 
+// TxCommit will commit the transaction.
+type TxCommit func() error
+
 // Tx is used to perform an arbitrary operation and not have to worry about rolling back a transaction.
-// The transaction is automatically rolled back unless it is explicitly committed.
+// The transaction is automatically rolled back unless committed by calling txCommit.
+// tx is only exposed for performance purposes. Do not use it to commit or rollback.
 //
 // NOTE: Until this note is removed, this function is not necessarily backward compatible.
-func Tx(ctx context.Context, db interface{}, fn func(tx Txer, Q QFn, E EFn)) error {
+//
+// Example:
+//
+//  ctx := context.Background()
+//  pool, _ := sql.Open("mysql", "user:password@tcp(localhost:3306)/db")
+//
+//  dbq.Tx(ctx, pool, func(tx interface{}, Q dbq.QFn, E dbq.EFn, txCommit dbq.TxCommit) {
+//  	stmt := dbq.INSERT("test", []string{"name", "age", "created_at"}, 1)
+//  	res, err := E(ctx, stmt, nil, "test name", 34, time.Now())
+//  	if err != nil {
+//  		return // Automatic rollback
+//  	}
+//  	txCommit()
+//  })
+//
+func Tx(ctx context.Context, db interface{}, fn func(tx interface{}, Q QFn, E EFn, txCommit TxCommit), retryPolicy ...backoff.BackOff) error {
 
 	var (
 		alreadyTx bool
@@ -49,7 +75,7 @@ func Tx(ctx context.Context, db interface{}, fn func(tx Txer, Q QFn, E EFn)) err
 
 	defer func() {
 		if r := recover(); r != nil {
-			tx.(Txer).Rollback()
+			tx.(txer).Rollback()
 			panic(r)
 		}
 	}()
@@ -66,10 +92,32 @@ func Tx(ctx context.Context, db interface{}, fn func(tx Txer, Q QFn, E EFn)) err
 		return E(ctx, tx.(ExecContexter), query, options, args...)
 	}
 
-	fn(tx.(Txer), qFn, eFn)
-	err = tx.(Txer).Rollback()
-	if err == sql.ErrTxDone {
-		return nil
+	completed := false
+	txCommit := func() error {
+		err := tx.(txer).Commit()
+		if err == nil || err == sql.ErrTxDone {
+			completed = true
+			return nil
+		}
+		return err
 	}
-	return err
+
+	operation := func() error {
+		fn(tx, qFn, eFn, txCommit)
+		if completed {
+			return nil
+		}
+		err = tx.(txer).Rollback()
+		if err == sql.ErrTxDone {
+			return nil
+		}
+		return err
+	}
+
+	if !(len(retryPolicy) > 0 && retryPolicy[0] != nil) {
+		// No retry
+		return operation()
+	}
+
+	return backoff.Retry(operation, backoff.WithContext(retryPolicy[0], ctx))
 }