compat

type Assignment struct {
	Column string     `json:"column"`
	Value  Expression `json:"value"`
}

type CatalogObject struct {
	Kind       string `json:"kind"`
	Name       string `json:"name"`
	Definition string `json:"definition,omitempty"`
	Reason     string `json:"reason"`
}

type Change struct {
	Source        Target     `json:"source"`
	Sequence      uint64     `json:"sequence"`
	CommittedAt   time.Time  `json:"committed_at"`
	Kind          ChangeKind `json:"kind"`
	Table         string     `json:"table"`
	PrimaryKey    Row        `json:"primary_key"`
	Before        Row        `json:"before,omitempty"`
	After         Row        `json:"after,omitempty"`
	TransactionID string     `json:"transaction_id"`
}

type ChangeKind string

type Column struct {
	Name     string      `json:"name"`
	Type     Type        `json:"type"`
	Nullable bool        `json:"nullable"`
	Default  *Expression `json:"default,omitempty"`
	// DomainRef, when set, names a Schema.Domains entry this column takes its
	// CHECK/NOT NULL/DEFAULT from. It is additive and omitempty, so a column
	// without it stays byte-identical. The column MUST still carry Type equal to
	// the domain's base type: the data chain (export/import canonicalization) keys
	// off Column.Type.Family, and both engines physically store the domain value
	// as its base type, so the redundant Type keeps that path unchanged and keeps
	// PG(native domain) and SQLite(inlined) storing identical values. A
	// domain-referencing column must be otherwise neutral — Nullable true, no own
	// Default, no Generated — so the domain is the single source of the constraint
	// (validated in Schema.Validate). On PostgreSQL the column's SQL type is the
	// domain name; on SQLite it is the base type with the domain's CHECK/NOT
	// NULL/DEFAULT inlined.
	DomainRef string `json:"domain,omitempty"`
	// Generated, when set, makes this a STORED generated column whose value is
	// computed from Expression rather than supplied on INSERT/UPDATE. It is an
	// additive, omitempty field: a column without it stays byte-identical in the
	// canonical JSON and in every emitted statement. See GeneratedColumn.
	Generated *GeneratedColumn `json:"generated,omitempty"`
}

type CommonTableExpr struct {
	Name  string      `json:"name"`
	Query SelectQuery `json:"query"`
}

type CompoundSelect struct {
	Operator string      `json:"operator"`
	Query    SelectQuery `json:"query"`
}

type ConflictError struct {
	Table      string
	PrimaryKey Row
	Expected   Row
	Actual     Row
}

type Constraint struct {
	Kind       ConstraintKind `json:"kind"`
	Columns    []string       `json:"columns"`
	References *Reference     `json:"references,omitempty"`
	Expression *Expression    `json:"expression,omitempty"`
}

type ConstraintKind string

type Contract struct {
	Source           Target    `json:"source"`
	Destination      Target    `json:"destination"`
	RequiredFeatures []Feature `json:"required_features"`
}

type Domain struct {
	Name    string      `json:"name"`
	Type    Type        `json:"type"`
	Check   *Expression `json:"check,omitempty"`
	NotNull bool        `json:"not_null,omitempty"`
	Default *Expression `json:"default,omitempty"`
}

type Engine string

type Expression struct {
	Kind  string       `json:"kind"`
	Value string       `json:"value,omitempty"`
	Args  []Expression `json:"args,omitempty"`
}

type Feature string

type Finding struct {
	Feature Feature       `json:"feature"`
	Status  MappingStatus `json:"status"`
	Reason  string        `json:"reason,omitempty"`
}

type GeneratedColumn struct {
	Expression Expression `json:"expression"`
	Stored     bool       `json:"stored"`
}

type Index struct {
	Name    string        `json:"name"`
	Table   string        `json:"table"`
	Unique  bool          `json:"unique,omitempty"`
	Columns []IndexColumn `json:"columns"`
	Where   *Expression   `json:"where,omitempty"`
}

type IndexColumn struct {
	Column     string      `json:"column,omitempty"`
	Descending bool        `json:"descending,omitempty"`
	Expression *Expression `json:"expression,omitempty"`
}

type Inspection struct {
	Schema     Schema          `json:"schema"`
	Exact      bool            `json:"exact"`
	Source     string          `json:"source"`
	Unresolved []CatalogObject `json:"unresolved,omitempty"`
}

type Join struct {
	Kind  string      `json:"kind"`
	Table TableSource `json:"table"`
	On    Expression  `json:"on"`
}

type MappingStatus string

type Ordering struct {
	Expression Expression `json:"expression"`
	Descending bool       `json:"descending,omitempty"`
}

type Projection struct {
	Expression Expression `json:"expression"`
	Alias      string     `json:"alias,omitempty"`
}

type Reference struct {
	Table    string            `json:"table"`
	Columns  []string          `json:"columns"`
	OnUpdate ReferentialAction `json:"on_update,omitempty"`
	OnDelete ReferentialAction `json:"on_delete,omitempty"`
}

type ReferentialAction string

type Routine struct {
	Name       string             `json:"name"`
	Parameters []RoutineParameter `json:"parameters,omitempty"`
	Actions    []RoutineAction    `json:"actions"`
}

type RoutineAction struct {
	Kind        string       `json:"kind"`
	Table       string       `json:"table"`
	Assignments []Assignment `json:"assignments,omitempty"`
	Where       *Expression  `json:"where,omitempty"`
	// The fields below belong to the read action ("select") and are all additive
	// and omitempty, so an insert/update/delete action serializes byte-identically
	// to how it did before the read action existed.
	//
	// Relation is the source of a "select": a table OR a view. It is a separate
	// field from Table (which names the written table of a write action) because a
	// read may target a view, where the joins/aggregates live — the canonical
	// division that keeps the read action free of joins.
	Relation string `json:"relation,omitempty"`
	// Columns are the DECLARED output columns of a "select". A View carries no
	// output types (it is {Name, Query}) and they cannot be inferred in general
	// (count(*), arbitrary expressions), so the action declares them: this layer
	// declares, it does not guess. The declaration is also the check — a value
	// that is not of the declared family fails loudly in canonicalValue instead of
	// reaching the caller as garbage.
	Columns []RoutineResultColumn `json:"columns,omitempty"`
	// OrderBy is the DECLARED ordering of a "select". Order columns are never
	// caller-supplied: a column name cannot be bound as a placeholder, so taking
	// it from the caller would be an injection path. It is mandatory whenever
	// Limit or Offset is present, because without a total order "page 2" can mean
	// different rows on each engine.
	OrderBy []RoutineOrdering `json:"order_by,omitempty"`
	// Limit and Offset are values, so they MAY come from the caller: each is a
	// routine expression resolving to a non-negative integer ("parameter" or
	// "integer"), bound as a placeholder after the WHERE placeholders. Offset
	// requires Limit: SQLite has no OFFSET without LIMIT, and emitting a synthetic
	// "LIMIT -1" to paper over that would be exactly the silent divergence this
	// layer refuses.
	Limit  *Expression `json:"limit,omitempty"`
	Offset *Expression `json:"offset,omitempty"`
}

type RoutineOrdering struct {
	Column     string `json:"column"`
	Descending bool   `json:"descending,omitempty"`
}

type RoutineParameter struct {
	Name string `json:"name"`
	Type Type   `json:"type"`
}

type RoutineResultColumn struct {
	Name string `json:"name"`
	Type Type   `json:"type"`
}

type Row map[string]Value

type Schema struct {
	Tables  []Table `json:"tables"`
	Indexes []Index `json:"indexes,omitempty"`
	// Domains is the list of named SQL domains (a base type plus an optional
	// CHECK, NOT NULL and DEFAULT). It is additive and omitempty, so a schema
	// without domains stays byte-identical in the canonical JSON and in every
	// emitted statement. PostgreSQL has native domains (CREATE DOMAIN emitted
	// before the tables); SQLite has none, so a column that references a domain is
	// inlined with the domain's base type + CHECK (+ NOT NULL/DEFAULT). See Domain.
	Domains  []Domain  `json:"domains,omitempty"`
	Views    []View    `json:"views,omitempty"`
	Triggers []Trigger `json:"triggers,omitempty"`
	Routines []Routine `json:"routines,omitempty"`
}

type SearchResult struct {
	ID string `json:"id"`
}

type SelectQuery struct {
	// With is the list of non-recursive common table expressions (CTEs) that
	// precede this query: WITH name AS (SELECT ...), ... <query>. Each CTE query
	// is itself a SelectQuery in the same bounded grammar. WITH RECURSIVE is
	// deliberately not modeled and is rejected at parse time, because its
	// termination and row-ordering semantics are hard to guarantee byte-identical
	// between SQLite and PostgreSQL. Absent CTEs leave the query byte-identical,
	// and the field is omitted from JSON so existing view snapshots do not change.
	With     []CommonTableExpr `json:"with,omitempty"`
	Distinct bool              `json:"distinct,omitempty"`
	Columns  []Projection      `json:"columns"`
	From     TableSource       `json:"from"`
	Joins    []Join            `json:"joins,omitempty"`
	Where    *Expression       `json:"where,omitempty"`
	GroupBy  []Expression      `json:"group_by,omitempty"`
	Having   *Expression       `json:"having,omitempty"`
	// Compounds is the left-associative chain of set operations applied after
	// this (the leading) SELECT: q0 op1 q1 op2 q2 ... The trailing OrderBy,
	// Limit and Offset below apply to the whole compound, not to the last
	// branch, so each CompoundSelect.Query carries none of them. Absent
	// compounds leave the single-SELECT behavior byte-identical, and the field
	// is omitted from JSON so existing view snapshots do not change.
	Compounds []CompoundSelect `json:"compounds,omitempty"`
	OrderBy   []Ordering       `json:"order_by,omitempty"`
	Limit     *int             `json:"limit,omitempty"`
	Offset    *int             `json:"offset,omitempty"`
}

type Snapshot struct {
	Schema Schema           `json:"schema"`
	Rows   map[string][]Row `json:"rows"`
}

type Store struct {
	Target Target
	DB     *sql.DB
}

type Table struct {
	Name        string       `json:"name"`
	Columns     []Column     `json:"columns"`
	Constraints []Constraint `json:"constraints,omitempty"`
}

type TableSource struct {
	Table    string       `json:"table,omitempty"`
	Alias    string       `json:"alias,omitempty"`
	Subquery *SelectQuery `json:"subquery,omitempty"`
}

type Target struct {
	Engine  Engine  `json:"engine"`
	Version Version `json:"version"`
}

type Trigger struct {
	Name    string          `json:"name"`
	Table   string          `json:"table"`
	Timing  string          `json:"timing"`
	Event   string          `json:"event"`
	When    *Expression     `json:"when,omitempty"`
	Actions []TriggerAction `json:"actions"`
}

type TriggerAction struct {
	Kind        string       `json:"kind"`
	Table       string       `json:"table"`
	Assignments []Assignment `json:"assignments,omitempty"`
	Where       *Expression  `json:"where,omitempty"`
}

type Type struct {
	Family TypeFamily `json:"family"`
	// Arguments preserve details such as precision, scale, length or array
	// dimensions without coupling the canonical schema to SQL text.
	Arguments []int `json:"arguments,omitempty"`
}

type TypeFamily string

type Value struct {
	Kind  ValueKind `json:"kind"`
	Value string    `json:"value,omitempty"`
}

type ValueKind string

type VerificationReport struct {
	SourceDigest      string `json:"source_digest"`
	DestinationDigest string `json:"destination_digest"`
	Equivalent        bool   `json:"equivalent"`
}

type Version struct {
	Major int `json:"major"`
	Minor int `json:"minor"`
	Patch int `json:"patch"`
}

type View struct {
	Name  string      `json:"name"`
	Query SelectQuery `json:"query"`
}