Add BeginFunc and BeginTxFunc

fixes #821

tx.go

@@ -85,6 +85,39 @@ func (c *Conn) BeginTx(ctx context.Context, txOptions TxOptions) (Tx, error) {
 	return &dbTx{conn: c}, nil
 }
 
+// BeginFunc starts a transaction and calls f. If f does not return an error the transaction is committed. If f returns
+// an error the transaction is rolled back. The context will be used when executing the transaction control statements
+// (BEGIN, ROLLBACK, and COMMIT) but does not otherwise affect the execution of f.
+func (c *Conn) BeginFunc(ctx context.Context, f func(Tx) error) (err error) {
+	return c.BeginTxFunc(ctx, TxOptions{}, f)
+}
+
+// BeginTxFunc starts a transaction with txOptions determining the transaction mode and calls f. If f does not return
+// an error the transaction is committed. If f returns an error the transaction is rolled back. The context will be
+// used when executing the transaction control statements (BEGIN, ROLLBACK, and COMMIT) but does not otherwise affect
+// the execution of f.
+func (c *Conn) BeginTxFunc(ctx context.Context, txOptions TxOptions, f func(Tx) error) (err error) {
+	var tx Tx
+	tx, err = c.BeginTx(ctx, TxOptions{})
+	if err != nil {
+		return err
+	}
+	defer func() {
+		rollbackErr := tx.Rollback(ctx)
+		if !(rollbackErr == nil || errors.Is(rollbackErr, ErrTxClosed)) {
+			err = rollbackErr
+		}
+	}()
+
+	fErr := f(tx)
+	if fErr != nil {
+		_ = tx.Rollback(ctx) // ignore rollback error as there is already an error to return
+		return fErr
+	}
+
+	return tx.Commit(ctx)
+}
+
 // Tx represents a database transaction.
 //
 // Tx is an interface instead of a struct to enable connection pools to be implemented without relying on internal pgx
@@ -96,6 +129,10 @@ type Tx interface {
 	// Begin starts a pseudo nested transaction.
 	Begin(ctx context.Context) (Tx, error)
 
+	// BeginFunc starts a pseudo nested transaction and executes f. If f does not return an err the pseudo nested
+	// transaction will be committed. If it does then it will be rolled back.
+	BeginFunc(ctx context.Context, f func(Tx) error) (err error)
+
 	// Commit commits the transaction if this is a real transaction or releases the savepoint if this is a pseudo nested
 	// transaction. Commit will return ErrTxClosed if the Tx is already closed, but is otherwise safe to call multiple
 	// times. If the commit fails with a rollback status (e.g. the transaction was already in a broken state) then
@@ -149,6 +186,32 @@ func (tx *dbTx) Begin(ctx context.Context) (Tx, error) {
 	return &dbSavepoint{tx: tx, savepointNum: tx.savepointNum}, nil
 }
 
+func (tx *dbTx) BeginFunc(ctx context.Context, f func(Tx) error) (err error) {
+	if tx.closed {
+		return ErrTxClosed
+	}
+
+	var savepoint Tx
+	savepoint, err = tx.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		rollbackErr := savepoint.Rollback(ctx)
+		if !(rollbackErr == nil || errors.Is(rollbackErr, ErrTxClosed)) {
+			err = rollbackErr
+		}
+	}()
+
+	fErr := f(savepoint)
+	if fErr != nil {
+		_ = savepoint.Rollback(ctx) // ignore rollback error as there is already an error to return
+		return fErr
+	}
+
+	return savepoint.Commit(ctx)
+}
+
 // Commit commits the transaction.
 func (tx *dbTx) Commit(ctx context.Context) error {
 	if tx.closed {
@@ -273,6 +336,14 @@ func (sp *dbSavepoint) Begin(ctx context.Context) (Tx, error) {
 	return sp.tx.Begin(ctx)
 }
 
+func (sp *dbSavepoint) BeginFunc(ctx context.Context, f func(Tx) error) (err error) {
+	if sp.closed {
+		return ErrTxClosed
+	}
+
+	return sp.tx.BeginFunc(ctx, f)
+}
+
 // Commit releases the savepoint essentially committing the pseudo nested transaction.
 func (sp *dbSavepoint) Commit(ctx context.Context) error {
 	if sp.closed {