sqldb

type BackendType uint8

type BaseDB struct {
	*sql.DB

	// BackendType defines the type of database backend the database is.
	BackendType BackendType

	// SkipMigrations can be set to true to skip running any migrations
	// during the iinitialization of the database.
	SkipMigrations bool
}

type BatchQueryFunc[T any, R any] func(context.Context, []T) ([]R, error)

type BatchedQuerier interface {
	// BeginTx creates a new database transaction given the set of
	// transaction options.
	BeginTx(ctx context.Context, options TxOptions) (*sql.Tx, error)

	// Backend returns the type of the database backend used.
	Backend() BackendType
}

type BatchedTx[Q any] interface {
	// ExecTx will execute the passed txBody, operating upon generic
	// parameter Q (usually a storage interface) in a single transaction.
	//
	// The set of TxOptions are passed in order to allow the caller to
	// specify if a transaction should be read-only and optionally what
	// type of concurrency control should be used.
	ExecTx(ctx context.Context, txOptions TxOptions,
		txBody func(Q) error, reset func()) error

	// Backend returns the type of the database backend used.
	Backend() BackendType
}

type CollectAndBatchDataQueryFunc[ID any, BatchData any] func(context.Context,
	[]ID) (BatchData, error)

type CollectFunc[T any, ID any] func(T) (ID, error)

type ConvertFunc[I any, T any] func(I) T

type CursorExtractFunc[T any, C any] func(T) C

type DB interface {
	MigrationExecutor

	// GetBaseDB returns the underlying BaseDB instance.
	GetBaseDB() *BaseDB
}

type ErrDeadlockError struct {
	DbError error
}

type ErrSQLUniqueConstraintViolation struct {
	DBError error
}

type ErrSchemaError struct {
	DbError error
}

type ErrSerializationError struct {
	DBError error
}

type ItemCallbackFunc[R any] func(context.Context, R) error

type ItemProcessFunc[T any] func(context.Context, T) error

type ItemWithBatchDataProcessFunc[T any, BatchData any] func(context.Context,
	T, BatchData) error

type MakeTx func() (Tx, error)

type MigrateOpt func(*migrateOptions)

type MigrationDescriptor struct {
	// Name is the name of the migration.
	Name string

	// Version represents the "global" database version for this migration.
	// Unlike the schema version tracked by golang-migrate, it encompasses
	// all migrations, including those managed by golang-migrate as well
	// as custom in-code migrations.
	Version int

	// SchemaVersion represents the schema version tracked by golang-migrate
	// at which the migration is applied.
	SchemaVersion int
}

type MigrationExecutor interface {
	// ExecuteMigrations runs database migrations for the given migration
	// set using the executor's default production migration target. A
	// migration may include a schema change, a custom migration function,
	// or both.
	ExecuteMigrations(set MigrationSet) error
}

type MigrationSet struct {
	// TrackingTableName is the name of the table used by golang-migrate to
	// track the current schema version.
	TrackingTableName string

	// SQLFiles is the embedded file system containing the SQL migration
	// files.
	SQLFiles embed.FS

	// SQLFileDirectory is the directory containing the SQL migration files.
	SQLFileDirectory string

	// MakeProgrammaticMigrations is a function that returns a map of
	// ProgrammaticMigrEntry functions that can be used to execute a Golang
	// based migration step. The key is the migration version and the value
	// is the Golang migration function entry that should be run for the
	// migration version. Note that a database version can be either an SQL
	// migration or a programmatic migration, but not both at the same time.
	MakeProgrammaticMigrations func(
		*BaseDB) (map[uint]migrate.ProgrammaticMigrEntry, error)

	// LatestMigrationVersion is the latest migration version of the
	// database. This is used to implement downgrade protection for the
	// daemon.
	LatestMigrationVersion uint

	// Descriptors defines a list of migrations to be applied to the
	// database. Each migration is assigned a version number that documents
	// and validates the expected execution order.
	// The schema version, tracked by golang-migrate, ensures migrations are
	// applied to the correct schema. For migrations involving only schema
	// changes, the migration function can be left nil. For custom
	// migrations an implemented migration function is required.
	Descriptors []MigrationDescriptor
}

type MigrationTarget func(mig *migrate.Migrate,
	currentDbVersion int, maxMigrationVersion uint) error

type OnBackoff func(retry int, delay time.Duration)

type PagedQueryFunc[C any, T any] func(context.Context, C, int32) ([]T, error)

type PostgresConfig struct {
	Dsn                string        `long:"dsn" description:"Database connection string."`
	Timeout            time.Duration `long:"timeout" description:"Database connection timeout. Set to zero to disable."`
	MaxOpenConnections int           `long:"maxconnections" description:"Max open connections to keep alive to the database server."`
	MaxIdleConnections int           `long:"maxidleconnections" description:"Max number of idle connections to keep in the connection pool."`
	ConnMaxLifetime    time.Duration `` /* 139-byte string literal not displayed */
	ConnMaxIdleTime    time.Duration `` /* 137-byte string literal not displayed */
	RequireSSL         bool          `long:"requiressl" description:"Whether to require using SSL (mode: require) when connecting to the server."`
	SkipMigrations     bool          `long:"skipmigrations" description:"Skip applying migrations on startup."`
	QueryConfig        `group:"query" namespace:"query"`
}

type PostgresStore struct {
	*BaseDB
	// contains filtered or unexported fields
}

type QueryConfig struct {
	// MaxBatchSize is the maximum number of items included in a batch
	// query IN clauses list.
	MaxBatchSize uint32 `` /* 178-byte string literal not displayed */

	// MaxPageSize is the maximum number of items returned in a single page
	// of results. This is used for paginated queries.
	MaxPageSize uint32 `` /* 137-byte string literal not displayed */
}

type QueryCreator[Q any] func(*sql.Tx) Q

type RollbackTx func(tx Tx) error

type SqliteConfig struct {
	Timeout            time.Duration `long:"timeout" description:"The time after which a database query should be timed out."`
	BusyTimeout        time.Duration `` /* 126-byte string literal not displayed */
	MaxConnections     int           `long:"maxconnections" description:"The maximum number of open connections to the database."`
	MaxIdleConnections int           `long:"maxidleconnections" description:"Max number of idle connections to keep in the connection pool."`
	ConnMaxLifetime    time.Duration `` /* 139-byte string literal not displayed */
	PragmaOptions      []string      `` /* 219-byte string literal not displayed */
	SkipMigrations     bool          `long:"skipmigrations" description:"Skip applying migrations on startup."`

	// SkipMigrationDbBackup if true, then a backup of the database will not
	// be created before applying migrations.
	SkipMigrationDbBackup bool `long:"skipmigrationdbbackup" description:"Skip creating a backup of the database before applying migrations."`

	QueryConfig `group:"query" namespace:"query"`
}

type SqliteStore struct {
	DbPath string

	Config *SqliteConfig

	*BaseDB
}

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

type TransactionExecutor[Query any] struct {
	BatchedQuerier
	// contains filtered or unexported fields
}

type Tx interface {
	// Commit commits the database transaction, an error should be returned
	// if the commit isn't possible.
	Commit() error

	// Rollback rolls back an incomplete database transaction.
	// Transactions that were able to be committed can still call this as a
	// noop.
	Rollback() error
}

type TxBody func(tx Tx) error

type TxExecutorOption func(*txExecutorOptions)

type TxOptions interface {
	// ReadOnly returns true if the transaction should be read only.
	ReadOnly() bool
}