data

type Applied struct {
	Migration
	Ms int64 `json:"ms"`
}

type Column struct {
	Name     string `json:"name"`
	Type     string `json:"type"` // as Postgres writes it, e.g. "timestamp with time zone"
	Nullable bool   `json:"nullable"`
	Default  string `json:"default,omitempty"` // SQL expression
}

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

type Error struct {
	Code string `json:"code"` // e.g. "DB601"
	Msg  string `json:"message"`
	Fix  string `json:"fix"`
	Err  error  `json:"-"`
}

type Migration struct {
	Version  int64    `json:"version"`
	Name     string   `json:"name"`
	File     string   `json:"file"`
	Checksum string   `json:"checksum"` // sha256 of the file, in hex
	Track    []string `json:"track,omitempty"`
	From     string   `json:"from,omitempty"` // "<package> <file>": installed from a sub-app by `loom db install`
	// NoTransaction is set by `-- loom:no-transaction`: the migration runs
	// outside a transaction, for statements that can't run in one, such
	// as CREATE INDEX CONCURRENTLY.
	NoTransaction bool   `json:"no_transaction,omitempty"`
	SQL           string `json:"-"`
}

type MigrationState struct {
	Migration
	// State is "applied", "pending", "changed" (applied, then edited: its
	// checksum no longer matches) or "missing" (applied, but its file is
	// gone).
	State     string     `json:"state"`
	AppliedAt *time.Time `json:"applied_at,omitempty"`
}

type Querier interface {
	Exec(ctx context.Context, query string, args ...any) (Result, error)
	Query(ctx context.Context, query string, args ...any) (Rows, error)
	QueryRow(ctx context.Context, query string, args ...any) Row
}

type QueryResult struct {
	Columns   []string `json:"columns"`
	Rows      [][]any  `json:"rows"`
	Truncated bool     `json:"truncated"` // there were more than limit rows
}

type QueryStat struct {
	// Query is the statement on one line, cut after 500 bytes; never its
	// arguments. "other" counts statements past the first 500 seen.
	Query string `json:"query"`
	// Rows is the rows queries returned and statements changed, in all.
	Rows   uint64 `json:"rows"`
	Errors uint64 `json:"errors"`
	trace.TimingSummary
}

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

type Row interface {
	Scan(dest ...any) error
}

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

type SchemaInfo struct {
	Tables []Table `json:"tables"`
}

type ServerStats struct {
	// Since is when Postgres last reset the counts, if it says.
	Since  *time.Time  `json:"since"`
	Tables []TableStat `json:"tables"` // the most rows read by sequential scans first
	// Statements are pg_stat_statements' busiest, by total time, or
	// empty without the extension; StatementsNote then says why.
	Statements     []StatementStat `json:"statements"`
	StatementsNote string          `json:"statements_note,omitempty"`
}

type StatementStat struct {
	Query   string  `json:"query"`
	Calls   int64   `json:"calls"`
	TotalMS float64 `json:"total_ms"`
	MeanMS  float64 `json:"mean_ms"`
	Rows    int64   `json:"rows"`
}

type Status struct {
	Migrations []MigrationState `json:"migrations"`
	Pending    int              `json:"pending"`
	// Problems are errors that stop Migrate: edited migrations (DB614).
	Problems []*Error `json:"problems"`
}

type Table struct {
	Name       string   `json:"name"`
	Columns    []Column `json:"columns"`
	PrimaryKey []string `json:"primary_key"`
	Tracked    bool     `json:"tracked"`
}

type TableStat struct {
	Name       string `json:"name"`
	Rows       int64  `json:"rows"` // live rows, as Postgres estimates
	Bytes      int64  `json:"bytes"`
	SeqScans   int64  `json:"seq_scans"`
	SeqRows    int64  `json:"seq_rows"` // rows those scans read
	IndexScans int64  `json:"index_scans"`
	Inserts    int64  `json:"inserts"`
	Updates    int64  `json:"updates"`
	Deletes    int64  `json:"deletes"`
	// Warning says when the table is read mostly by sequential scans of
	// many rows: a query on it has no index it can use.
	Warning string `json:"warning,omitempty"`
}

type Tx interface {
	Querier
	// Context is the context the transaction was started with.
	Context() context.Context
	// AfterCommit runs f after the transaction commits, never if it rolls
	// back. Use it to notify live pages of committed changes.
	AfterCommit(f func())
	// AfterRollback runs f if the transaction rolls back, for code that
	// keeps state on the transaction's behalf (in-memory job stores).
	AfterRollback(f func())
	// DB is the database the transaction belongs to.
	DB() *DB
}