schema

type CheckConstraint struct {
	Name string
	// KeyColumns are the columns that the constraint applies to
	KeyColumns         []string
	Expression         string
	IsValid            bool
	IsInheritable      bool
	DependsOnFunctions []SchemaQualifiedName
}

type Column struct {
	Name      string
	Type      string
	Collation SchemaQualifiedName
	// If the column has a default value, this will be a SQL string representing that value.
	// Examples:
	//   ”::text
	//   CURRENT_TIMESTAMP
	// If empty, indicates that there is no default value.
	Default    string
	IsNullable bool
	// Size is the number of bytes required to store the value.
	// It is used for data-packing purposes
	Size     int
	Identity *ColumnIdentity
}

type ColumnIdentity struct {
	Type       ColumnIdentityType
	MinValue   int64
	MaxValue   int64
	StartValue int64
	Increment  int64
	CacheSize  int64
	Cycle      bool
}

type ColumnIdentityType string

type Enum struct {
	SchemaQualifiedName
	Labels []string
}

type Extension struct {
	SchemaQualifiedName
	Version string
}

type ForeignKeyConstraint struct {
	EscapedName   string
	OwningTable   SchemaQualifiedName
	ForeignTable  SchemaQualifiedName
	ConstraintDef string
	IsValid       bool
}

type Function struct {
	SchemaQualifiedName
	// FunctionDef is the statement required to completely (re)create
	// the function, as returned by `pg_get_functiondef`. It is a CREATE OR REPLACE
	// statement
	FunctionDef string
	// Language is the language of the function. This is relevant in determining if we
	// can track the dependencies of the function (or not)
	Language           string
	DependsOnFunctions []SchemaQualifiedName
}

type GetIndexDefStatement string

type GetSchemaOpt func(*getSchemaOptions)

type GetTriggerDefStatement string

type Index struct {
	// Name is the name of the index. We don't store the schema because the schema is just the schema of the table.
	// Referencing the name is an anti-pattern because it is not qualified. Use should use GetSchemaQualifiedName instead.
	Name        string
	OwningTable SchemaQualifiedName
	Columns     []string
	IsInvalid   bool
	IsUnique    bool

	Constraint *IndexConstraint

	// GetIndexDefStmt is the output of pg_getindexdef
	GetIndexDefStmt GetIndexDefStatement

	ParentIdx *SchemaQualifiedName
}

type IndexConstraint struct {
	Type                  IndexConstraintType
	EscapedConstraintName string
	ConstraintDef         string
	IsLocal               bool
}

type IndexConstraintType string

type NamedSchema struct {
	Name string
}

type Object interface {
	// GetName is used to identify the old and new versions of a schema object between the old and new schemas
	// If the name is not present in the old schema objects list, then it is added
	// If the name is not present in the new schemas objects list, then it is removed
	// Otherwise, it has persisted across two schemas and is possibly altered
	//
	// GetName should be qualified with the schema name.
	GetName() string
}

type ObjectType string

type Policy struct {
	EscapedName     string
	IsPermissive    bool
	AppliesTo       []string
	Cmd             PolicyCmd
	CheckExpression string
	UsingExpression string
	// Columns are the columns that the policy applies to.
	Columns []string
}

type PolicyCmd string

type Procedure struct {
	SchemaQualifiedName
	// Def is the statement required to completely (re)create
	// the procedure, as returned by `pg_get_functiondef`. It is a CREATE OR REPLACE
	// statement.
	Def string
}

type ReplicaIdentity string

type Schema struct {
	NamedSchemas          []NamedSchema
	Extensions            []Extension
	Enums                 []Enum
	Tables                []Table
	Indexes               []Index
	ForeignKeyConstraints []ForeignKeyConstraint
	Sequences             []Sequence
	Functions             []Function
	Procedures            []Procedure
	Triggers              []Trigger
}

type SchemaQualifiedName struct {
	SchemaName string
	// EscapedName is the name of the object. It should already be escaped
	// We take an escaped name because there are weird exceptions, like functions, where we can't just
	// surround the name in quotes
	EscapedName string
}

type Sequence struct {
	SchemaQualifiedName
	Owner      *SequenceOwner
	Type       string
	StartValue int64
	Increment  int64
	MaxValue   int64
	MinValue   int64
	CacheSize  int64
	Cycle      bool
}

type SequenceOwner struct {
	TableName  SchemaQualifiedName
	ColumnName string
}

type Table struct {
	SchemaQualifiedName
	Columns          []Column
	CheckConstraints []CheckConstraint
	Policies         []Policy
	ReplicaIdentity  ReplicaIdentity
	RLSEnabled       bool
	RLSForced        bool

	// PartitionKeyDef is the output of Pg function pg_get_partkeydef:
	// PARTITION BY $PartitionKeyDef
	// If empty, then the table is not partitioned
	PartitionKeyDef string

	ParentTable *SchemaQualifiedName
	ForValues   string
}

type Trigger struct {
	EscapedName string
	OwningTable SchemaQualifiedName
	Function    SchemaQualifiedName
	// GetTriggerDefStmt is the statement required to completely (re)create the trigger, as returned
	// by pg_get_triggerdef
	GetTriggerDefStmt GetTriggerDefStatement
}