sqlutil

type ConnectionManager ¶ added in v0.6.21

type ConnectionManager interface {
	Writer
	DS() *config.DataSource
	Connection(ctx context.Context, readOnly bool) *gorm.DB
	BeginTx(ctx context.Context, opts ...*WriterOption) (context.Context, Transaction, error)
	FromOptions(ctx context.Context, opts *config.DatabaseOptions) (ConnectionManager, error)
	Collect(migrations ...*frame.MigrationPatch) error
	Migrate(ctx context.Context) error
}

func NewConnectionManager(service *frame.Service) ConnectionManager

func NewConnectionManagerWithOptions(ctx context.Context, service *frame.Service, opts *config.DatabaseOptions) (ConnectionManager, error)

type Connections ¶

type Connections struct {
	// contains filtered or unexported fields
}

func (c *Connections) BeginTx(ctx context.Context, opts ...*WriterOption) (context.Context, Transaction, error)

func (c *Connections) Collect(migrations ...*frame.MigrationPatch) error

func (c *Connections) Connection(ctx context.Context, readOnly bool) *gorm.DB

func (c *Connections) DS() *config.DataSource

func (c *Connections) Do(ctx context.Context, f func(ctx context.Context) error, opts ...*WriterOption) error

func (c *Connections) FromOptions(ctx context.Context, opts *config.DatabaseOptions) (ConnectionManager, error)

func (c *Connections) Migrate(ctx context.Context) error

type DefaultWriter ¶ added in v0.6.21

type DefaultWriter struct {
	// contains filtered or unexported fields
}

DefaultWriter implements sqlutil.Writer. The DefaultWriter is designed to allow reuse of the sqlutil.Writer interface but, unlike ExclusiveWriter, it will not guarantee writer exclusivity. This is fine in PostgreSQL where overlapping transactions and writes are acceptable.

func (w *DefaultWriter) Do(ctx context.Context, f func(ctx context.Context) error, opts ...*WriterOption) error

type ExclusiveWriter ¶

type ExclusiveWriter struct {
	// contains filtered or unexported fields
}

ExclusiveWriter implements sqlutil.Writer. ExclusiveWriter allows queuing database writes so that you don't contend on database locks in, e.g. SQLite. Only one task will run at a time on a given ExclusiveWriter.

func (w *ExclusiveWriter) Do(ctx context.Context, f func(ctx context.Context) error, opts ...*WriterOption) error

type Transaction ¶

type Transaction interface {
	// Commit the transaction
	Commit() error
	// Rollback the transaction.
	Rollback() error
}

A Transaction is something that can be committed or rolledback.

type TransactionStack ¶ added in v0.6.21

type TransactionStack struct {
	// contains filtered or unexported fields
}

TransactionStack represents a stack of transactions to enable proper nesting

func GetTransactionStack(ctx context.Context) *TransactionStack

func (s *TransactionStack) IsEmpty() bool

func (s *TransactionStack) Peek() Transaction

func (s *TransactionStack) Pop() Transaction

func (s *TransactionStack) Push(txn Transaction)

type Writer ¶

type Writer interface {
	// Do queues up one or more database write operations within the
	// provided function to be executed when it is safe to do so.
	Do(ctx context.Context, f func(ctx context.Context) error, opts ...*WriterOption) error
}

The Writer interface is designed to solve the problem of how to handle database writes for database engines that don't allow concurrent writes, e.g. SQLite.

The interface has a single Do function which takes an optional database parameter, an optional transaction parameter and a required function parameter. The Writer will call the function provided when it is safe to do so, optionally providing a transaction to use.

The Writer will call f() when it is safe to do so. The supplied "txn" will ALWAYS be passed through to f() via the context. Use the connection manager to obtain the connection. If one exists in the context then it will be re used.

You MUST take particular care not to call Do() from within f() on the same Writer, or it will likely result in a deadlock.

func NewDefaultWriter(cm ConnectionManager) Writer

func NewExclusiveWriter(cm ConnectionManager) Writer

type WriterOption ¶ added in v0.6.21

type WriterOption struct {
	SqlOpts []*sql.TxOptions
}

WriterOption is an optional parameter to Writer.Do