schema

type ColumnDiff struct {
	Type        ColumnDiffType // Type of column operation
	ColumnName  string         // Name of the column
	Current     *ColumnInfo    // Current column definition (nil for ADD)
	Target      *ColumnInfo    // Target column definition (nil for DROP)
	Description string         // Human-readable description
}

type ColumnDiffType string

type ColumnInfo struct {
	Name        string              // Column name
	DataType    *parser.DataType    // Data type AST
	DefaultType string              // Default type: DEFAULT, MATERIALIZED, EPHEMERAL, ALIAS
	Default     *parser.Expression  // Default expression AST
	Codec       *parser.CodecClause // Codec AST
	TTL         *parser.TTLClause   // TTL AST
	Comment     string              // Column comment
}

type DatabaseDiff struct {
	DiffBase               // Embeds Type, Name, NewName, Description, UpSQL, DownSQL
	Current  *DatabaseInfo // Current state (nil if database doesn't exist)
	Target   *DatabaseInfo // Target state (nil if database should be dropped)
}

type DatabaseDiffType string

type DatabaseInfo struct {
	Name    string // Database name
	Engine  string // Engine type (e.g., "Atomic", "MySQL", "Memory")
	Comment string // Database comment (without quotes)
	Cluster string // Cluster name if specified (empty if not clustered)
}

type DictionaryDiff struct {
	DiffBase                 // Embeds Type, Name, NewName, Description, UpSQL, DownSQL
	Current  *DictionaryInfo // Current state (nil if dictionary doesn't exist)
	Target   *DictionaryInfo // Target state (nil if dictionary should be dropped)
}

type DictionaryDiffType string

type DictionaryInfo struct {
	Name      string                       // Dictionary name
	Database  string                       // Database name (empty for default database)
	Cluster   string                       // Cluster name if specified (empty if not clustered)
	Comment   string                       // Dictionary comment (without quotes)
	Statement *parser.CreateDictionaryStmt // Full parsed CREATE DICTIONARY statement for deep comparison
}

type DiffBase struct {
	// Type is the operation type (CREATE, ALTER, DROP, RENAME, REPLACE, etc.)
	Type string

	// Name is the name of the object being modified
	Name string

	// NewName is the new name for rename operations (empty otherwise)
	NewName string

	// Description is a human-readable description of the change
	Description string

	// UpSQL is the SQL to apply the change (forward migration)
	UpSQL string

	// DownSQL is the SQL to rollback the change (reverse migration)
	DownSQL string
}

type FunctionDiff struct {
	DiffBase               // Embeds Type, Name, NewName, Description, UpSQL, DownSQL
	Current  *FunctionInfo // Current state (nil if function doesn't exist)
	Target   *FunctionInfo // Target state (nil if function should be dropped)
}

type FunctionDiffType string

type FunctionInfo struct {
	Name       string             // Function name
	Parameters []string           // Function parameter names
	Expression *parser.Expression // Function expression/body AST
	Cluster    string             // Cluster name if specified (empty if not clustered)
}

type GrantInfo struct {
	Grantee    string   // Role or user receiving the grant
	Privileges []string // List of privileges or roles granted
	OnTarget   string   // Target object (database.table or *.*)
	WithGrant  bool     // WITH GRANT OPTION
	WithAdmin  bool     // WITH ADMIN OPTION
	Cluster    string   // Cluster name if specified
}

type RenamePair struct {
	OldName string
	NewName string
}

type RoleDiff struct {
	DiffBase           // Embeds Type, Name, NewName, Description, UpSQL, DownSQL
	Current  *RoleInfo // Current state (nil if role doesn't exist)
	Target   *RoleInfo // Target state (nil if role should be dropped)
}

type RoleDiffType string

type RoleInfo struct {
	Name     string            // Role name
	Settings map[string]string // Role settings (key-value pairs)
	Cluster  string            // Cluster name if specified (empty if not clustered)
}

type SchemaObject interface {
	// GetName returns the fully-qualified name of the schema object.
	// For objects with database prefixes (e.g., tables), this returns "db.name".
	// For global objects (e.g., databases), this returns just the name.
	GetName() string

	// GetCluster returns the cluster name if the object is clustered,
	// or an empty string if not clustered.
	GetCluster() string

	// PropertiesMatch returns true if this object has the same properties
	// as the other object, excluding the name. This is used for rename detection:
	// if two objects have different names but matching properties, it's a rename.
	//
	// Callers should pass the same concrete type as the receiver for the other parameter,
	// but implementations must still perform type checking via type assertion.
	PropertiesMatch(other SchemaObject) bool
}

type TableDiff struct {
	DiffBase                   // Embeds Type, Name, NewName, Description, UpSQL, DownSQL
	Current       *TableInfo   // Current state (nil if table doesn't exist)
	Target        *TableInfo   // Target state (nil if table should be dropped)
	ColumnChanges []ColumnDiff // For ALTER operations - specific column changes
}

type TableDiffType string

type TableInfo struct {
	Name          string              // Table name (without database prefix)
	Database      string              // Database name (empty if not specified)
	Engine        *parser.TableEngine // Engine AST
	Cluster       string              // Cluster name for distributed tables
	Comment       string              // Table comment
	OrderBy       *parser.Expression  // ORDER BY expression AST
	PartitionBy   *parser.Expression  // PARTITION BY expression AST
	PrimaryKey    *parser.Expression  // PRIMARY KEY expression AST
	SampleBy      *parser.Expression  // SAMPLE BY expression AST
	TTL           *parser.Expression  // Table-level TTL expression AST
	Settings      map[string]string   // Table settings
	Columns       []ColumnInfo        // Column definitions
	OrReplace     bool                // Whether CREATE OR REPLACE was used
	IfNotExists   bool                // Whether IF NOT EXISTS was used
	AsSourceTable *string             // If this table uses AS, the source table name (qualified)
	AsDependents  map[string]bool     // Tables that use AS to reference this table
}

type ViewDiff struct {
	DiffBase                 // Embeds Type, Name, NewName, Description, UpSQL, DownSQL
	Current        *ViewInfo // Current state (nil if view doesn't exist)
	Target         *ViewInfo // Target state (nil if view should be dropped)
	IsMaterialized bool      // True if this is a materialized view
}

type ViewDiffType string

type ViewInfo struct {
	Name           string                 // View name
	Database       string                 // Database name (empty for default database)
	Cluster        string                 // Cluster name if specified (empty if not clustered)
	IsMaterialized bool                   // True if this is a materialized view
	OrReplace      bool                   // True if created with OR REPLACE
	Query          string                 // Query string for validation compatibility
	Statement      *parser.CreateViewStmt // Full parsed CREATE VIEW statement for deep comparison
}