driver

type Backend interface {
	Name() string
	// OpenPools establishes the writer and reader pools plus any dialect
	// resources (file lock, keeper pool). The returned cleanup releases them
	// in the correct order, and must not close a caller-owned Config.DB.
	OpenPools(ctx context.Context, cfg Config) (write, read *sql.DB, cleanup func() error, err error)
	// Rebind rewrites '?' placeholders to the dialect's form (identity for
	// SQLite and MySQL, '$n' for Postgres).
	Rebind(query string) string
	// Migrations returns the ordered DDL for this dialect. Version numbers are
	// per-dialect (a database is never more than one dialect).
	Migrations() []Migration
	// MigrateLock serializes concurrent migrations across processes. It runs
	// inside each per-version transaction (no-op when the database is private
	// to one process).
	MigrateLock(ctx context.Context, tx *sql.Tx) error
	// ClaimLock serializes claim transactions across processes. It runs at the
	// start of ClaimDueMulti (no-op for single-process SQLite).
	ClaimLock(ctx context.Context, tx *sql.Tx) error
	// RunLock locks a run row for the duration of a DAG-mutating transaction
	// (complete/fail/cancel), serializing per-run decisions across processes
	// (no-op for single-process SQLite).
	RunLock(ctx context.Context, tx *sql.Tx, runID string) error
	// SupportsLeases reports whether step leases are meaningful for this
	// dialect (true for networked databases; false for single-process SQLite).
	SupportsLeases() bool
	// SupportsCheckpoint reports whether the WAL checkpoint loop applies.
	SupportsCheckpoint(cfg Config) bool
	// RecoverOnBoot reports whether boot-time recovery of RUNNING rows applies.
	RecoverOnBoot(cfg Config) bool
	// KeyGate is the per-key concurrency predicate (no placeholders) used on
	// the claim path: it admits a step only while fewer than key_limit RUNNING
	// steps share its concurrency_key. SQLite/Postgres use the correlated form
	// from CorrelatedKeyGate; MySQL must use a derived-table form because it
	// forbids reading the table being updated in a subquery (error 1093).
	KeyGate() string
	// SequenceGate is the predicate (no placeholders) that admits a step only
	// when no earlier-inserted step in the same sequence is unfinished. It is
	// a correlated subquery on the enclosing steps row (SQLite/Postgres); MySQL
	// needs the derived-table form.
	SequenceGate() string
	// KeysGate is the predicate (no placeholders) that admits a step only when
	// every extra concurrency key on the step has a free slot (fewer than its
	// limit RUNNING siblings with the same name and value).
	KeysGate() string
	// LabelGate is the SQL predicate (containing one '?' for the worker-labels
	// JSON) admitting a step only when its labels are a subset of the worker's.
	LabelGate() string
	// BlockedDependentsSQL returns a statement ('?' placeholders: runID,
	// blockedStatus, dependency name) selecting the BLOCKED steps of a run
	// that depend on the named step, returning id, name, depends_on. It lets
	// completion inspect only the direct dependents of the step that finished
	// rather than every blocked step in the run.
	BlockedDependentsSQL() string
	// UpsertSQL returns an INSERT that updates the given columns when the
	// conflict target already exists. insertCols are the destination columns,
	// conflictCols the unique key, updateCols the columns to overwrite on
	// conflict; the returned statement takes one '?' per insert column.
	UpsertSQL(table string, insertCols, conflictCols, updateCols []string) string
}

type Config struct {
	// Mode is the built-in SQLite storage mode; ignored by custom drivers.
	Mode Mode
	// Path is the SQLite database file path; required for ModeFile.
	Path string
	// DSN is the driver-specific connection string.
	DSN string
	// DB, when non-nil, is an existing pool owned by the caller. Drivers with
	// a single-pool model (Postgres, MySQL) reuse it instead of dialing DSN,
	// and cleanup must leave it open.
	DB *sql.DB
	// Driver is the registered driver name ("sqlite", "postgres", "mysql",
	// ...). Empty selects the built-in SQLite driver from Mode.
	Driver string
	// RecoverRunningOnBoot (single-process drivers only): when true, runs left
	// RUNNING or INTERRUPTED by a previous process are re-queued on Open; when
	// false they are marked FAILED.
	RecoverRunningOnBoot bool
	// CheckpointInterval is how often WAL drivers run a passive checkpoint to
	// bound WAL growth. <=0 uses the driver's default; values below 10ms are
	// clamped to 10ms.
	CheckpointInterval time.Duration
}

type InsertBatcher interface {
	InsertBatchRows() int
}

type MigrateLocker interface {
	LockMigration(ctx context.Context, db *sql.DB) (release func(), err error)
}

type Migration struct {
	Version int
	SQL     string
}

type Mode int

type UniqueViolationer interface {
	IsUniqueViolation(err error) bool
}