schemadiff

type Change struct {
	// SQL is the literal statement, without a trailing semicolon.
	SQL string `json:"sql"`
	// Kind classifies the statement for consumers that gate by class.
	Kind ChangeKind `json:"kind"`
	// Destructive marks statements that discard data, constraints, or
	// indexes (column, constraint, and index drops — dropping a unique
	// index discards the same guarantee as dropping a unique constraint).
	// Destructive changes are gated by the caller, never executed
	// silently.
	Destructive bool `json:"destructive,omitempty"`
}

type ChangeKind string

type Column struct {
	// Name is the column name.
	Name string
	// Type is the canonical type text (format_type), e.g. "character
	// varying(50)" — never an alias like varchar(50).
	Type string
	// NotNull reports the NOT NULL attribute.
	NotNull bool
	// Default is the canonical default expression (pg_get_expr), empty when
	// none. For a generated column it is the generation expression.
	Default string
	// SequenceDefault reports that the default expression depends on a
	// sequence (per pg_depend) — a serial column or a hand-written nextval
	// default. In a desired-state model that sequence exists only inside
	// the rolled-back scratch transaction, so no derived plan can
	// reference it.
	SequenceDefault bool
	// SequenceOwned reports that the sequence behind the default is owned
	// by this exact column (a pg_depend OWNED BY edge, deptype 'a') — what
	// the serial shorthand produces. It is false for a hand-written
	// nextval default on a standalone sequence or another table's
	// sequence, however the sequence is named: sharing distinguishes it
	// from ownership, not naming.
	SequenceOwned bool
	// Collation is the column's explicit collation as a schema-qualified,
	// quote_ident-quoted name, empty when the column uses its type's
	// default collation. The declarative model does not manage collations yet, so
	// the model carries it only to refuse: dropping a COLLATE clause from
	// a rendered baseline would silently change sort order and index
	// semantics, and a collation delta cannot be converged without a
	// table rewrite.
	Collation string
	// Identity is the identity kind, IdentityNone for plain columns.
	Identity Identity
	// Generated reports GENERATED ALWAYS AS (...) STORED.
	Generated bool
}

type Constraint struct {
	// Name is the constraint name.
	Name string
	// Def is the canonical definition text.
	Def string
}

type Identity string

type Index struct {
	// Name is the index name.
	Name string
	// Def is the canonical CREATE INDEX statement.
	Def string
	// Invalid reports pg_index.indisvalid = false: the entry carries the
	// name and the definition but the planner never uses it, so it does not
	// deliver the desired index. On a plain table it is a concurrent build
	// that has not finished — abandoned, or still running. On a partitioned
	// parent it means not every partition has a matching attached index;
	// the server never builds a partitioned index concurrently. A
	// desired-side index, materialized on the scratch schema, is never
	// invalid, so the zero value is the delivered state.
	Invalid bool
}

type Model struct {
	// Table is the unqualified table name.
	Table string
	// PartitionKey is the server-decompiled partition key definition
	// (pg_get_partkeydef), e.g. "RANGE (created_at)" — empty for a
	// non-partitioned table.
	PartitionKey string
	// IsPartition reports that the table is itself a partition of a
	// partitioned parent (pg_class.relispartition).
	IsPartition bool
	// InheritsParents lists the classic-inheritance parents of this table.
	// Declarative partitions use the same pg_inherits catalog but are
	// excluded using pg_class.relispartition.
	InheritsParents []string
	// InheritanceChildren lists the classic-inheritance children of this
	// table. The model carries both directions so rendering either side can
	// fail closed rather than flattening inherited columns or losing edges.
	InheritanceChildren []string
	// Unlogged reports that the table is unlogged
	// (pg_class.relpersistence 'u'). The declarative model does not manage
	// persistence yet — converging it (SET LOGGED / SET UNLOGGED) is a
	// full table rewrite — so the model carries it only to refuse:
	// rendering an unlogged table as a plain CREATE TABLE would silently
	// change its crash-safety and replication behavior, and a persistence
	// mismatch fails the diff closed instead of diffing to silence.
	Unlogged bool
	// ReferencedBy lists the incoming foreign keys — constraints on other
	// tables that reference this one — as "table.constraint" strings, in
	// that order. Incoming foreign keys are not part of this table's own
	// definition and cannot be expressed in a desired file, so the model
	// carries them only for the renderer to refuse on.
	ReferencedBy []string
	// Columns are the table's columns in attribute order.
	Columns []Column
	// Constraints are the table constraints, name-sorted.
	Constraints []Constraint
	// Indexes are the non-constraint indexes, name-sorted.
	Indexes []Index
}