Retries

When two transactions collide, the database cancels one, and running it again usually just works. ant can do that for you.

One transaction

ant.Attemptsfunc Attempts(n int) TxOptionAttempts retries a transaction that fails from a deadlock or serialization conflict, up to n runs in all, waiting a little longer each time. reruns a transaction that lost a serialization conflict or a deadlock. The number is the total number of runs. An ordinary error is never retried.

err := db.Tx(
	ctx,
	func(tx *AppDB) error {
		user, err := tx.Users.NoTracking().Find(ctx, id)
		if err != nil {
			return err
		}

		_, err = tx.Users.Where(ant.Eq(&U.ID, id)).Update(ctx, ant.Set(&U.Age, user.Age+1))

		return err
	},
	ant.Isolation(sql.LevelSerializable),
	ant.Attempts(5),
)

Every transaction

ant.WithRetryfunc WithRetry(policy Retry) OptionWithRetry applies a retry policy to every Tx and SaveChanges of this context, unless Attempts says otherwise for one call. applies to every Txfunc (c *Context) Tx[DB any](ctx context.Context, f func(tx *DB) error, options ...TxOption) errorTx runs f in a transaction, passing a context of the same type bound to it. and SaveChangesfunc (c *Context) SaveChanges(ctx context.Context) errorSaveChanges writes every change to tracked entities in one transaction: inserts and updates with parents first, then deletes with children first. of a context, for an application that wants this handled in one place. ant.Attempts overrides it for one call.

db, err := ant.Open[AppDB](ctx, postgres.Dialect, dsn, ant.WithRetry(ant.Retry{Attempts: 5}))

Checking by hand

ant.IsRetryablefunc IsRetryable(err error) boolIsRetryable reports whether a transaction failed from a deadlock or a serialization conflict, and would likely work if run again. reports whether an error is one of these.

err := db.SaveChanges(ctx)

if ant.IsRetryable(err) {
	log.Println("worth another try")
}

The function may run twice

A retried function runs again from the top, so it shouldn't change anything outside the database. Send the email after the commit, or from an observer.

Commit failures aren't retried: the transaction may already have committed. See when a commit fails.

See it tested: tests/features/transactions/retry_test.go