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
	// LitFilter is set when a PII column is compared for equality with a
	// literal the agent wrote (not a placeholder, not IS NULL), anywhere in
	// the statement. Its results carry no cell references: the agent chose
	// the value behind them, and the rows it selected may be linked to the
	// literal through any join, subquery or set operation.
	LitFilter    bool
	Replacements []Replacement
	// Values are the placeholders compared with PII columns.
	Values []ValueUse
	// KeyFilters are the non-PII columns compared with = and a literal in
	// WHERE (the console checks whether one is a unique key).
	KeyFilters []Source
}

type Assignment struct {
	Qualifier []string
	Column    string
	Value     Expr
}

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
	Write   *Write
	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
	// Value resolves a placeholder: the value the human typed for a name, or
	// the value of a referenced cell. ok is false when the console does not
	// know it (yet, for a typed name).
	Value func(kind ValueKind, name string) (value string, 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
	// Separator is the SEPARATOR string of a MySQL GROUP_CONCAT.
	Separator *Literal
	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
	// contains filtered or unexported fields
}

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
	// Write is set instead of Query for an INSERT, REPLACE, UPDATE or
	// DELETE.
	Write *Write
	// 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 ValueKind int

type ValueUse struct {
	Kind ValueKind
	// Name is "email" for '${email}', "r3.1.2" for '${r3.1.2}'.
	Name string
	// Column is the PII column the placeholder is compared with.
	Column Source
	// InList is set inside IN (...).
	InList bool
	Span   Span
}

type When struct{ Cond, Result Expr }

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

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

type Write struct {
	With *With
	Verb string // INSERT, REPLACE, UPDATE or DELETE
	// Target is the relation written.
	Target *TableName
	// Columns is the column list of an INSERT, nil when absent.
	Columns []string
	// Rows are the VALUES rows of an INSERT; a nil item is DEFAULT.
	Rows [][]Expr
	// Source is the query an INSERT stores.
	Source *Query
	// Set is the SET list of an UPDATE or of a MySQL INSERT ... SET.
	Set []*Assignment
	// From is the FROM list of an UPDATE or the USING list of a DELETE.
	From  []TableExpr
	Where Expr
	// OrderBy and Limit are the MySQL and SQLite ORDER BY and LIMIT of an
	// UPDATE or a DELETE.
	OrderBy []*OrderItem
	Limit   *Limit
	// Conflict is the conflict target of an ON CONFLICT clause (index
	// expressions and their WHERE); Upsert and UpsertWhere are its DO
	// UPDATE SET list and condition, or the ON DUPLICATE KEY UPDATE list.
	Conflict      []Expr
	ConflictWhere Expr
	Upsert        []*Assignment
	UpsertWhere   Expr
	// Returning is the RETURNING list, nil when absent.
	Returning []*SelectItem
	Sp        Span
}