db

type Beginner interface {
	// Begin begins a transaction
	Begin(ctx context.Context, readonly bool) (QuerierExecutorCommitter, error)
}

type Columns []string

type Commiter interface {
	// Commit returns nil iff the transaction was successful.  This method may only be called once.
	// If this method returns true, future calls to Rollback() will be no-ops and always return nil.
	// If an error is returned, the transaction may have been successful, or it may have failed.
	Commit() error
	// Rollback reverts the transaction.  Invocations after first are no-ops and always return nil.
	// If an error is returned, the caller does not need to call Rollback() again.
	Rollback() error
}

type DB interface {
	DBAdaptable
	IdAllocatable
	Beginner
	// Close closes the database, and should be called when the db is no longer needed.
	Close() error
	// InitSchema initializes the database tables.  This is typically used in unit tests.
	InitSchema(context.Context, []string) error
}

type DBAdaptable interface {
	// Adapter returns an adapter for use with a database.
	Adapter() DBAdapter
}

type DBAdapter interface {
	Name() string
	Quote(string) string
	BlobIdxQuote(string) string
	LockStmt(*strings.Builder, Lock)
	BoolType() string
	IntType() string
	BigIntType() string
	BlobType() string

	Open(ctx context.Context, dataSourceName string) (DB, error)
	OpenForTest(context.Context) (DB, error)

	// Can the given error be retried?
	RetryableErr(error) bool
}

type Executor interface {
	Exec(string, ...interface{}) (Result, error)
}

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

type IdAllocatable interface {
	// IdAllocator returns an IdAlloc for use with a database.
	IdAllocator() *IdAlloc
}

type Idx interface {
	Cols() []string
	Vals() []interface{}
}

type Lock int

type Opts struct {
	Prefix Idx
	// At most one of StartInc and StartEx may be set
	StartInc, StartEx Idx
	// At most one of StopInc and StopEx may be set
	StopInc, StopEx Idx
	Lock            Lock
	Reverse         bool
	Limit           int
}

type Querier interface {
	Query(query string, args ...interface{}) (Rows, error)
}

type QuerierExecutorCommitter interface {
	Querier
	Commiter
	Executor
}

type Result interface {
	LastInsertId() (int64, error)
	RowsAffected() (int64, error)
}

type Retryable interface {
	CanRetry() bool
}

type Rows interface {
	Close() error
	Columns() ([]string, error)
	Err() error
	Next() bool
	Scan(dest ...interface{}) error
}

type UniqueIdx interface {
	Idx
	Unique()
}