faithful

type Catalog struct {
	Engine Engine
	Schema string
	Tables []*Table
	// Skipped names objects the reader saw and cannot carry, as warnings.
	Notes []Warning
	// Objects are the stored definitions of the views, triggers and indexes of a SQLite database, in creation order.
	Objects []RawObject
}

type Check struct {
	Name string
	Expr string
}

type Choice struct {
	Kind Kind
	// Family is the storage family: int, float, decimal, text, bytes, date, datetime, time.
	Family string
	Type   string
	// Bits is the width of an int (16, 32, 64). Len is the character length of a bounded text or the byte
	// length of a bounded binary, 0 for an unbounded type. Prec and Scale of a decimal; Fsp of a time.
	Bits, Len, Prec, Scale, Fsp int
	// Note is why the declared type could not be carried, "" when it was.
	Note string
	// Normalized is how many text values are spelled differently by the target (decimal text), with the first as Example.
	Normalized int64
	Example    string
	// Bounded marks a key column given a bounded type that was not declared so.
	Bounded bool
	// Tight is the shortest length that holds every value (characters of a text, bytes of a binary), at least 1.
	Tight int
	// MaxSize is the longest value in bytes; it decides the TEXT or BLOB size class of an unbounded type.
	MaxSize int
}

type Column struct {
	Name string
	// SourceType is the declared type text in the source engine, as the engine reports it.
	SourceType string
	Kind       Kind
	// Special is a PostgreSQL type with no logical kind of its own that is carried as text: json, jsonb, uuid.
	Special string
	// Width is the byte width of an integer (2, 4, 8) or float (4, 8) when the source declares one.
	Width int
	// Length is the character length of a varchar / char column, 0 when none.
	Length int
	// Fixed marks a blank-padded char(n).
	Fixed bool
	// Precision and Scale of a decimal, -1 when the source declares none.
	Precision, Scale int
	NotNull          bool
	// Default is the source default expression as the source reports it, "" for none.
	Default  string
	Identity Identity
	// Marker is what an earlier datatug copy recorded on this column (PostgreSQL comment).
	Marker *Marker
	// Comment is a PostgreSQL column comment that is not a datatug marker.
	Comment string
	// Generated is the expression of a generated column, "" for an ordinary column.
	Generated string
	// SequenceStart is the next value of an identity / autoincrement counter, 0 when unknown.
	SequenceStart int64
}

type ColumnUse struct{ PK, Unique, Index, FK bool }

type Cond struct{ Field, Op, Value string }

type ConflictError struct{ Tables []string }

type Dialect interface {
	// Name is the --dialect value ("mysql").
	Name() string
	// QuoteIdent quotes a name that StorableName accepted.
	QuoteIdent(name string) string
	// StorableName says why the engine cannot store the name, "" when it can.
	StorableName(name string) string
	// MaxIdentLen is the longest name in characters.
	MaxIdentLen() int
	// Choose picks the column type for the values the pre-scan saw.
	Choose(c *Column, st *ScriptStats, use ColumnUse) Choice
	// Adjust applies the rules that need the whole plan: unification of foreign key columns, key and row size
	// budgets, foreign key and index support. It may add warnings and may refuse (an error).
	Adjust(p *ScriptPlan) error
	// Default translates a SQLite default expression for the column; note is a warning text ("" for none).
	Default(expr string, ch Choice) (def string, note string, ok bool)
	// Check translates a SQLite CHECK expression; ok is false when it cannot, with the reason in note.
	Check(expr string, t *ScriptTable) (out string, note string, ok bool)
	// Literal is the one place where a value becomes SQL text.
	Literal(ch Choice, v any) (string, error)
	// Statements.
	CreateTable(t *ScriptTable) string
	IndexSQL(t *ScriptTable, ix Index) string
	CheckSQL(t *ScriptTable, ck Check) string
	FKSQL(p *ScriptPlan, t *ScriptTable, fk ForeignKey) string
	CounterSQL(t *ScriptTable, c *ScriptColumn, next int64) string
	// Script framing.
	Header(p *ScriptPlan, h Header) []string
	Prelude(p *ScriptPlan, h Header) []string
	Epilogue(p *ScriptPlan, h Header) []string
	BeginData(t *ScriptTable) []string
	EndData(t *ScriptTable) []string
	// InsertHead is the first line of a multi-row insert; rows follow one per line, "," between and ";" after.
	InsertHead(t *ScriptTable) string
	// BatchLimits are the most rows and bytes of one insert statement.
	BatchLimits() (rows, bytes int)
}

type Diff struct {
	Object string `json:"object"`
	Aspect string `json:"aspect"`
	Left   string `json:"left"`
	Right  string `json:"right"`
}

type Endpoint struct {
	Engine  Engine
	DB      *sql.DB
	Display string
	// Schema is the PostgreSQL schema read from (source) or written to (target); "public" when empty.
	Schema string
}

type EndpointInfo struct {
	Engine  Engine `json:"engine"`
	Display string `json:"display"`
	Schema  string `json:"schema,omitempty"`
}

type Engine string

type ForeignKey struct {
	Name       string
	Columns    []string
	RefTable   string
	RefColumns []string
	OnUpdate   string // NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT
	OnDelete   string
	Deferrable bool
	Deferred   bool
	NotValid   bool
	Match      string // "FULL" when the key is MATCH FULL (PostgreSQL), else ""
}

type Header struct {
	// Name is the dataset name, Edition the contract edition label, License and Attribution as the provider gives them.
	Name, Edition, License, Attribution string
	SourceSHA256                        string
	Version                             string
}

type Identity int

type Index struct {
	Name    string
	Unique  bool
	Columns []IndexColumn
	// Where is the predicate of a partial index in source dialect, "" for a full index.
	Where string
}

type IndexColumn struct {
	Name string
	Desc bool
}

type Kind int

type Marker struct {
	Src      string `json:"src"`
	Type     string `json:"type"`
	Identity string `json:"identity,omitempty"` // "rowid" | "autoincrement"
	// Carried is the PostgreSQL type text the column was given, so a later copy can tell a widened column.
	Widened string `json:"widened,omitempty"`
}

type NameError struct{ Object, Reason string }

type Options struct {
	// Overwrite is "" (the target must hold none of the source's tables), "recreate" (drop them first) or
	// "reload" (empty them and load the rows again; their schema stays).
	Overwrite        string
	Include, Exclude []string
	// Filters is the --where / --limit of each table, by source table name.
	Filters map[string]RowFilter
	// DecimalsText keeps a DECIMAL_TEXT column whose texts numeric would spell differently as text
	// (--decimals=text); by default such a column is numeric and the change of spelling is a warning.
	DecimalsText bool
	DryRun       bool
	Progress     io.Writer
}

type Plan struct {
	From, To Engine
	Schema   string // target schema (PostgreSQL)
	Tables   []*TargetTable
	Warnings []Warning
}

type Queryer interface {
	QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
	QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row
}

type RawObject struct {
	Type, Name, Table, SQL string
}

type ReloadMismatchError struct {
	Table    string
	Problems []string
}

type Report struct {
	Command string        `json:"command"`
	Status  string        `json:"status"` // ok | ok-with-warnings | dry-run | failed
	DryRun  bool          `json:"dryRun"`
	From    EndpointInfo  `json:"from"`
	To      EndpointInfo  `json:"to"`
	Tables  []TableReport `json:"tables"`
	Totals  Totals        `json:"totals"`
	// Warnings lists every feature that was not carried exactly, per object.
	Warnings []Warning `json:"warnings"`
	// Plan is the DDL that is (dry-run: would be) executed.
	Plan     []string `json:"plan,omitempty"`
	ExitCode int      `json:"exitCode"`
	Error    string   `json:"error,omitempty"`
}

type RowFilter struct {
	Where []Cond
	Limit int
}

type ScriptColumn struct {
	// Object names the column in a warning: table.column.
	Object  string
	Src     *Column
	Name    string
	Choice  Choice
	NotNull bool
	Default string
	AutoInc bool
	Stats   *ScriptStats
	Use     ColumnUse
}

type ScriptPlan struct {
	Dialect  Dialect
	Tables   []*ScriptTable
	Warnings []Warning
}

type ScriptRequest struct {
	Dialect string
	DB      *sql.DB
	Display string
	Header  Header
	// DryRun plans and reports, and writes nothing.
	DryRun bool
	// Include and Exclude name the tables to write (all when both are empty).
	Include, Exclude []string
}

type ScriptStats struct {
	MaxBytes      int
	MaxBlob       int
	BadUTF8       int64 // text values that are not valid UTF-8
	NonFinite     int64 // infinite floats
	LowYear       int64 // dates and timestamps before year 1000
	MaxFsp        int   // most decimals of a timestamp or time text
	MaxIntDigits  int   // most integer digits of a value that is a decimal number
	MaxFracDigits int
	Empty         int64 // empty texts
	// RealExample is the first REAL value the column holds, as its shortest decimal ("" when it holds none).
	RealExample string
	// contains filtered or unexported fields
}

type ScriptTable struct {
	Src     *Table
	Name    string
	Columns []*ScriptColumn
	PK      []string // target column names
	Uniques []Unique
	Indexes []Index
	Checks  []Check
	FKs     []ForeignKey
	Rows    int64
	// OrderBy is the ORDER BY of the source query: a total order.
	OrderBy string
}

type ScriptUsageError struct{ Err error }

type Table struct {
	Name    string
	Columns []*Column
	// PKName is the constraint name, "" when the engine does not report one.
	PKName  string
	PK      []string
	Uniques []Unique
	Indexes []Index
	Checks  []Check
	FKs     []ForeignKey
	// Rows is the row count read from the source.
	Rows int64
	// CreateSQL is the CREATE TABLE statement of a SQLite table, as stored.
	CreateSQL string
}

type TableReport struct {
	Name              string   `json:"name"`
	Rows              int64    `json:"rows"`
	Columns           int      `json:"columns"`
	PrimaryKey        []string `json:"primaryKey"`
	ForeignKeys       int      `json:"foreignKeys"`
	Indexes           int      `json:"indexes"`
	UniqueConstraints int      `json:"uniqueConstraints"`
	CheckConstraints  int      `json:"checkConstraints"`
}

type TargetColumn struct {
	Src      *Column
	Name     string
	Type     string // type text in the target dialect
	NotNull  bool
	Default  string // default expression in the target dialect, "" for none
	Identity Identity
	Marker   *Marker
	// Kind is the logical kind the column is written as.
	Kind Kind
	// Cast is the PostgreSQL type a text parameter is cast to on insert ("" for a parameter of the column's own type).
	Cast string
	// contains filtered or unexported fields
}

type TargetTable struct {
	Src     *Table
	Name    string
	Columns []*TargetColumn
	PKName  string
	PK      []string
	Uniques []Unique
	Indexes []Index
	Checks  []Check
	FKs     []ForeignKey
	// Copied is the number of rows written, set when the table has been loaded.
	Copied int64
	// Filter is the --where / --limit of the table, nil for none.
	Filter *compiledFilter
	// Loaded says the table's rows have been written (Copied is then the number).
	Loaded bool
	// Reload says the table exists on the target and keeps its schema: it is emptied and loaded again.
	Reload bool
}

type Totals struct {
	Tables            int   `json:"tables"`
	Rows              int64 `json:"rows"`
	Columns           int   `json:"columns"`
	PrimaryKeys       int   `json:"primaryKeys"`
	ForeignKeys       int   `json:"foreignKeys"`
	Indexes           int   `json:"indexes"`
	UniqueConstraints int   `json:"uniqueConstraints"`
	CheckConstraints  int   `json:"checkConstraints"`
}

type Unique struct {
	Name    string
	Columns []string
}

type Warning struct {
	Kind string `json:"kind"`
	// Object names the table, column, index or constraint the warning is about ("t", "t.c", "t.idx").
	Object  string `json:"object"`
	Message string `json:"message"`
}