sql

type AlterAlertInfo struct {
	Name   string
	Enable bool // true = ENABLE, false = DISABLE
}

type AlterTableInfo struct {
	Table         string
	Action        string // "ADD COLUMN", "DROP COLUMN", "RENAME COLUMN"
	ColumnName    string
	NewColumnName string // for RENAME COLUMN
	ColumnType    string // for ADD COLUMN
	Nullable      bool   // for ADD COLUMN (default true)
}

type AnalyzeTableInfo struct {
	Name string
}

type AndNode struct {
	Left  Node
	Right Node
}

type AnyAllExpr struct {
	Left     Node
	Op       string // =, !=, <, <=, >, >=
	Modifier string // "ANY", "ALL", "SOME"
	Values   []Node // value list or single SubqueryNode
}

type ArrayLitNode struct {
	Elements []Node
}

type BetweenExpr struct {
	Left Node
	Not  bool
	Low  Node
	High Node
}

type BinaryOp struct {
	Left  Node
	Op    string // +, -, *, /, %, ||
	Right Node
}

type CTEDef struct {
	Name      string   // CTE name (lowercased for matching)
	SQL       string   // the CTE body SQL (the SELECT inside the parentheses)
	Columns   []string // optional column name list
	Recursive bool     // WITH RECURSIVE
}

type CaseNode struct {
	Subject Node         // nil for searched CASE
	Whens   []WhenClause // at least one
	Else    Node         // nil if no ELSE
}

type CastNode struct {
	Inner    Node
	TypeName string
}

type CmpExpr struct {
	Left  Node
	Op    string // =, !=, <, <=, >, >=
	Right Node
}

type ColRef struct {
	Table  string
	Column string
}

type ColumnDef struct {
	Name     string
	Type     string
	Nullable bool // true by default; NOT NULL sets it to false
}

type CreateAlertInfo struct {
	Name       string
	QueryText  string        // raw SELECT text, re-parsed at eval time
	Interval   time.Duration // validated >= 10s at parse time
	WebhookURL string        // "" if no webhook sink
	Headers    map[string]string
	InsertInto string // "" if no table sink; at least one sink required
}

type CreateFunctionInfo struct {
	Name    string
	Params  []string
	Body    string
	Replace bool // CREATE OR REPLACE
	Locked  bool // WITH LOCK
}

type CreateSnapshotInfo struct{}

type CreateTableInfo struct {
	Name          string
	Columns       []ColumnDef
	PartitionKeys []string
}

type CreateViewInfo struct {
	Name    string
	SQL     string // the view definition SQL
	Replace bool   // CREATE OR REPLACE VIEW
}

type DeleteInfo struct {
	Table    string // table name
	WhereSQL string // raw WHERE clause SQL (empty = delete all rows)
}

type DescribeInfo struct {
	TableName string
}

type DropAlertInfo struct {
	Name     string
	IfExists bool
}

type DropFunctionInfo struct {
	Name     string
	IfExists bool
}

type DropTableInfo struct {
	Name     string
	IfExists bool
}

type DropViewInfo struct {
	Name     string
	IfExists bool
}

type ExistsNode struct {
	Not bool
	SQL string
}

type ExplainInfo struct {
	Verbose  bool
	Analyze  bool
	InnerSQL string
}

type FrameBound struct {
	Type   FrameBoundType
	Offset Node // nil for UNBOUNDED/CURRENT ROW
}

type FrameBoundType int

type FrameMode int

type FuncCallNode struct {
	Name     string
	Args     []Node
	Distinct bool // COUNT(DISTINCT col)
	Star     bool // COUNT(*)
}

type InExpr struct {
	Left   Node
	Not    bool
	Values []Node
}

type InsertInfo struct {
	Table   string     // table name
	Columns []string   // target column names (empty = all columns)
	Values  [][]string // rows of value expressions
}

type IntervalLit struct {
	Value int
	Unit  string // "day", "month", "year", "hour", "minute", "second"
}

type IsExpr struct {
	Left  Node
	Not   bool
	Check string // "null", "true", "false"
}

type JoinInfo struct {
	Type          string // join, left join, right join, full outer join, cross join
	LeftTable     string
	RightTable    string
	RightAlias    string
	RightTableRef *TableRef // full right-side table ref (includes function info)
	Condition     string
	CondExpr      Node
	Lateral       bool // LATERAL join — right side can reference left side columns
}

type LikeExpr struct {
	Left    Node
	Not     bool
	Pattern Node
}

type Lit struct {
	Value string
	Kind  LiteralKind
}

type LiteralKind int

type LiteralPlaceholder struct {
	Name string
}

type MergeInfo struct {
	Target      string // target table name
	TargetAlias string
	Source      string // source table/subquery
	SourceAlias string
	OnCondition string            // MERGE ON condition
	WhenClauses []MergeWhenClause // WHEN MATCHED / NOT MATCHED clauses
}

type MergeWhenClause struct {
	Matched   bool   // true = WHEN MATCHED, false = WHEN NOT MATCHED
	Condition string // optional AND condition
	Action    string // "UPDATE", "DELETE", "INSERT"
	SQL       string // raw SET/VALUES clause
}

type Node interface {
	String() string
	// contains filtered or unexported methods
}

type NotNode struct {
	Inner Node
}

type OrNode struct {
	Left  Node
	Right Node
}

type OrderByItem struct {
	Column     string
	Desc       bool
	NullsFirst *bool // nil = default, true = NULLS FIRST, false = NULLS LAST
}

type OuterRef struct {
	Table  string // outer table alias (lowercased)
	Column string // column name (lowercased)
}

type ParenNode struct {
	Inner Node
}

type ParsedQuery struct {
	Type           QueryType
	TableName      string
	SQL            string
	Explain        *ExplainInfo
	Describe       *DescribeInfo
	CreateFunction *CreateFunctionInfo
	DropFunction   *DropFunctionInfo
	CreateTable    *CreateTableInfo
	DropTable      *DropTableInfo
	AnalyzeTable   *AnalyzeTableInfo
	CreateView     *CreateViewInfo
	DropView       *DropViewInfo
	AlterTable     *AlterTableInfo
	Merge          *MergeInfo
	Update         *UpdateInfo
	Delete         *DeleteInfo
	Insert         *InsertInfo
	CreateAlert    *CreateAlertInfo
	DropAlert      *DropAlertInfo
	AlterAlert     *AlterAlertInfo
	CreateSnapshot *CreateSnapshotInfo
	Windows        []WindowSpec // extracted window function specs
	CTEs           []CTEDef     // extracted CTE definitions
	SelectInfo     *SelectInfo  // parsed SELECT info (replaces AST)
}

type QueryType int

type SelectColumn struct {
	Expr        string
	Alias       string
	Star        bool
	IsAgg       bool
	AggFunc     string
	AggArg      string
	AggArgExpr  Node        // AST for aggregate argument expression
	AggDistinct bool        // COUNT(DISTINCT col)
	IsWindow    bool        // true if this is a window function
	WindowSpec  *WindowSpec // window function details
	ColumnRef   string
	TableRef    string
	ASTExpr     Node // our AST expression node
}

type SelectInfo struct {
	Tables       []TableRef
	Joins        []JoinInfo
	Columns      []SelectColumn
	Where        string
	WhereExpr    Node
	GroupBy      []string
	GroupByExprs []Node     // AST for GROUP BY expressions (parallel to GroupBy)
	GroupingSets [][]string // GROUPING SETS / CUBE / ROLLUP (nil = simple GROUP BY)
	Having       string
	HavingExpr   Node
	Distinct     bool
	Qualify      string
	QualifyExpr  Node
	OrderBy      []OrderByItem
	Limit        string
	Offset       string
	Windows      []WindowSpec // window function specs extracted during pre-parse
	CTEs         []CTEDef     // CTE definitions extracted during pre-parse
	Union        *UnionInfo   // non-nil if this is a UNION query
}

type SetClause struct {
	Column string
	Value  string // raw expression text
}

type SetOp string

type StarNode struct {
	Table string
}

type SubqueryNode struct {
	SQL string
}

type TableRef struct {
	Name           string
	Alias          string
	IsFunction     bool              // true for table functions like read_json(...)
	FuncArgs       []string          // positional arguments
	FuncNamedArgs  map[string]string // named arguments (key=value)
	WithOrdinality bool              // UNNEST(...) WITH ORDINALITY
	ColumnAliases  []string          // AS alias(col1, col2, ...)
	SampleMethod   string            // TABLESAMPLE method: BERNOULLI, SYSTEM
	SamplePercent  string            // percentage for TABLESAMPLE
}

type TokenType int

type TupleNode struct {
	Elements []Node
}

type UnaryOp struct {
	Op    string // -, +
	Inner Node
}

type UnionInfo struct {
	Left  *SelectInfo
	Right *SelectInfo
	All   bool  // true for UNION ALL / INTERSECT ALL / EXCEPT ALL (no dedup)
	Op    SetOp // the set operation type (defaults to UNION for backwards compat)
}

type UpdateInfo struct {
	Table      string      // table name
	SetClauses []SetClause // SET column = value pairs
	WhereSQL   string      // raw WHERE clause SQL (empty = update all rows)
}

type WhenClause struct {
	Cond   Node
	Result Node
}

type WindowFrame struct {
	Mode  FrameMode
	Start FrameBound
	End   *FrameBound // nil means "to CURRENT ROW"
}

type WindowFuncNode struct {
	Func        *FuncCallNode
	PartitionBy []Node
	OrderBy     []WindowOrderBy
	Frame       *WindowFrame
}

type WindowOrderBy struct {
	Expr       Node
	Desc       bool
	NullsFirst *bool
}

type WindowOrderItem struct {
	Column     string
	Desc       bool
	NullsFirst *bool
}

type WindowSpec struct {
	FuncName    string
	Args        string // raw arg string (e.g., "amount", "*", "")
	PartitionBy []string
	OrderBy     []WindowOrderItem
	Alias       string       // output column name
	Frame       *WindowFrame // optional frame specification
}