sqlast

type Analysis struct {
	Outputs []Output
	// Relations are the base relations read, "db.table".
	Relations []string
	// Uses are the PII columns the statement touches.
	Uses []Use
	// KChecks must all pass (k rows or more) before the statement runs.
	KChecks []KCheck
	// PIIFilter is set when a PII column is compared with a constant: row
	// estimates must not reach the agent.
	PIIFilter    bool
	Replacements []Replacement
}

type Between struct {
	X, Lo, Hi Expr
	Not       bool
	Sp        Span
}

type Binary struct {
	Op   string
	L, R Expr
	Sp   Span
}

type Body interface {
	// contains filtered or unexported methods
}

type CTE struct {
	Name    string
	Columns []string
	Query   *Query
	Sp      Span
}

type Case struct {
	Operand Expr
	Whens   []When
	Else    Expr
	Sp      Span
}

type Cast struct {
	X    Expr
	Type string
	Sp   Span
}

type Catalog interface {
	// Lookup returns the relations a table name (folded parts, as written)
	// may denote: none when it is unknown, several when it is ambiguous.
	Lookup(parts []string) ([]Table, error)
}

type Collate struct {
	X    Expr
	Name string
	Sp   Span
}

type ColumnRef struct {
	Parts []string
	Sp    Span
}

type Derived struct {
	Lateral    bool
	Query      *Query
	Alias      string
	ColAliases []string
	Sp         Span
}

type Env struct {
	Catalog Catalog
	// Rule returns the mask mode of a base column, and whether a rule
	// covers it.
	Rule func(Source) (mode string, masked bool)
	// Masking is false for an unmask plan: provenance and functions are
	// still checked, but not the PII usage rules.
	Masking bool
	// Token resolves a string literal (without quotes) that looks like a
	// token issued by the console. isToken reports the token format; ok
	// whether the console knows it.
	Token func(lit string) (value string, isToken, ok bool)
}

type Exists struct {
	Query *Query
	Not   bool
	Sp    Span
}

type Expr interface{ Span() Span }

type FuncCall struct {
	// Name is the folded, dot-joined function name.
	Name     string
	Args     []Expr
	Star     bool // COUNT(*)
	Distinct bool
	// OrderBy is an ordered-set argument: string_agg(x, ',' ORDER BY y),
	// GROUP_CONCAT(x ORDER BY y).
	OrderBy []*OrderItem
	Filter  Expr
	Over    *Window
	Sp      Span
}

type In struct {
	X     Expr
	List  []Expr
	Query *Query
	Not   bool
	Sp    Span
}

type IsTest struct {
	X    Expr
	Not  bool
	What string // NULL, TRUE, FALSE, UNKNOWN, DISTINCT
	Y    Expr   // DISTINCT FROM y
	Sp   Span
}

type Join struct {
	Kind        string // INNER, LEFT, RIGHT, FULL, CROSS
	Natural     bool
	Left, Right TableExpr
	On          Expr
	Using       []string
	Sp          Span
}

type KCheck struct {
	SQL string
	// Grouped checks the smallest group (its result may be NULL when no
	// group remains); otherwise it counts the rows.
	Grouped bool
}

type Kind int

type Like struct {
	Op         string
	X, Pattern Expr
	Escape     Expr
	Not        bool
	Sp         Span
}

type Limit struct {
	Count, Offset int64
}

type LitKind int

type Literal struct {
	Kind LitKind
	// Text is the source text of the literal (with its quotes).
	Text string
	Sp   Span
}

type OrderItem struct {
	Expr Expr
	Desc bool
}

type Output struct {
	// Label is the column label the engine must report (an alias or a
	// plain column name), "" when the engine chooses it.
	Label string
	Prov  Prov
	// Mask is the mask mode of the column, "" for none.
	Mask string
}

type Paren struct {
	X  Expr
	Sp Span
}

type Prov struct {
	Sources []Source
	Kind    Kind
	// Sensitive is set when a source is under a mask rule and the value
	// reveals source values (Kind Identity, Aggregate or Expr).
	Sensitive bool
	// Modes are the mask modes of the sensitive sources.
	Modes []string
	// Lit is set when some values may be literals of the statement (a
	// UNION of a column and a constant, for instance).
	Lit bool
}

type Query struct {
	With    *With
	Body    Body
	OrderBy []*OrderItem
	Limit   *Limit
	Sp      Span
}

type Replacement struct {
	Span Span
	Text string
}

type Select struct {
	Distinct   bool
	DistinctOn []Expr
	Items      []*SelectItem
	From       []TableExpr
	Where      Expr
	GroupBy    []Expr
	Having     Expr
	Sp         Span
	// Spans of the FROM list, the WHERE condition, the GROUP BY list and
	// the HAVING condition (without their keywords); zero when absent.
	FromSp, WhereSp, GroupSp, HavingSp Span
}

type SelectItem struct {
	Star      bool
	Qualifier []string
	Expr      Expr
	Alias     string
	Sp        Span
}

type SetOp struct {
	Op          string
	All         bool
	Left, Right Body
	Sp          Span
}

type Source struct {
	DB, Table, Column string
	// View marks a column of a view (or of a relation whose base columns
	// are unknown): rules match it by column name.
	View bool
}

type Span struct{ Pos, End int }

type Statement struct {
	// Explain is set for EXPLAIN SELECT: the console runs the EXPLAIN
	// itself, without ANALYZE.
	Explain bool
	Query   *Query
	// SQL is the statement text the spans refer to.
	SQL     string
	Dialect sqlclass.Dialect
}

type Subquery struct {
	Query *Query
	Sp    Span
}

type Table struct {
	DB, Name string
	Columns  []string
	View     bool
}

type TableExpr interface {
	// contains filtered or unexported methods
}

type TableName struct {
	// Parts are the folded name parts: [table], [db, table] or
	// [catalog, schema, table].
	Parts      []string
	Alias      string
	ColAliases []string
	Sp         Span
}

type Tuple struct {
	Items []Expr
	Sp    Span
}

type Unary struct {
	Op string
	X  Expr
	Sp Span
}

type Use struct {
	Source Source
	Clause string
}

type When struct{ Cond, Result Expr }

type Window struct {
	PartitionBy []Expr
	OrderBy     []*OrderItem
}

type With struct {
	Recursive bool
	CTEs      []*CTE
	Sp        Span
}