bench

type Column struct {
	Name string
	Kind formula.Kind
}

type Execer interface {
	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
}

type LookupReport struct {
	Target string
	Rows   int
	// Map is the time of one lookup in a map[string]formula.Value built
	// from the table; MapBytes the heap the map and its keys took, as
	// the runtime measured it.
	Map      time.Duration
	MapBytes int64
	// Stmt is the time of one prepared-statement lookup on the engine.
	Stmt time.Duration
}

type Options struct {
	// Commits is the number of commits to write.
	Commits int
	// Documents is the number of documents the commits are spread over.
	// The first Documents commits create, the rest update, so that every
	// document receives Commits/Documents versions.
	Documents int
	// Lines is the number of child rows per version.
	Lines int
	// Batch is the number of commits per transaction; 1 is unbatched, one
	// transaction per commit, which is how a user's edit commits.
	Batch int
	// Seed seeds the values.
	Seed uint64
}

type Report struct {
	Target    string
	Commits   int
	Documents int
	Lines     int
	Batch     int
	// Elapsed is the wall time of all commits; PerSecond the throughput.
	Elapsed   time.Duration
	PerSecond float64
	// The latency percentiles of one commit (Batch 1) or of one batch.
	P50, P90, P99, Max time.Duration
	// FileBytes is the size of the database on disk after the run.
	FileBytes int64
}

type SQLite struct {
	// Synchronous is the PRAGMA synchronous setting: NORMAL, the
	// architecture page's choice, where a commit is durable against a
	// crash of the process but the last commits may be lost on power
	// failure, or FULL, where every commit is fsynced.
	Synchronous string
	// BackgroundCheckpoints turns SQLite's automatic checkpoint off, where
	// the committing connection copies the log into the database file
	// every 1,000 pages and pays that fsync inside a commit, and runs
	// PRAGMA wal_checkpoint(PASSIVE) on a second connection every 100 ms
	// instead, off the commit path. A passive checkpoint never resets the
	// log while a writer keeps appending, so when the log passes
	// WALLimit bytes the checkpointer runs wal_checkpoint(TRUNCATE),
	// which waits for the writer's transaction, holds the next one back
	// while it copies the rest, and empties the log.
	BackgroundCheckpoints bool
	// WALLimit is the log size that triggers a truncating checkpoint; 0
	// is 64 MB.
	WALLimit int64
}

type Target interface {
	// Name names the engine in reports.
	Name() string
	// Open opens or creates the database at path for the single writer,
	// configured as the store would configure it.
	Open(path string) (*sql.DB, error)
	// OpenReadOnly opens the database at path for reading, as a second
	// process would while the writer holds it.
	OpenReadOnly(path string) (*sql.DB, error)
	// ColumnType spells the SQL type of a column holding values of the
	// kind, as the generated tables of ADR-0014 would declare it.
	ColumnType(k formula.Kind) string
	// FillRates fills the rates table of the lookup benchmark with n rows
	// whose code is "K" and seven digits and whose rate is the row number
	// times 0.001, in the engine's own bulk way, on the given connection.
	FillRates(ctx context.Context, conn Execer, n int) error
	// FileSize reports the bytes the database at path occupies on disk,
	// its log included.
	FileSize(path string) int64
}