sqlparser

type Assignment struct {
	Columns []*Ident // column list
	Expr    Expr     // assigned expression
}

type BinaryExpr struct {
	X  Expr  // lhs
	Op Token // operator
	Y  Expr  // rhs
}

type BindExpr struct {
	Name string // binding name
	Pos  int    // binding position
}

type BlobLit struct {
	Value string // literal value
}

type BoolLit struct {
	Value bool // literal value
}

type Call struct {
	Name     *Ident // function name
	Star     bool
	Distinct bool
	Args     []Expr        // argument list
	Filter   *FilterClause // filter clause
}

type CaseBlock struct {
	Condition Expr // block condition
	Body      Expr // result expression
}

type CaseExpr struct {
	Operand  Expr         // optional condition after the CASE keyword
	Blocks   []*CaseBlock // list of WHEN/THEN pairs
	ElseExpr Expr         // expression used by default case
}

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

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

type DeleteStatement struct {
	Only      bool
	TableName *TableName
	TableStar bool
	Alias     *Ident

	UsingList []*TableName

	Condition  Expr
	CursorName *Ident

	OutputExpressions *OutputNames
}

type Error struct {
	Pos Pos
	Msg string
}

type Exists struct {
	Not    bool
	Select *SelectStatement // select statement
}

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

type Exprs struct {
	Exprs []Expr // list of expressions
}

type FilterClause struct {
	X Expr // filter expression
}

type Hint struct {
	Value string
}

type Ident struct {
	Name      string // identifier name
	Quoted    bool   // true if double quoted
	QuoteChar string // " for postgresql, ` for mysql, etc
}

type IndexedColumn struct {
	X    Expr // column expression
	Asc  bool
	Desc bool
}

type InsertStatement struct {
	TableName *TableName

	ColumnNames []*Ident
	Overriding  string

	DefaultValues bool
	Expressions   []*Exprs
	Query         *SelectStatement

	UpsertClause *UpsertClause

	OutputExpressions *OutputNames
}

type JoinClause struct {
	X          Source         // lhs source
	Operator   *JoinOperator  // join operator
	Y          Source         // rhs source
	Constraint JoinConstraint // join constraint
}

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

type JoinOperator struct {
	Comma   bool
	Natural bool
	Left    bool
	Outer   bool
	Inner   bool
	Cross   bool
}

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

type Node interface {
	fmt.Stringer
	// contains filtered or unexported methods
}

type NullLit struct {
}

type NumberLit struct {
	Value string // literal value
}

type OnConstraint struct {
	X Expr // constraint expression
}

type OrderingTerm struct {
	X Expr // ordering expression

	Asc  bool
	Desc bool

	NullsFirst bool
	NullsLast  bool
}

type OutputNames []*ResultColumn

type ParenExpr struct {
	X Expr // parenthesized expression
}

type ParenSource struct {
	X     Source // nested source
	Alias *Ident // optional table alias (select source only)
}

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

type Pos struct {
	Offset int // offset, starting at 0
	Line   int // line number, starting at 1
	Column int // column number, starting at 1 (byte count)
}

type QualifiedRef struct {
	Table  *Ident // table name
	Star   bool
	Column *Ident // column name
}

type Range struct {
	X Expr // lhs expression
	Y Expr // rhs expression
}

type ResultColumn struct {
	Star  bool
	Expr  Expr   // column expression (may be "tbl.*")
	Alias *Ident // alias name
}

type Scope struct {
	Parent *Scope
	Source Source
}

type SelectStatement struct {
	All      bool
	Distinct bool
	Columns  *OutputNames // list of result columns in the SELECT clause

	FromItems Source

	Condition Expr

	GroupingElements []Expr
	HavingCondition  Expr

	Union     bool
	UnionAll  bool
	Intersect bool
	Except    bool
	Compound  *SelectStatement // compounded SELECT statement

	OrderBy []*OrderingTerm // terms of ORDER BY clause

	Limit  Expr
	Fetch  Expr
	Offset Expr // offset expression

	Hint *Hint
}

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

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

type StringLit struct {
	Value string // literal value (without quotes)
}

type TableName struct {
	Name  *Ident // table name
	Alias *Ident // optional table alias
}

type Token int

type Type struct {
	Name      *Ident     // type name
	Lparen    Pos        // position of left paren (optional)
	Precision *NumberLit // precision (optional)
	Scale     *NumberLit // scale (optional)
	Rparen    Pos        // position of right paren (optional)
}

type UnaryExpr struct {
	Op Token // operation
	X  Expr  // target expression
}

type UpdateStatement struct {
	Only      bool
	TableName *TableName
	TableStar bool
	Alias     *Ident

	Assignments []*Assignment

	FromList []*TableName

	Condition  Expr
	CursorName *Ident

	OutputExpressions *OutputNames
}

type UpsertClause struct {
	Columns   []*IndexedColumn // optional indexed column list
	WhereExpr Expr             // optional conditional expression

	DoNothing       bool          // position of NOTHING keyword after DO
	DoUpdate        bool          // position of UPDATE keyword after DO
	Assignments     []*Assignment // list of column assignments
	UpdateWhereExpr Expr          // optional conditional expression for DO UPDATE SET
}

type UsingConstraint struct {
	Columns []*Ident // column list
}

type VisitEndFunc func(Node) error

type VisitFunc func(Node) error

type Visitor interface {
	Visit(node Node) (w Visitor, err error)
	VisitEnd(node Node) error
}