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 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 Cond struct{ Field, Op, Value string }

type ConflictError struct{ Tables []string }

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 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 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"`
}