database

type BatchJob interface {
	Run(ctx context.Context, runner Runner, data []dynworker.UserData) error
}

type Config struct {
	Driver           string         `json:"driver"`
	Username         string         `json:"username"`
	Password         string         `config_obscure:"true"     json:"password"`
	Hostname         string         `json:"hostname"`
	Port             int            `json:"port"`
	Database         string         `json:"database"`
	BatchSize        int            `json:"batch_size"`
	BatchTimeout     types.Duration `json:"batch_timeout"`
	SetPoolLimits    bool           `json:"set_pool_limits"`
	MaxIdleConns     int            `json:"max_idle_conns"`
	MaxOpenConns     int            `json:"max_open_conns"`
	UsePool          bool           `json:"use_worker_pool"`
	PoolMinWorkers   int            `json:"pool_min_workers"`
	PoolMaxWorkers   int            `json:"pool_max_workers"`
	PoolIdleTimeout  types.Duration `json:"pool_idle_timeout"`
	PoolDrainTimeout types.Duration `json:"pool_drain_timeout"`
	// contains filtered or unexported fields
}

type Cursor struct {
	Offset int64 `json:"offset"`
	Limit  int64 `json:"limit"`
}

type Database interface {
	// Pings the database connection to ensure it is alive and connected.
	Ping() error

	// Close a database connection.  This does nothing if the connection
	// is already closed.
	Close() error

	// Set the maximum idle connections.
	SetMaxIdleConns(int)

	// Set the maximum open connections.
	SetMaxOpenConns(int)

	// Rebind query placeholders to the chosen SQL backend.
	Rebind(string) string

	// Parses the given error looking for common MySQL error conditions.
	//
	// If one is found, then a Golang error describing the condition is
	// raised.
	//
	// If nothing interesting is found, then the original error is
	// returned.
	GetError(error) error

	// Run a query function within the context of a database transaction.
	//
	// If there is no error, then the transaction is committed.
	//
	// If there is an error, then the transaction is rolled back.
	WithTransaction(context.Context, TxnFn) error

	// Exposes the database's pool as a `Runner`.
	Runner() Runner
}

type Manager interface {
	Open(string, string) (Database, error)
	OpenConfig(*Config) (Database, error)
	OpenWorker(context.Context, *Config, BatchJob) (Worker, error)
	CheckDB(Database) error
}

type NullBool struct {
	sql.NullBool
}

type NullByte struct {
	sql.NullByte
}

type NullFloat64 struct {
	sql.NullFloat64
}

type NullInt16 struct {
	sql.NullInt16
}

type NullInt32 struct {
	sql.NullInt32
}

type NullInt64 struct {
	sql.NullInt64
}

type NullString struct {
	sql.NullString
}

type NullTime struct {
	sql.NullTime
}

type Runner interface {
	sqlx.ExtContext

	GetContext(context.Context, any, string, ...any) error
	SelectContext(context.Context, any, string, ...any) error
}

type TxnFn func(context.Context, Runner) error

type TxnProvider interface {
	Txn(context.Context, Runner) error
}

type Worker interface {
	Name() string
	Database() Database
	Start()
	Stop()
	SubmitBatch(dynworker.UserData) error
	SubmitJob(WorkerJob) error
}

type WorkerJob interface {
	Run(ctx context.Context, runner Runner) error
}