diff

Documentation

Index

• type CompositeTypeDiffResult
  • func DiffCompositeTypes(current, desired *orderedmap.Map[string, *model.CompositeType], dc DropChecker) (*CompositeTypeDiffResult, error)
• type DomainDiffResult
  • func DiffDomains(current, desired *orderedmap.Map[string, *model.Domain], dc DropChecker) (*DomainDiffResult, error)
• type DropChecker
• type EnumDiffResult
  • func DiffEnums(current, desired *orderedmap.Map[string, *model.Enum], dc DropChecker) (*EnumDiffResult, error)
• type RetypedColumn
• type RoutineDiffResult
  • func DiffRoutines(current, desired *orderedmap.Map[string, *model.Routine], dc DropChecker) (*RoutineDiffResult, error)
• type SequenceDiffResult
  • func DiffSequences(current, desired *orderedmap.Map[string, *model.Sequence], dc DropChecker) (*SequenceDiffResult, error)
• type TableDiffResult
  • func DiffTables(current, desired *orderedmap.Map[string, *model.Table], dc DropChecker) (*TableDiffResult, error)
• type ViewDiffResult
  • func DiffViews(current, desired *orderedmap.Map[string, *model.View], dc DropChecker) (*ViewDiffResult, error)

Types

type CompositeTypeDiffResult

type CompositeTypeDiffResult struct {
	Stmts               []string
	DropStmts           []string
	DisallowedDropStmts []string
}

func DiffCompositeTypes

func DiffCompositeTypes(current, desired *orderedmap.Map[string, *model.CompositeType], dc DropChecker) (*CompositeTypeDiffResult, error)

type DomainDiffResult

type DomainDiffResult struct {
	Stmts               []string
	DropStmts           []string
	DisallowedDropStmts []string
}

func DiffDomains

func DiffDomains(current, desired *orderedmap.Map[string, *model.Domain], dc DropChecker) (*DomainDiffResult, error)

type DropChecker

type DropChecker interface {
	IsDropAllowed(objectType string) bool
}

DropChecker checks whether dropping a specific object type is allowed.

type EnumDiffResult

type EnumDiffResult struct {
	Stmts               []string
	DropStmts           []string
	DisallowedDropStmts []string
}

func DiffEnums

func DiffEnums(current, desired *orderedmap.Map[string, *model.Enum], dc DropChecker) (*EnumDiffResult, error)

type RetypedColumn

type RetypedColumn struct {
	Name    string
	Current string
}

RetypedColumn is a column that goes out as SET DATA TYPE. Name is <table>.<column> as the desired schema names it, and Current as the catalog names it, before any rename in the plan.

type RoutineDiffResult

type RoutineDiffResult struct {
	Stmts               []string
	DropStmts           []string
	DisallowedDropStmts []string
	// Recreated lists the current routines that Stmts drops and creates again.
	Recreated []*model.Routine
}

func DiffRoutines

func DiffRoutines(current, desired *orderedmap.Map[string, *model.Routine], dc DropChecker) (*RoutineDiffResult, error)

DiffRoutines compares functions and procedures. Both maps are keyed by FQRN, which carries the identity argument types, so an overload set appears as several independent objects and a change to an argument type reads as a drop plus a create rather than a modification.

type SequenceDiffResult

type SequenceDiffResult struct {
	Stmts               []string
	DropStmts           []string
	DisallowedDropStmts []string
}

func DiffSequences

func DiffSequences(current, desired *orderedmap.Map[string, *model.Sequence], dc DropChecker) (*SequenceDiffResult, error)

type TableDiffResult

type TableDiffResult struct {
	FKDropStmts []string // FK drops (should run first)
	// PersistenceStmts holds the logged <-> unlogged transitions, already in an
	// order PostgreSQL accepts. They are kept out of Stmts because the caller
	// sorts that by object dependency, which is the right order for one
	// direction and the wrong one for the other.
	PersistenceStmts []string
	Stmts            []string // CREATE/ALTER TABLE, columns, constraints, indexes, comments
	FKAddStmts       []string // FK adds and renames (should run last)
	// PolicyStmts holds a new table's policies. They run after every table and
	// view, since a policy can read any of them. An existing table's policies
	// stay in Stmts, next to its RLS change, so a live table is never left
	// without them or without its RLS.
	PolicyStmts []string
	// PartitionedIndexStmts holds the CREATE INDEX and COMMENT ON INDEX for
	// indexes on partitioned tables, deepest level first. They run after the
	// tables and the partitions' own indexes, so each index attaches the
	// partitions' matching indexes instead of creating copies.
	PartitionedIndexStmts []string
	// RetypedColumns lists the columns of existing tables that go out as SET
	// DATA TYPE.
	RetypedColumns      []RetypedColumn
	DropStmts           []string // DROP TABLE (separate from Stmts for ordering)
	DisallowedDropStmts []string // DROP TABLE / DROP COLUMN / DROP CONSTRAINT (incl. FK) / DROP INDEX suppressed by DropChecker, with "-- skipped: " prefix
	HasConcurrently     bool     // true if any index operation uses CONCURRENTLY
}

TableDiffResult separates FK operations from other statements to allow correct ordering: FK drops first, then schema changes, then FK adds last.

func DiffTables

func DiffTables(current, desired *orderedmap.Map[string, *model.Table], dc DropChecker) (*TableDiffResult, error)

type ViewDiffResult

type ViewDiffResult struct {
	DropStmts           []string // DROP VIEW / DROP MATERIALIZED VIEW (should run before table changes)
	CreateStmts         []string // ALTER VIEW RENAME, CREATE OR REPLACE VIEW, CREATE MATERIALIZED VIEW, indexes, comments (should run after table changes)
	DisallowedDropStmts []string // DROP VIEW / DROP MATERIALIZED VIEW / DROP INDEX (on matview) suppressed by DropChecker, with "-- skipped: " prefix
	HasConcurrently     bool     // true if any index operation uses CONCURRENTLY
	// DroppedViews names every view and materialized view DropStmts drops,
	// including the ones dropped to be created again. A suppressed drop is
	// left out, since nothing runs. PostgreSQL refuses to drop a relation
	// another object reads, so the caller checks these against the catalog;
	// see checkViewDependents.
	DroppedViews []string
}

ViewDiffResult separates view DROP and CREATE/MODIFY statements. Drops should run before table changes, creates after.

func DiffViews

func DiffViews(current, desired *orderedmap.Map[string, *model.View], dc DropChecker) (*ViewDiffResult, error)