parser

type AliasedExpression struct {
	BaseNode
	Expression Expression
	Alias      string
}

type AlterAction struct {
	BaseNode
	ActionType string            // ADD, DROP, MODIFY, CHANGE, RENAME
	Column     *ColumnDefinition // For ADD/MODIFY
	ColumnName string            // For DROP/CHANGE
	NewColumn  *ColumnDefinition // For CHANGE
	Constraint *TableConstraint  // For ADD constraint
}

type AlterTableStatement struct {
	BaseNode
	Table  TableReference
	Action *AlterAction
}

type Assignment struct {
	BaseNode
	Column string
	Value  Expression
}

type AssignmentStatement struct {
	BaseNode
	Variable string
	Value    Expression
}

type BaseNode struct{}

type BeginTransactionStatement struct {
	BaseNode
	UseStart bool // true if START TRANSACTION, false if BEGIN
}

type BinaryExpression struct {
	BaseNode
	Left     Expression
	Operator string
	Right    Expression
}

type CaseExpression struct {
	BaseNode
	Input       Expression // Optional input for simple CASE
	WhenClauses []*WhenClause
	ElseResult  Expression // Optional ELSE clause
}

type CaseStatement struct {
	BaseNode
	Expression Expression   // Optional: CASE expr WHEN...
	WhenList   []*WhenBlock // WHEN conditions
	ElseBlock  []Statement  // ELSE block
}

type CatchBlock struct {
	BaseNode
	Body []Statement // Statements in CATCH block
}

type CloseStatement struct {
	BaseNode
	CursorName string
}

type ColumnDefinition struct {
	BaseNode
	Name          string
	DataType      string
	Length        int // For VARCHAR(255), etc.
	Precision     int // For DECIMAL(10,2)
	Scale         int // For DECIMAL(10,2)
	NotNull       bool
	PrimaryKey    bool
	Unique        bool
	AutoIncrement bool
	Default       Expression
	References    *ForeignKeyReference // For inline FOREIGN KEY
}

type ColumnReference struct {
	BaseNode
	Table  string
	Column string
}

type CommitStatement struct {
	BaseNode
	Work bool // true if COMMIT WORK
}

type CommonTableExpression struct {
	BaseNode
	Name    string
	Columns []string  // Optional column names
	Query   Statement // Can be SelectStatement or SetOperation (for recursive CTEs with UNION)
}

type ContinueStatement struct {
	BaseNode
	Label     string     // Loop label
	Condition Expression // WHEN condition (PostgreSQL)
}

type CreateFunctionStatement struct {
	BaseNode
	Name            string
	Parameters      []*ProcedureParameter
	ReturnType      *DataTypeDefinition
	Body            *ProcedureBody
	Language        string            // SQL, PLPGSQL, etc.
	Deterministic   bool              // DETERMINISTIC
	SecurityDefiner bool              // SECURITY DEFINER vs INVOKER
	Options         map[string]string // Dialect-specific options
	OrReplace       bool              // CREATE OR REPLACE
	IfNotExists     bool              // IF NOT EXISTS
}

type CreateIndexStatement struct {
	BaseNode
	IndexName   string
	Table       TableReference
	Columns     []string
	Unique      bool
	IfNotExists bool
}

type CreateProcedureStatement struct {
	BaseNode
	Name            string
	Parameters      []*ProcedureParameter
	Body            *ProcedureBody
	Language        string            // SQL, PLPGSQL, etc.
	SecurityDefiner bool              // SECURITY DEFINER vs INVOKER
	Options         map[string]string // Dialect-specific options
	OrReplace       bool              // CREATE OR REPLACE
	IfNotExists     bool              // IF NOT EXISTS
}

type CreateTableStatement struct {
	BaseNode
	Table       TableReference
	Columns     []*ColumnDefinition
	Constraints []*TableConstraint
	IfNotExists bool
}

type CreateTriggerStatement struct {
	BaseNode
	TriggerName   string            // Trigger name
	Timing        string            // BEFORE, AFTER, INSTEAD OF
	Events        []string          // INSERT, UPDATE, DELETE
	TableName     TableReference    // Table the trigger is on
	ForEachRow    bool              // FOR EACH ROW (vs FOR EACH STATEMENT)
	WhenCondition Expression        // Optional WHEN condition
	Body          *ProcedureBody    // Trigger body (BEGIN...END or single statement)
	OrReplace     bool              // OR REPLACE (PostgreSQL)
	IfNotExists   bool              // IF NOT EXISTS (MySQL)
	Options       map[string]string // Dialect-specific options
}

type CreateViewStatement struct {
	BaseNode
	OrReplace    bool              // CREATE OR REPLACE VIEW
	Materialized bool              // MATERIALIZED VIEW (PostgreSQL)
	IfNotExists  bool              // IF NOT EXISTS
	ViewName     TableReference    // View name (can have schema)
	Columns      []string          // Optional column list
	SelectStmt   *SelectStatement  // The SELECT query
	WithCheck    bool              // WITH CHECK OPTION
	Options      map[string]string // Dialect-specific options (e.g., SECURITY DEFINER)
}

type CursorDecl struct {
	BaseNode
	Name  string
	Query *SelectStatement
}

type DataTypeDefinition struct {
	BaseNode
	Name      string // VARCHAR, INT, DECIMAL, etc.
	Length    int    // For VARCHAR(255), CHAR(10), etc.
	Precision int    // For DECIMAL(10,2), NUMERIC(8,3)
	Scale     int    // For DECIMAL(10,2), NUMERIC(8,3)
	IsArray   bool   // For array types (PostgreSQL)
}

type DeallocateStatement struct {
	BaseNode
	CursorName string
}

type DeleteStatement struct {
	BaseNode
	From    TableReference
	Where   Expression
	OrderBy []*OrderByClause // MySQL/SQLite support ORDER BY in DELETE
	Limit   *LimitClause     // MySQL/SQLite support LIMIT in DELETE
}

type DropStatement struct {
	BaseNode
	ObjectType string // TABLE, DATABASE, INDEX
	ObjectName string
	IfExists   bool
	Cascade    bool
}

type ElseIfBlock struct {
	BaseNode
	Condition Expression
	Block     []Statement
}

type ExceptionBlock struct {
	BaseNode
	WhenClauses []*WhenExceptionClause // WHEN exception_name THEN ...
}

type ExistsExpression struct {
	BaseNode
	Subquery Statement
	Not      bool
}

type ExitStatement struct {
	BaseNode
	Label     string     // Loop label to exit
	Condition Expression // WHEN condition (PostgreSQL)
}

type ExplainStatement struct {
	BaseNode
	Statement Statement         // The statement to explain
	Analyze   bool              // EXPLAIN ANALYZE
	Format    string            // FORMAT (JSON, XML, TEXT, etc.)
	Options   map[string]string // Dialect-specific options
}

type Expression interface {
	Node
	// contains filtered or unexported methods
}

type FetchStatement struct {
	BaseNode
	Direction  string // NEXT, PRIOR, FIRST, LAST, ABSOLUTE, RELATIVE (empty for simple FETCH)
	Count      int    // For ABSOLUTE/RELATIVE n (0 means not specified)
	CursorName string
	Variables  []string // INTO variables
}

type ForStatement struct {
	BaseNode
	Variable  string
	Start     Expression
	End       Expression
	Step      Expression // Optional
	Block     []Statement
	Label     string // Loop label
	IsReverse bool   // FOR ... IN REVERSE (PostgreSQL)
}

type ForeignKeyReference struct {
	BaseNode
	Table    string
	Columns  []string
	OnDelete string // CASCADE, SET NULL, etc.
	OnUpdate string
}

type FrameBound struct {
	BaseNode
	BoundType string     // UNBOUNDED, CURRENT, or expression
	Direction string     // PRECEDING or FOLLOWING
	Offset    Expression // For expression-based bounds
}

type FromClause struct {
	BaseNode
	Tables []TableReference
}

type FunctionCall struct {
	BaseNode
	Name      string
	Arguments []Expression
}

type HandlerDeclaration struct {
	BaseNode
	HandlerType string      // CONTINUE, EXIT, UNDO
	Condition   string      // SQLEXCEPTION, SQLWARNING, NOT FOUND, SQLSTATE, etc.
	Body        []Statement // Handler body
}

type IfStatement struct {
	BaseNode
	Condition  Expression
	ThenBlock  []Statement
	ElseIfList []*ElseIfBlock
	ElseBlock  []Statement
}

type InExpression struct {
	BaseNode
	Expression Expression
	Values     []Expression
	Not        bool
}

type InsertStatement struct {
	BaseNode
	Table   TableReference
	Columns []string         // Optional column list
	Values  [][]Expression   // For INSERT ... VALUES
	Select  *SelectStatement // For INSERT ... SELECT
}

type JoinClause struct {
	BaseNode
	JoinType  string // INNER, LEFT, RIGHT, FULL
	Table     TableReference
	Condition Expression
}

type LimitClause struct {
	BaseNode
	Count  int
	Offset int
}

type Literal struct {
	BaseNode
	Value interface{}
}

type LoopStatement struct {
	BaseNode
	Block []Statement
	Label string // Loop label
}

type MergeAction struct {
	BaseNode
	ActionType string       // UPDATE, INSERT, DELETE
	Columns    []string     // For UPDATE/INSERT
	Values     []Expression // For UPDATE/INSERT
}

type MergeStatement struct {
	BaseNode
	TargetTable      TableReference
	SourceTable      interface{}        // Can be TableReference or SelectStatement
	SourceAlias      string             // Alias for source
	OnCondition      Expression         // MERGE condition
	WhenMatched      []*MergeWhenClause // WHEN MATCHED clauses (can have multiple)
	WhenNotMatched   []*MergeWhenClause // WHEN NOT MATCHED clauses
	WhenNotMatchedBy []*MergeWhenClause // WHEN NOT MATCHED BY SOURCE (SQL Server)
}

type MergeWhenClause struct {
	BaseNode
	Matched   bool         // true for WHEN MATCHED, false for WHEN NOT MATCHED
	BySource  bool         // true for WHEN NOT MATCHED BY SOURCE (SQL Server)
	Condition Expression   // Optional AND condition
	Action    *MergeAction // The action to perform
}

type Node interface {
	String() string
	Type() string
}

type OpenCursorStatement struct {
	BaseNode
	CursorName string
}

type OrderByClause struct {
	BaseNode
	Expression Expression
	Direction  string // ASC, DESC
}

type OverClause struct {
	BaseNode
	PartitionBy []Expression
	OrderBy     []*OrderByClause
	Frame       *WindowFrame
}

type ParseError struct {
	Message string
	Line    int
	Column  int
	Token   string
}

type Parser struct {
	// contains filtered or unexported fields
}

type ProcedureBody struct {
	BaseNode
	Statements     []Statement     // List of statements in the body
	Variables      []*VariableDecl // DECLARE variables
	Cursors        []*CursorDecl   // DECLARE cursors
	ExceptionBlock *ExceptionBlock // EXCEPTION block (PostgreSQL/Oracle)
}

type ProcedureParameter struct {
	BaseNode
	Name       string
	Mode       string              // IN, OUT, INOUT
	DataType   *DataTypeDefinition // Parameter type
	Default    Expression          // Default value
	IsVariadic bool                // VARIADIC (PostgreSQL)
}

type RaiseStatement struct {
	BaseNode
	Level   string     // EXCEPTION, NOTICE, WARNING, INFO, LOG, DEBUG
	Message Expression // Error message
	Code    string     // Optional SQLSTATE code
}

type ReleaseSavepointStatement struct {
	BaseNode
	Name string
}

type RepeatStatement struct {
	BaseNode
	Body      []Statement // Loop body
	Condition Expression  // UNTIL condition
	Label     string      // Optional loop label
}

type ReturnStatement struct {
	BaseNode
	Value Expression
}

type RollbackStatement struct {
	BaseNode
	Work        bool   // true if ROLLBACK WORK
	ToSavepoint string // Optional: ROLLBACK TO SAVEPOINT name
}

type SavepointStatement struct {
	BaseNode
	Name string
}

type SelectStatement struct {
	BaseNode
	Distinct bool
	Top      *TopClause
	Columns  []Expression
	From     *FromClause
	Joins    []*JoinClause
	Where    Expression
	GroupBy  []Expression
	Having   Expression
	OrderBy  []*OrderByClause
	Limit    *LimitClause
}

type SetOperation struct {
	BaseNode
	Left     Statement
	Operator string // UNION, INTERSECT, EXCEPT
	All      bool   // UNION ALL, etc.
	Right    Statement
}

type SignalStatement struct {
	BaseNode
	SqlState   string            // SQLSTATE value
	Properties map[string]string // MESSAGE_TEXT, MYSQL_ERRNO, etc.
}

type StarExpression struct {
	BaseNode
	Table string // optional table qualifier
}

type Statement interface {
	Node
	// contains filtered or unexported methods
}

type SubqueryExpression struct {
	BaseNode
	Query *SelectStatement
}

type SyntaxError struct {
	Expected string
	Found    string
	Line     int
	Column   int
}

type TableConstraint struct {
	BaseNode
	Name           string // Optional constraint name
	ConstraintType string // PRIMARY_KEY, FOREIGN_KEY, UNIQUE, CHECK
	Columns        []string
	References     *ForeignKeyReference // For FOREIGN KEY
	Check          Expression           // For CHECK constraint
}

type TableReference struct {
	BaseNode
	Schema   string
	Name     string
	Alias    string
	Subquery *SelectStatement // For derived tables: (SELECT ...) AS alias
}

type ThrowStatement struct {
	BaseNode
	ErrorNumber int        // Error number
	Message     Expression // Error message
	State       int        // Error state
}

type TopClause struct {
	BaseNode
	Count   int
	Percent bool
}

type TryStatement struct {
	BaseNode
	TryBlock   []Statement // Statements in TRY block
	CatchBlock *CatchBlock // CATCH block
}

type UnaryExpression struct {
	BaseNode
	Operator string
	Operand  Expression
}

type UpdateStatement struct {
	BaseNode
	Table   TableReference
	Set     []*Assignment
	Where   Expression
	OrderBy []*OrderByClause // MySQL/SQLite support ORDER BY in UPDATE
	Limit   *LimitClause     // MySQL/SQLite support LIMIT in UPDATE
}

type VariableDecl struct {
	BaseNode
	Name     string
	DataType *DataTypeDefinition
	Default  Expression
}

type WhenBlock struct {
	BaseNode
	Condition Expression
	Block     []Statement
}

type WhenClause struct {
	BaseNode
	Condition Expression
	Result    Expression
}

type WhenExceptionClause struct {
	BaseNode
	ExceptionName string      // Exception type (SQLEXCEPTION, division_by_zero, OTHERS, etc.)
	Body          []Statement // Statements to execute
}

type WhileStatement struct {
	BaseNode
	Condition Expression
	Block     []Statement
	Label     string // Loop label
}

type WindowFrame struct {
	BaseNode
	FrameType string // ROWS or RANGE
	Start     *FrameBound
	End       *FrameBound
}

type WindowFunction struct {
	BaseNode
	Function   *FunctionCall // The window function (ROW_NUMBER, RANK, etc.)
	OverClause *OverClause
}

type WithStatement struct {
	BaseNode
	Recursive bool
	CTEs      []*CommonTableExpression
	Query     Statement // Main query (usually SelectStatement)
}