sqlparse

type Error struct {
	Pos *Position
	Msg string
}

type Join struct {
	Type    JoinType
	Natural bool
	On      []Predicate // ON conjuncts (structured where possible); nil for USING/none
	Using   []string    // USING (col, …) columns; nil for ON/none
}

type JoinType int

type Limit struct {
	Count  *Value
	Offset *Value
}

type Literal struct {
	Kind LiteralKind
	Raw  string // original source text (e.g. 21, 'paid', X'4142', CURRENT_TIMESTAMP)
	// Value is the parsed Go value matching Kind:
	//   LiteralInteger -> int64    LiteralFloat   -> float64
	//   LiteralString  -> string   LiteralBool    -> bool
	//   LiteralBlob    -> []byte   LiteralNull    -> nil
	//   LiteralKeyword -> string (the upper-cased keyword)
	//
	// Prefer the typed accessors (AsInt, AsString, …) over asserting Value.
	Value any
}

type LiteralKind int

type Operator int

type OrderTerm struct {
	Table  string
	Column string
	Expr   string
	Desc   bool
}

type Position struct {
	Line   int
	Column int
}

type Predicate struct {
	Table  string // column's table qualifier ("" if unqualified)
	Column string
	Op     Operator
	Value  *Value  // single right-hand value (see above)
	Values []Value // multiple right-hand values: IN list, or BETWEEN [low, high]
	// RefTable/RefColumn hold the right-hand column when the comparison is
	// column-to-column (both Value and Values are nil).
	RefTable  string
	RefColumn string
	Raw       string // always set: original text of the conjunct
}

type Projection struct {
	Star   bool   // SELECT * (Table=="") or SELECT t.* (Table set)
	Table  string // qualifier for t.* or for a qualified column
	Column string // column name for a simple column projection
	Alias  string // AS alias, if any
	Expr   string // raw text for non-column expressions (e.g. COUNT(*))
}

type Query struct {
	// Raw is the original SQL, run verbatim against the local database later.
	Raw string
	// Tables are the external base tables the query references: referenced
	// tables minus CTE names and table-valued functions, deduped and sorted,
	// with identifiers unquoted.
	Tables []string
	// Columns are the column names the query references, deduped and sorted,
	// with identifiers unquoted. This is a flat set across the whole query;
	// mapping each column to a specific table is future work. SELECT * yields
	// no columns (the set of columns is not known syntactically).
	Columns []string
	// Stmt is the structured AST of the query, built for planning what to fetch
	// per source and which filters/projections can be pushed down. Tables and
	// Columns above are exhaustive flat views; Stmt models the query structure
	// (see ast.go for what is and isn't yet represented).
	Stmt *Select
}

type Select struct {
	// Complete reports whether the AST fully represents the source query. It is
	// false when the parser dropped clauses the AST does not model (ORDER BY,
	// LIMIT, GROUP BY/HAVING, WINDOW, WITH/CTE, or a compound UNION/EXCEPT tail),
	// meaning SQL() reconstructs only part of the query and must not be treated
	// as an equivalent rewrite. The zero value (false) is the safe default.
	Complete    bool
	Distinct    bool
	Projections []Projection
	// From holds the FROM/JOIN sources in order. From[0] is the first source;
	// each later source From[i] is connected by Joins[i-1].
	From []Source
	// Joins[i] describes how From[i+1] joins the preceding sources.
	Joins []Join
	// Where holds the top-level AND-ed conjuncts of the WHERE clause.
	Where []Predicate
	// OrderBy holds the ORDER BY terms in order, empty if none.
	OrderBy []OrderTerm
	// Limit holds the LIMIT/OFFSET clause, nil if none.
	Limit *Limit
}

type Source struct {
	Schema   string  // optional schema qualifier (base tables only)
	Name     string  // base table name; empty for subquery / Raw sources
	Subquery *Select // non-nil when the source is a (SELECT …) subquery
	Alias    string  // empty when unaliased
	Raw      string  // original text for unmodeled sources (table functions, paren joins)
}

type Value struct {
	Kind    ValueKind
	Literal *Literal // set when Kind == ValueLiteral
	Bind    string   // bind parameter token (e.g. ?, :id, @x, $y) when Kind == ValueBind
}

type ValueKind int