ast

type AdminStmt struct {
	Tp        AdminStmtType
	Index     string
	Tables    []*TableName
	JobIDs    []int64
	JobNumber int64

	HandleRanges []HandleRange
	ShowSlow     *ShowSlow
	// contains filtered or unexported fields
}

type AdminStmtType int

type AggregateFuncExpr struct {

	// F is the function name.
	F string
	// Args is the function args.
	Args []ExprNode
	// Distinct is true, function hence only aggregate distinct values.
	// For example, column c1 values are "1", "2", "2",  "sum(c1)" is "5",
	// but "sum(distinct c1)" is "3".
	Distinct bool
	// contains filtered or unexported fields
}

type AlterTableSpec struct {
	Tp              AlterTableType
	Name            string
	Constraint      *Constraint
	Options         []*TableOption
	NewTable        *TableName
	NewColumns      []*ColumnDef
	OldColumnName   *ColumnName
	Position        *ColumnPosition
	LockType        LockType
	Comment         string
	FromKey         model.CIStr
	ToKey           model.CIStr
	PartDefinitions []*PartitionDefinition
	// contains filtered or unexported fields
}

type AlterTableStmt struct {
	Table *TableName
	Specs []*AlterTableSpec
	// contains filtered or unexported fields
}

type AlterTableType int

type AlterUserStmt struct {
	IfExists    bool
	CurrentAuth *AuthOption
	Specs       []*UserSpec
	// contains filtered or unexported fields
}

type AnalyzeTableStmt struct {
	TableNames     []*TableName
	PartitionNames []model.CIStr
	IndexNames     []model.CIStr
	MaxNumBuckets  uint64

	// IndexFlag is true when we only analyze indices for a table.
	IndexFlag bool
	// contains filtered or unexported fields
}

type Assignment struct {

	// Column is the column name to be assigned.
	Column *ColumnName
	// Expr is the expression assigning to ColName.
	Expr ExprNode
	// contains filtered or unexported fields
}

type AuthOption struct {
	// ByAuthString set as true, if AuthString is used for authorization. Otherwise, authorization is done by HashString.
	ByAuthString bool
	AuthString   string
	HashString   string
}

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

type BetweenExpr struct {

	// Expr is the expression to be checked.
	Expr ExprNode
	// Left is the expression for minimal value in the range.
	Left ExprNode
	// Right is the expression for maximum value in the range.
	Right ExprNode
	// Not is true, the expression is "not between and".
	Not bool
	// contains filtered or unexported fields
}

type BinaryOperationExpr struct {

	// Op is the operator code for BinaryOperation.
	Op opcode.Op
	// L is the left expression in BinaryOperation.
	L ExprNode
	// R is the right expression in BinaryOperation.
	R ExprNode
	// contains filtered or unexported fields
}

type BinlogStmt struct {
	Str string
	// contains filtered or unexported fields
}

type BoundType int

type ByItem struct {
	Expr ExprNode
	Desc bool
	// contains filtered or unexported fields
}

type CaseExpr struct {

	// Value is the compare value expression.
	Value ExprNode
	// WhenClauses is the condition check expression.
	WhenClauses []*WhenClause
	// ElseClause is the else result expression.
	ElseClause ExprNode
	// contains filtered or unexported fields
}

type CastFunctionType int

type ChangeStmt struct {
	NodeType string
	State    string
	NodeID   string
	// contains filtered or unexported fields
}

type CharsetOpt struct {
	Chs string
	Col string
}

type ColumnDef struct {
	Name    *ColumnName
	Tp      *types.FieldType
	Options []*ColumnOption
	// contains filtered or unexported fields
}

type ColumnName struct {
	Schema model.CIStr
	Table  model.CIStr
	Name   model.CIStr
	// contains filtered or unexported fields
}

type ColumnNameExpr struct {

	// Name is the referenced column name.
	Name *ColumnName

	// Refer is the result field the column name refers to.
	// The value of Refer.Expr is used as the value of the expression.
	Refer *ResultField
	// contains filtered or unexported fields
}

type ColumnOption struct {
	Tp ColumnOptionType
	// Expr is used for ColumnOptionDefaultValue/ColumnOptionOnUpdateColumnOptionGenerated.
	// For ColumnOptionDefaultValue or ColumnOptionOnUpdate, it's the target value.
	// For ColumnOptionGenerated, it's the target expression.
	Expr ExprNode
	// Stored is only for ColumnOptionGenerated, default is false.
	Stored bool
	// Refer is used for foreign key.
	Refer    *ReferenceDef
	StrValue string
	// contains filtered or unexported fields
}

type ColumnOptionType int

type ColumnPosition struct {

	// Tp is either ColumnPositionNone, ColumnPositionFirst or ColumnPositionAfter.
	Tp ColumnPositionType
	// RelativeColumn is the column the newly added column after if type is ColumnPositionAfter
	RelativeColumn *ColumnName
	// contains filtered or unexported fields
}

type ColumnPositionType int

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

type CompareSubqueryExpr struct {

	// L is the left expression
	L ExprNode
	// Op is the comparison opcode.
	Op opcode.Op
	// R is the subquery for right expression, may be rewritten to other type of expression.
	R ExprNode
	// All is true, we should compare all records in subquery.
	All bool
	// contains filtered or unexported fields
}

type Constraint struct {
	Tp   ConstraintType
	Name string

	Keys []*IndexColName // Used for PRIMARY KEY, UNIQUE, ......

	Refer *ReferenceDef // Used for foreign key.

	Option *IndexOption // Index Options
	// contains filtered or unexported fields
}

type ConstraintType int

type CreateDatabaseStmt struct {
	IfNotExists bool
	Name        string
	Options     []*DatabaseOption
	// contains filtered or unexported fields
}

type CreateIndexStmt struct {
	IndexName     string
	Table         *TableName
	Unique        bool
	IndexColNames []*IndexColName
	IndexOption   *IndexOption
	// contains filtered or unexported fields
}

type CreateTableStmt struct {
	IfNotExists bool
	Table       *TableName
	ReferTable  *TableName
	Cols        []*ColumnDef
	Constraints []*Constraint
	Options     []*TableOption
	Partition   *PartitionOptions
	OnDuplicate OnDuplicateCreateTableSelectType
	Select      ResultSetNode
	// contains filtered or unexported fields
}

type CreateUserStmt struct {
	IfNotExists bool
	Specs       []*UserSpec
	// contains filtered or unexported fields
}

type CreateViewStmt struct {
	OrReplace bool
	ViewName  *TableName
	Cols      []model.CIStr
	Select    StmtNode
	// contains filtered or unexported fields
}

type DDLNode interface {
	StmtNode
	// contains filtered or unexported methods
}

type DMLNode interface {
	StmtNode
	// contains filtered or unexported methods
}

type DatabaseOption struct {
	Tp    DatabaseOptionType
	Value string
}

type DatabaseOptionType int

type DateArithType byte

type DeallocateStmt struct {
	Name string
	// contains filtered or unexported fields
}

type DefaultExpr struct {

	// Name is the column name.
	Name *ColumnName
	// contains filtered or unexported fields
}

type DeleteStmt struct {

	// TableRefs is used in both single table and multiple table delete statement.
	TableRefs *TableRefsClause
	// Tables is only used in multiple table delete statement.
	Tables       *DeleteTableList
	Where        ExprNode
	Order        *OrderByClause
	Limit        *Limit
	Priority     mysql.PriorityEnum
	IgnoreErr    bool
	Quick        bool
	IsMultiTable bool
	BeforeFrom   bool
	// TableHints represents the table level Optimizer Hint for join type.
	TableHints []*TableOptimizerHint
	// contains filtered or unexported fields
}

type DeleteTableList struct {
	Tables []*TableName
	// contains filtered or unexported fields
}

type DoStmt struct {
	Exprs []ExprNode
	// contains filtered or unexported fields
}

type DropDatabaseStmt struct {
	IfExists bool
	Name     string
	// contains filtered or unexported fields
}

type DropIndexStmt struct {
	IfExists  bool
	IndexName string
	Table     *TableName
	// contains filtered or unexported fields
}

type DropStatsStmt struct {
	Table *TableName
	// contains filtered or unexported fields
}

type DropTableStmt struct {
	IfExists bool
	Tables   []*TableName
	// contains filtered or unexported fields
}

type DropUserStmt struct {
	IfExists bool
	UserList []*auth.UserIdentity
	// contains filtered or unexported fields
}

type ExecuteStmt struct {
	Name      string
	UsingVars []ExprNode
	ExecID    uint32
	// contains filtered or unexported fields
}

type ExistsSubqueryExpr struct {

	// Sel is the subquery, may be rewritten to other type of expression.
	Sel ExprNode
	// contains filtered or unexported fields
}

type ExplainStmt struct {
	Stmt    StmtNode
	Format  string
	Analyze bool
	// contains filtered or unexported fields
}

type ExprNode interface {
	// Node is embedded in ExprNode.
	Node
	// SetType sets evaluation type to the expression.
	SetType(tp *types.FieldType)
	// GetType gets the evaluation type of the expression.
	GetType() *types.FieldType
	// SetFlag sets flag to the expression.
	// Flag indicates whether the expression contains
	// parameter marker, reference, aggregate function...
	SetFlag(flag uint64)
	// GetFlag returns the flag of the expression.
	GetFlag() uint64

	// Format formats the AST into a writer.
	Format(w io.Writer)
}

type FieldList struct {
	Fields []*SelectField
	// contains filtered or unexported fields
}

type FieldsClause struct {
	Terminated string
	Enclosed   byte
	Escaped    byte
}

type FloatOpt struct {
	Flen    int
	Decimal int
}

type FlushStmt struct {
	Tp              FlushStmtType // Privileges/Tables/...
	NoWriteToBinLog bool
	Tables          []*TableName // For FlushTableStmt, if Tables is empty, it means flush all tables.
	ReadLock        bool
	Plugins         []string
	// contains filtered or unexported fields
}

type FlushStmtType int

type FrameBound struct {
	Type      BoundType
	UnBounded bool
	Expr      ExprNode
	// `Unit` is used to indicate the units in which the `Expr` should be interpreted.
	// For example: '2:30' MINUTE_SECOND.
	Unit ExprNode
	// contains filtered or unexported fields
}

type FrameClause struct {
	Type   FrameType
	Extent FrameExtent
	// contains filtered or unexported fields
}

type FrameExtent struct {
	Start FrameBound
	End   FrameBound
}

type FrameType int

type FuncCallExpr struct {

	// FnName is the function name.
	FnName model.CIStr
	// Args is the function args.
	Args []ExprNode
	// contains filtered or unexported fields
}

type FuncCastExpr struct {

	// Expr is the expression to be converted.
	Expr ExprNode
	// Tp is the conversion type.
	Tp *types.FieldType
	// FunctionType is either Cast, Convert or Binary.
	FunctionType CastFunctionType
	// contains filtered or unexported fields
}

type FuncNode interface {
	ExprNode
	// contains filtered or unexported methods
}

type GrantLevel struct {
	Level     GrantLevelType
	DBName    string
	TableName string
}

type GrantLevelType int

type GrantStmt struct {
	Privs      []*PrivElem
	ObjectType ObjectTypeType
	Level      *GrantLevel
	Users      []*UserSpec
	WithGrant  bool
	// contains filtered or unexported fields
}

type GroupByClause struct {
	Items []*ByItem
	// contains filtered or unexported fields
}

type HandleRange struct {
	Begin int64
	End   int64
}

type HavingClause struct {
	Expr ExprNode
	// contains filtered or unexported fields
}

type Ident struct {
	Schema model.CIStr
	Name   model.CIStr
}

type IndexColName struct {
	Column *ColumnName
	Length int
	// contains filtered or unexported fields
}

type IndexHint struct {
	IndexNames []model.CIStr
	HintType   IndexHintType
	HintScope  IndexHintScope
}

type IndexHintScope int

type IndexHintType int

type IndexOption struct {
	KeyBlockSize uint64
	Tp           model.IndexType
	Comment      string
	// contains filtered or unexported fields
}

type InsertStmt struct {
	IsReplace   bool
	IgnoreErr   bool
	Table       *TableRefsClause
	Columns     []*ColumnName
	Lists       [][]ExprNode
	Setlist     []*Assignment
	Priority    mysql.PriorityEnum
	OnDuplicate []*Assignment
	Select      ResultSetNode
	// contains filtered or unexported fields
}

type IsNullExpr struct {

	// Expr is the expression to be checked.
	Expr ExprNode
	// Not is true, the expression is "is not null".
	Not bool
	// contains filtered or unexported fields
}

type IsTruthExpr struct {

	// Expr is the expression to be checked.
	Expr ExprNode
	// Not is true, the expression is "is not true/false".
	Not bool
	// True indicates checking true or false.
	True int64
	// contains filtered or unexported fields
}

type Join struct {

	// Left table can be TableSource or JoinNode.
	Left ResultSetNode
	// Right table can be TableSource or JoinNode or nil.
	Right ResultSetNode
	// Tp represents join type.
	Tp JoinType
	// On represents join on condition.
	On *OnCondition
	// Using represents join using clause.
	Using []*ColumnName
	// NaturalJoin represents join is natural join.
	NaturalJoin bool
	// StraightJoin represents a straight join.
	StraightJoin bool
	// contains filtered or unexported fields
}

type JoinType int

type KillStmt struct {

	// Query indicates whether terminate a single query on this connection or the whole connection.
	// If Query is true, terminates the statement the connection is currently executing, but leaves the connection itself intact.
	// If Query is false, terminates the connection associated with the given ConnectionID, after terminating any statement the connection is executing.
	Query        bool
	ConnectionID uint64
	// TiDBExtension is used to indicate whether the user knows he is sending kill statement to the right tidb-server.
	// When the SQL grammar is "KILL TIDB [CONNECTION | QUERY] connectionID", TiDBExtension will be set.
	// It's a special grammar extension in TiDB. This extension exists because, when the connection is:
	// client -> LVS proxy -> TiDB, and type Ctrl+C in client, the following action will be executed:
	// new a connection; kill xxx;
	// kill command may send to the wrong TiDB, because the exists of LVS proxy, and kill the wrong session.
	// So, "KILL TIDB" grammar is introduced, and it REQUIRES DIRECT client -> TiDB TOPOLOGY.
	// TODO: The standard KILL grammar will be supported once we have global connectionID.
	TiDBExtension bool
	// contains filtered or unexported fields
}

type Limit struct {
	Count  ExprNode
	Offset ExprNode
	// contains filtered or unexported fields
}

type LinesClause struct {
	Starting   string
	Terminated string
}

type LoadDataStmt struct {
	IsLocal     bool
	Path        string
	Table       *TableName
	Columns     []*ColumnName
	FieldsInfo  *FieldsClause
	LinesInfo   *LinesClause
	IgnoreLines uint64
	// contains filtered or unexported fields
}

type LoadStatsStmt struct {
	Path string
	// contains filtered or unexported fields
}

type LockType byte

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

type Node interface {
	// Accept accepts Visitor to visit itself.
	// The returned node should replace original node.
	// ok returns false to stop visiting.
	//
	// Implementation of this method should first call visitor.Enter,
	// assign the returned node to its method receiver, if skipChildren returns true,
	// children should be skipped. Otherwise, call its children in particular order that
	// later elements depends on former elements. Finally, return visitor.Leave.
	Accept(v Visitor) (node Node, ok bool)
	// Text returns the original text of the element.
	Text() string
	// SetText sets original text to the Node.
	SetText(text string)
}

type ObjectTypeType int

type OnCondition struct {
	Expr ExprNode
	// contains filtered or unexported fields
}

type OnDeleteOpt struct {
	ReferOpt ReferOptionType
	// contains filtered or unexported fields
}

type OnDuplicateCreateTableSelectType int

type OnUpdateOpt struct {
	ReferOpt ReferOptionType
	// contains filtered or unexported fields
}

type OptBinary struct {
	IsBinary bool
	Charset  string
}

type OrderByClause struct {
	Items    []*ByItem
	ForUnion bool
	// contains filtered or unexported fields
}

type ParamMarkerExpr interface {
	ValueExpr
	SetOrder(int)
}

type ParenthesesExpr struct {

	// Expr is the expression in parentheses.
	Expr ExprNode
	// contains filtered or unexported fields
}

type PartitionByClause struct {
	Items []*ByItem
	// contains filtered or unexported fields
}

type PartitionDefinition struct {
	Name     model.CIStr
	LessThan []ExprNode
	MaxValue bool
	Comment  string
}

type PartitionOptions struct {
	Tp          model.PartitionType
	Expr        ExprNode
	ColumnNames []*ColumnName
	Definitions []*PartitionDefinition
	Num         uint64
}

type PatternInExpr struct {

	// Expr is the value expression to be compared.
	Expr ExprNode
	// List is the list expression in compare list.
	List []ExprNode
	// Not is true, the expression is "not in".
	Not bool
	// Sel is the subquery, may be rewritten to other type of expression.
	Sel ExprNode
	// contains filtered or unexported fields
}

type PatternLikeExpr struct {

	// Expr is the expression to be checked.
	Expr ExprNode
	// Pattern is the like expression.
	Pattern ExprNode
	// Not is true, the expression is "not like".
	Not bool

	Escape byte

	PatChars []byte
	PatTypes []byte
	// contains filtered or unexported fields
}

type PatternRegexpExpr struct {

	// Expr is the expression to be checked.
	Expr ExprNode
	// Pattern is the expression for pattern.
	Pattern ExprNode
	// Not is true, the expression is "not rlike",
	Not bool

	// Re is the compiled regexp.
	Re *regexp.Regexp
	// Sexpr is the string for Expr expression.
	Sexpr *string
	// contains filtered or unexported fields
}

type PositionExpr struct {

	// N is the position, started from 1 now.
	N int
	// Refer is the result field the position refers to.
	Refer *ResultField
	// contains filtered or unexported fields
}

type PrepareStmt struct {
	Name    string
	SQLText string
	SQLVar  *VariableExpr
	// contains filtered or unexported fields
}

type Prepared struct {
	Stmt          StmtNode
	Params        []ParamMarkerExpr
	SchemaVersion int64
	UseCache      bool
}

type PrivElem struct {
	Priv mysql.PrivilegeType
	Cols []*ColumnName
	// contains filtered or unexported fields
}

type ReferOptionType int

type ReferenceDef struct {
	Table         *TableName
	IndexColNames []*IndexColName
	OnDelete      *OnDeleteOpt
	OnUpdate      *OnUpdateOpt
	// contains filtered or unexported fields
}

type RenameTableStmt struct {
	OldTable *TableName
	NewTable *TableName

	// TableToTables is only useful for syncer which depends heavily on tidb parser to do some dirty work for now.
	// TODO: Refactor this when you are going to add full support for multiple schema changes.
	TableToTables []*TableToTable
	// contains filtered or unexported fields
}

type ResultField struct {
	Column       *model.ColumnInfo
	ColumnAsName model.CIStr
	Table        *model.TableInfo
	TableAsName  model.CIStr
	DBName       model.CIStr

	// Expr represents the expression for the result field. If it is generated from a select field, it would
	// be the expression of that select field, otherwise the type would be ValueExpr and value
	// will be set for every retrieved row.
	Expr      ExprNode
	TableName *TableName
	// Referenced indicates the result field has been referenced or not.
	// If not, we don't need to get the values.
	Referenced bool
}

type ResultSetNode interface {
	Node
}

type RevokeStmt struct {
	Privs      []*PrivElem
	ObjectType ObjectTypeType
	Level      *GrantLevel
	Users      []*UserSpec
	// contains filtered or unexported fields
}

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

type RowExpr struct {
	Values []ExprNode
	// contains filtered or unexported fields
}

type SelectField struct {

	// Offset is used to get original text.
	Offset int
	// WildCard is not nil, Expr will be nil.
	WildCard *WildCardField
	// Expr is not nil, WildCard will be nil.
	Expr ExprNode
	// AsName is alias name for Expr.
	AsName model.CIStr
	// Auxiliary stands for if this field is auxiliary.
	// When we add a Field into SelectField list which is used for having/orderby clause but the field is not in select clause,
	// we should set its Auxiliary to true. Then the TrimExec will trim the field.
	Auxiliary bool
	// contains filtered or unexported fields
}

type SelectLockType int

type SelectStmt struct {

	// SelectStmtOpts wraps around select hints and switches.
	*SelectStmtOpts
	// Distinct represents whether the select has distinct option.
	Distinct bool
	// From is the from clause of the query.
	From *TableRefsClause
	// Where is the where clause in select statement.
	Where ExprNode
	// Fields is the select expression list.
	Fields *FieldList
	// GroupBy is the group by expression list.
	GroupBy *GroupByClause
	// Having is the having condition.
	Having *HavingClause
	// WindowSpecs is the window specification list.
	WindowSpecs []WindowSpec
	// OrderBy is the ordering expression list.
	OrderBy *OrderByClause
	// Limit is the limit clause.
	Limit *Limit
	// LockTp is the lock type
	LockTp SelectLockType
	// TableHints represents the table level Optimizer Hint for join type
	TableHints []*TableOptimizerHint
	// IsAfterUnionDistinct indicates whether it's a stmt after "union distinct".
	IsAfterUnionDistinct bool
	// IsInBraces indicates whether it's a stmt in brace.
	IsInBraces bool
	// contains filtered or unexported fields
}

type SelectStmtOpts struct {
	Distinct      bool
	SQLCache      bool
	CalcFoundRows bool
	StraightJoin  bool
	Priority      mysql.PriorityEnum
	TableHints    []*TableOptimizerHint
}

type SensitiveStmtNode interface {
	StmtNode
	// SecureText is different from Text that it hide password information.
	SecureText() string
}

type SetPwdStmt struct {
	User     *auth.UserIdentity
	Password string
	// contains filtered or unexported fields
}

type SetStmt struct {

	// Variables is the list of variable assignment.
	Variables []*VariableAssignment
	// contains filtered or unexported fields
}

type ShowSlow struct {
	Tp    ShowSlowType
	Count uint64
	Kind  ShowSlowKind
}

type ShowSlowKind int

type ShowSlowType int

type ShowStmt struct {
	Tp     ShowStmtType // Databases/Tables/Columns/....
	DBName string
	Table  *TableName  // Used for showing columns.
	Column *ColumnName // Used for `desc table column`.
	Flag   int         // Some flag parsed from sql, such as FULL.
	Full   bool
	User   *auth.UserIdentity // Used for show grants.

	// GlobalScope is used by show variables
	GlobalScope bool
	Pattern     *PatternLikeExpr
	Where       ExprNode
	// contains filtered or unexported fields
}

type ShowStmtType int

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

type SubqueryExpr struct {

	// Query is the query SelectNode.
	Query      ResultSetNode
	Evaluated  bool
	Correlated bool
	MultiRows  bool
	Exists     bool
	// contains filtered or unexported fields
}

type TableName struct {
	Schema model.CIStr
	Name   model.CIStr

	DBInfo    *model.DBInfo
	TableInfo *model.TableInfo

	IndexHints []*IndexHint
	// contains filtered or unexported fields
}

type TableOptimizerHint struct {

	// HintName is the name or alias of the table(s) which the hint will affect.
	// Table hints has no schema info
	// It allows only table name or alias (if table has an alias)
	HintName model.CIStr
	Tables   []model.CIStr
	// Statement Execution Time Optimizer Hints
	// See https://dev.mysql.com/doc/refman/5.7/en/optimizer-hints.html#optimizer-hints-execution-time
	MaxExecutionTime uint64
	// contains filtered or unexported fields
}

type TableOption struct {
	Tp        TableOptionType
	StrValue  string
	UintValue uint64
}

type TableOptionType int

type TableRefsClause struct {
	TableRefs *Join
	// contains filtered or unexported fields
}

type TableSource struct {

	// Source is the source of the data, can be a TableName,
	// a SelectStmt, a UnionStmt, or a JoinNode.
	Source ResultSetNode

	// AsName is the alias name of the table source.
	AsName model.CIStr
	// contains filtered or unexported fields
}

type TableToTable struct {
	OldTable *TableName
	NewTable *TableName
	// contains filtered or unexported fields
}

type TexprNode = exprNode

type TraceStmt struct {
	Stmt   StmtNode
	Format string
	// contains filtered or unexported fields
}

type TrimDirectionType int

type TruncateTableStmt struct {
	Table *TableName
	// contains filtered or unexported fields
}

type TypeOpt struct {
	IsUnsigned bool
	IsZerofill bool
}

type UnaryOperationExpr struct {

	// Op is the operator opcode.
	Op opcode.Op
	// V is the unary expression.
	V ExprNode
	// contains filtered or unexported fields
}

type UnionSelectList struct {
	Selects []*SelectStmt
	// contains filtered or unexported fields
}

type UnionStmt struct {
	SelectList *UnionSelectList
	OrderBy    *OrderByClause
	Limit      *Limit
	// contains filtered or unexported fields
}

type UpdateStmt struct {
	TableRefs     *TableRefsClause
	List          []*Assignment
	Where         ExprNode
	Order         *OrderByClause
	Limit         *Limit
	Priority      mysql.PriorityEnum
	IgnoreErr     bool
	MultipleTable bool
	TableHints    []*TableOptimizerHint
	// contains filtered or unexported fields
}

type UseStmt struct {
	DBName string
	// contains filtered or unexported fields
}

type UserSpec struct {
	User    *auth.UserIdentity
	AuthOpt *AuthOption
}

type ValueExpr interface {
	ExprNode
	SetValue(val interface{})
	GetValue() interface{}
	GetDatumString() string
	GetString() string
	GetProjectionOffset() int
	SetProjectionOffset(offset int)
}

type ValuesExpr struct {

	// Column is column name.
	Column *ColumnNameExpr
	// contains filtered or unexported fields
}

type VariableAssignment struct {
	Name     string
	Value    ExprNode
	IsGlobal bool
	IsSystem bool

	// ExtendValue is a way to store extended info.
	// VariableAssignment should be able to store information for SetCharset/SetPWD Stmt.
	// For SetCharsetStmt, Value is charset, ExtendValue is collation.
	// TODO: Use SetStmt to implement set password statement.
	ExtendValue ValueExpr
	// contains filtered or unexported fields
}

type VariableExpr struct {

	// Name is the variable name.
	Name string
	// IsGlobal indicates whether this variable is global.
	IsGlobal bool
	// IsSystem indicates whether this variable is a system variable in current session.
	IsSystem bool
	// ExplicitScope indicates whether this variable scope is set explicitly.
	ExplicitScope bool
	// Value is the variable value.
	Value ExprNode
	// contains filtered or unexported fields
}

type Visitor interface {
	// Enter is called before children nodes are visited.
	// The returned node must be the same type as the input node n.
	// skipChildren returns true means children nodes should be skipped,
	// this is useful when work is done in Enter and there is no need to visit children.
	Enter(n Node) (node Node, skipChildren bool)
	// Leave is called after children nodes have been visited.
	// The returned node's type can be different from the input node if it is a ExprNode,
	// Non-expression node must be the same type as the input node n.
	// ok returns false to stop visiting.
	Leave(n Node) (node Node, ok bool)
}

type WhenClause struct {

	// Expr is the condition expression in WhenClause.
	Expr ExprNode
	// Result is the result expression in WhenClause.
	Result ExprNode
	// contains filtered or unexported fields
}

type WildCardField struct {
	Table  model.CIStr
	Schema model.CIStr
	// contains filtered or unexported fields
}

type WindowFuncExpr struct {

	// F is the function name.
	F string
	// Args is the function args.
	Args []ExprNode
	// Distinct cannot be true for most window functions, except `max` and `min`.
	// We need to raise error if it is not allowed to be true.
	Distinct bool
	// IgnoreNull indicates how to handle null value.
	// MySQL only supports `RESPECT NULLS`, so we need to raise error if it is true.
	IgnoreNull bool
	// FromLast indicates the calculation direction of this window function.
	// MySQL only supports calculation from first, so we need to raise error if it is true.
	FromLast bool
	// Spec is the specification of this window.
	Spec WindowSpec
	// contains filtered or unexported fields
}

type WindowSpec struct {
	Name model.CIStr
	// Ref is the reference window of this specification. For example, in `w2 as (w1 order by a)`,
	// the definition of `w2` references `w1`.
	Ref model.CIStr

	PartitionBy *PartitionByClause
	OrderBy     *OrderByClause
	Frame       *FrameClause
	// contains filtered or unexported fields
}