schema

type CheckConstraintDiff struct {
	Action             MetadataDiffAction
	OldCheckConstraint *storepb.CheckConstraintMetadata
	NewCheckConstraint *storepb.CheckConstraintMetadata
	OldASTNode         any // AST node for old check constraint
	NewASTNode         any // AST node for new check constraint
}

type ColumnDiff struct {
	Action    MetadataDiffAction
	OldColumn *storepb.ColumnMetadata
	NewColumn *storepb.ColumnMetadata

	// AST nodes for DDL analysis and generation
	OldASTNode parser.IColumnDefContext // Previous column definition AST node
	NewASTNode parser.IColumnDefContext // Current column definition AST node
}

type CommentDiff struct {
	Action     MetadataDiffAction // CREATE or ALTER (no DROP since object deletion removes comments automatically)
	ObjectType CommentObjectType
	SchemaName string
	TableName  string // used for TRIGGER comments (COMMENT ON TRIGGER trigger_name ON table_name)
	ObjectName string // table/view/function/sequence/index name
	ColumnName string // only used for COLUMN comments
	IndexName  string // only used for table-level INDEX comments
	OldComment string
	NewComment string
	OldASTNode antlr.ParserRuleContext
	NewASTNode antlr.ParserRuleContext
}

type CommentObjectType string

type DefaultFunctionComparer struct{}

type DefaultIndexComparer struct{}

type DefaultViewComparer struct{}

type EnumTypeDiff struct {
	Action       MetadataDiffAction
	SchemaName   string
	EnumTypeName string
	OldEnumType  *storepb.EnumTypeMetadata
	NewEnumType  *storepb.EnumTypeMetadata
	OldASTNode   any // For SDL/AST-only mode
	NewASTNode   any // For SDL/AST-only mode
}

type EventDiff struct {
	Action    MetadataDiffAction
	EventName string
	OldEvent  *storepb.EventMetadata
	NewEvent  *storepb.EventMetadata
}

type EventTriggerDiff struct {
	Action           MetadataDiffAction
	EventTriggerName string
	OldEventTrigger  *storepb.EventTriggerMetadata
	NewEventTrigger  *storepb.EventTriggerMetadata
	OldASTNode       any // For SDL/AST-only mode
	NewASTNode       any // For SDL/AST-only mode
}

type ExcludeConstraintDiff struct {
	Action               MetadataDiffAction
	OldExcludeConstraint *storepb.ExcludeConstraintMetadata
	NewExcludeConstraint *storepb.ExcludeConstraintMetadata
	OldASTNode           any // AST node for old EXCLUDE constraint
	NewASTNode           any // AST node for new EXCLUDE constraint
}

type ExtensionDiff struct {
	Action        MetadataDiffAction
	ExtensionName string
	OldExtension  *storepb.ExtensionMetadata
	NewExtension  *storepb.ExtensionMetadata
	OldASTNode    any // For SDL/AST-only mode
	NewASTNode    any // For SDL/AST-only mode
}

type File struct {
	// Name is the file path or name (e.g., "schemas/public/tables/users.sql")
	Name string
	// Content is the file content
	Content string
}

type ForeignKeyDiff struct {
	Action        MetadataDiffAction
	OldForeignKey *storepb.ForeignKeyMetadata
	NewForeignKey *storepb.ForeignKeyMetadata
	OldASTNode    any // AST node for old foreign key constraint
	NewASTNode    any // AST node for new foreign key constraint
}

type FunctionChange struct {
	Type                FunctionChangeType
	Description         string
	RequiresRecreation  bool
	CanUseAlterFunction bool
}

type FunctionChangeType string

type FunctionComparer interface {
	// Equal compares two functions and returns whether they are equal.
	Equal(oldFunc, newFunc *storepb.FunctionMetadata) bool

	// CompareDetailed performs detailed comparison and returns migration strategy information.
	// Returns nil if functions are equal.
	CompareDetailed(oldFunc, newFunc *storepb.FunctionMetadata) (*FunctionComparisonResult, error)
}

type FunctionComparisonResult struct {
	SignatureChanged    bool
	BodyChanged         bool
	AttributesChanged   bool
	ChangedAttributes   []string
	RequiresRecreation  bool
	CanUseAlterFunction bool
}

type FunctionDiff struct {
	Action       MetadataDiffAction
	SchemaName   string
	FunctionName string
	OldFunction  *storepb.FunctionMetadata
	NewFunction  *storepb.FunctionMetadata
	OldASTNode   any // AST node for old function
	NewASTNode   any // AST node for new function

	// Detailed change information for advanced engines
	SignatureChanged    bool
	BodyChanged         bool
	AttributesChanged   bool
	ChangedAttributes   []string
	CanUseAlterFunction bool
}

type GetDefinitionContext struct {
	SkipBackupSchema bool
	PrintHeader      bool
	SDLFormat        bool
	// MultiFileFormat indicates whether to generate multi-file SDL output.
	// When true, the result should be organized as multiple files.
	MultiFileFormat bool
}

type IndexComparer interface {
	// CompareIndexWhereConditions compares WHERE conditions from two index definitions
	CompareIndexWhereConditions(def1, def2 string) bool

	// ExtractWhereClauseFromIndexDef extracts the WHERE clause from an index definition
	ExtractWhereClauseFromIndexDef(definition string) string
}

type IndexDiff struct {
	Action     MetadataDiffAction
	OldIndex   *storepb.IndexMetadata
	NewIndex   *storepb.IndexMetadata
	OldASTNode any // AST node for old index constraint
	NewASTNode any // AST node for new index constraint
}

type MaterializedViewChange struct {
	Type        MaterializedViewChangeType
	Description string
	// RequiresRecreation indicates if the change requires dropping and recreating the materialized view.
	RequiresRecreation bool
}

type MaterializedViewChangeType int

type MaterializedViewDiff struct {
	Action               MetadataDiffAction
	SchemaName           string
	MaterializedViewName string
	OldMaterializedView  *storepb.MaterializedViewMetadata
	NewMaterializedView  *storepb.MaterializedViewMetadata
	OldASTNode           any          // AST node for old materialized view
	NewASTNode           any          // AST node for new materialized view
	IndexChanges         []*IndexDiff // Index changes on materialized view
}

type MetadataDiff struct {
	// Database level changes
	DatabaseName string

	// Schema changes
	SchemaChanges []*SchemaDiff

	// Table changes
	TableChanges []*TableDiff

	// View changes
	ViewChanges []*ViewDiff

	// MaterializedView changes
	MaterializedViewChanges []*MaterializedViewDiff

	// Function changes
	FunctionChanges []*FunctionDiff

	// Procedure changes
	ProcedureChanges []*ProcedureDiff

	// Sequence changes
	SequenceChanges []*SequenceDiff

	// Enum type changes
	EnumTypeChanges []*EnumTypeDiff

	// Extension changes
	ExtensionChanges []*ExtensionDiff

	// Event trigger changes
	EventTriggerChanges []*EventTriggerDiff

	// Event changes
	EventChanges []*EventDiff

	// Comment changes
	CommentChanges []*CommentDiff
}

type MetadataDiffAction string

type MultiFileSchemaResult struct {
	// Files is the list of schema files organized by type
	Files []File
}

type PartitionDiff struct {
	Action       MetadataDiffAction
	OldPartition *storepb.TablePartitionMetadata
	NewPartition *storepb.TablePartitionMetadata
}

type PrimaryKeyDiff struct {
	Action        MetadataDiffAction
	OldPrimaryKey *storepb.IndexMetadata
	NewPrimaryKey *storepb.IndexMetadata
	OldASTNode    any // AST node for old primary key constraint
	NewASTNode    any // AST node for new primary key constraint
}

type ProcedureDiff struct {
	Action        MetadataDiffAction
	SchemaName    string
	ProcedureName string
	OldProcedure  *storepb.ProcedureMetadata
	NewProcedure  *storepb.ProcedureMetadata
	OldASTNode    any // AST node for old procedure
	NewASTNode    any // AST node for new procedure
}

type SDLChunk struct {
	Identifier        string
	ASTNode           antlr.ParserRuleContext   // The parsed AST node for this chunk (e.g., CREATE SEQUENCE)
	AlterStatements   []antlr.ParserRuleContext // Additional ALTER statements for this object (e.g., ALTER SEQUENCE OWNED BY)
	CommentStatements []antlr.ParserRuleContext // COMMENT ON statements for this object
}

type SDLChunks struct {
	Tables            map[string]*SDLChunk // key: table name/identifier
	Views             map[string]*SDLChunk // key: view name/identifier
	MaterializedViews map[string]*SDLChunk // key: materialized view name/identifier
	Functions         map[string]*SDLChunk // key: function name/identifier
	Triggers          map[string]*SDLChunk // key: schema.table.trigger_name (table-scoped)
	Indexes           map[string]*SDLChunk // key: index name/identifier
	Sequences         map[string]*SDLChunk // key: sequence name/identifier
	Schemas           map[string]*SDLChunk // key: schema name/identifier
	EnumTypes         map[string]*SDLChunk // key: enum type name/identifier
	Extensions        map[string]*SDLChunk // key: extension name/identifier
	EventTriggers     map[string]*SDLChunk // key: event trigger name (database-level, no schema)

	// Column comments: map[schemaName.tableName][columnName] -> COMMENT ON COLUMN AST node
	ColumnComments map[string]map[string]antlr.ParserRuleContext

	// Index comments for table-level indexes: map[schemaName.tableName][indexName] -> COMMENT ON INDEX AST node
	IndexComments map[string]map[string]antlr.ParserRuleContext
}

type SDLDiff struct {
	CurrentChunks  *SDLChunks
	PreviousChunks *SDLChunks
	Added          []*SDLChunk
	Removed        []*SDLChunk
	Modified       []*SDLChunk
}

type SchemaDiff struct {
	Action     MetadataDiffAction
	SchemaName string
	OldSchema  *storepb.SchemaMetadata
	NewSchema  *storepb.SchemaMetadata
}

type SequenceDiff struct {
	Action       MetadataDiffAction
	SchemaName   string
	SequenceName string
	OldSequence  *storepb.SequenceMetadata
	NewSequence  *storepb.SequenceMetadata
	OldASTNode   any // AST node for old sequence
	NewASTNode   any // AST node for new sequence
}

type TableDiff struct {
	Action     MetadataDiffAction
	SchemaName string
	TableName  string
	OldTable   *storepb.TableMetadata
	NewTable   *storepb.TableMetadata

	// AST nodes for DDL analysis and generation
	OldASTNode *parser.CreatestmtContext // Previous user CREATE TABLE AST node
	NewASTNode *parser.CreatestmtContext // Current user CREATE TABLE AST node

	// Column changes
	ColumnChanges []*ColumnDiff

	// Index changes (excluding PK and UK which are handled separately)
	IndexChanges []*IndexDiff

	// Primary key changes
	PrimaryKeyChanges []*PrimaryKeyDiff

	// Unique constraint changes
	UniqueConstraintChanges []*UniqueConstraintDiff

	// Foreign key changes
	ForeignKeyChanges []*ForeignKeyDiff

	// Check constraint changes
	CheckConstraintChanges []*CheckConstraintDiff

	// EXCLUDE constraint changes (PostgreSQL specific)
	ExcludeConstraintChanges []*ExcludeConstraintDiff

	// Partition changes
	PartitionChanges []*PartitionDiff

	// Trigger changes
	TriggerChanges []*TriggerDiff
}

type TriggerDiff struct {
	Action      MetadataDiffAction
	SchemaName  string // Schema name of the table that owns the trigger
	TableName   string // Table name that owns the trigger
	TriggerName string // Trigger name
	OldTrigger  *storepb.TriggerMetadata
	NewTrigger  *storepb.TriggerMetadata
	OldASTNode  any // AST node for old trigger (*parser.CreatetrigstmtContext)
	NewASTNode  any // AST node for new trigger (*parser.CreatetrigstmtContext)
}

type UniqueConstraintDiff struct {
	Action              MetadataDiffAction
	OldUniqueConstraint *storepb.IndexMetadata
	NewUniqueConstraint *storepb.IndexMetadata
	OldASTNode          any // AST node for old unique constraint
	NewASTNode          any // AST node for new unique constraint
}

type ViewChange struct {
	Type        ViewChangeType
	Description string
	// RequiresRecreation indicates if the change requires dropping and recreating the view.
	RequiresRecreation bool
}

type ViewChangeType int

type ViewComparer interface {
	// CompareView compares two views and returns the detected changes.
	CompareView(oldView, newView *storepb.ViewMetadata) ([]ViewChange, error)

	// CompareMaterializedView compares two materialized views and returns the detected changes.
	CompareMaterializedView(oldMV, newMV *storepb.MaterializedViewMetadata) ([]MaterializedViewChange, error)
}

type ViewDiff struct {
	Action     MetadataDiffAction
	SchemaName string
	ViewName   string
	OldView    *storepb.ViewMetadata
	NewView    *storepb.ViewMetadata
	OldASTNode any // AST node for old view
	NewASTNode any // AST node for new view
}