Documentation ¶
Overview ¶
Package ast is the abstract syntax tree parsed from a SQL statement by parser. It can be analysed and transformed by optimizer.
Index ¶
- Constants
- Variables
- func HasAggFlag(expr ExprNode) bool
- func HasWindowFlag(expr ExprNode) bool
- func IsReadOnly(node Node) bool
- func SetFlag(n Node)
- type AdminStmt
- type AdminStmtType
- type AggregateFuncExpr
- type AlterAlgorithm
- type AlterDatabaseStmt
- type AlterTableSpec
- type AlterTableStmt
- type AlterTableType
- type AlterUserStmt
- type AnalyzeTableStmt
- type Assignment
- type AuthOption
- type BeginStmt
- type BetweenExpr
- func (n *BetweenExpr) Accept(v Visitor) (Node, bool)
- func (n *BetweenExpr) Format(w io.Writer)
- func (en *BetweenExpr) GetFlag() uint64
- func (en *BetweenExpr) GetType() *types.FieldType
- func (n *BetweenExpr) Restore(ctx *RestoreCtx) error
- func (en *BetweenExpr) SetFlag(flag uint64)
- func (en *BetweenExpr) SetType(tp *types.FieldType)
- type BinaryOperationExpr
- func (n *BinaryOperationExpr) Accept(v Visitor) (Node, bool)
- func (n *BinaryOperationExpr) Format(w io.Writer)
- func (en *BinaryOperationExpr) GetFlag() uint64
- func (en *BinaryOperationExpr) GetType() *types.FieldType
- func (n *BinaryOperationExpr) Restore(ctx *RestoreCtx) error
- func (en *BinaryOperationExpr) SetFlag(flag uint64)
- func (en *BinaryOperationExpr) SetType(tp *types.FieldType)
- type BinlogStmt
- type BoundType
- type ByItem
- type CaseExpr
- func (n *CaseExpr) Accept(v Visitor) (Node, bool)
- func (n *CaseExpr) Format(w io.Writer)
- func (en *CaseExpr) GetFlag() uint64
- func (en *CaseExpr) GetType() *types.FieldType
- func (n *CaseExpr) Restore(ctx *RestoreCtx) error
- func (en *CaseExpr) SetFlag(flag uint64)
- func (en *CaseExpr) SetType(tp *types.FieldType)
- type CastFunctionType
- type ChangeStmt
- type CharsetOpt
- type ColumnDef
- type ColumnName
- type ColumnNameExpr
- func (n *ColumnNameExpr) Accept(v Visitor) (Node, bool)
- func (n *ColumnNameExpr) Format(w io.Writer)
- func (en *ColumnNameExpr) GetFlag() uint64
- func (en *ColumnNameExpr) GetType() *types.FieldType
- func (n *ColumnNameExpr) Restore(ctx *RestoreCtx) error
- func (en *ColumnNameExpr) SetFlag(flag uint64)
- func (en *ColumnNameExpr) SetType(tp *types.FieldType)
- type ColumnNameOrUserVar
- type ColumnOption
- type ColumnOptionType
- type ColumnPosition
- type ColumnPositionType
- type CommitStmt
- type CompareSubqueryExpr
- func (n *CompareSubqueryExpr) Accept(v Visitor) (Node, bool)
- func (n *CompareSubqueryExpr) Format(w io.Writer)
- func (en *CompareSubqueryExpr) GetFlag() uint64
- func (en *CompareSubqueryExpr) GetType() *types.FieldType
- func (n *CompareSubqueryExpr) Restore(ctx *RestoreCtx) error
- func (en *CompareSubqueryExpr) SetFlag(flag uint64)
- func (en *CompareSubqueryExpr) SetType(tp *types.FieldType)
- type Constraint
- type ConstraintType
- type CreateBindingStmt
- type CreateDatabaseStmt
- type CreateIndexStmt
- type CreateTableStmt
- type CreateUserStmt
- type CreateViewStmt
- type DDLNode
- type DMLNode
- type DatabaseOption
- type DatabaseOptionType
- type DateArithType
- type DeallocateStmt
- type DefaultExpr
- func (n *DefaultExpr) Accept(v Visitor) (Node, bool)
- func (n *DefaultExpr) Format(w io.Writer)
- func (en *DefaultExpr) GetFlag() uint64
- func (en *DefaultExpr) GetType() *types.FieldType
- func (n *DefaultExpr) Restore(ctx *RestoreCtx) error
- func (en *DefaultExpr) SetFlag(flag uint64)
- func (en *DefaultExpr) SetType(tp *types.FieldType)
- type DeleteStmt
- type DeleteTableList
- type DoStmt
- type DropBindingStmt
- type DropDatabaseStmt
- type DropIndexStmt
- type DropStatsStmt
- type DropTableStmt
- type DropUserStmt
- type ExecuteStmt
- type ExistsSubqueryExpr
- func (n *ExistsSubqueryExpr) Accept(v Visitor) (Node, bool)
- func (n *ExistsSubqueryExpr) Format(w io.Writer)
- func (en *ExistsSubqueryExpr) GetFlag() uint64
- func (en *ExistsSubqueryExpr) GetType() *types.FieldType
- func (n *ExistsSubqueryExpr) Restore(ctx *RestoreCtx) error
- func (en *ExistsSubqueryExpr) SetFlag(flag uint64)
- func (en *ExistsSubqueryExpr) SetType(tp *types.FieldType)
- type ExplainForStmt
- type ExplainStmt
- type ExprNode
- type FieldItem
- type FieldList
- type FieldsClause
- type FloatOpt
- type FlushStmt
- type FlushStmtType
- type FrameBound
- type FrameClause
- type FrameExtent
- type FrameType
- type FuncCallExpr
- type FuncCastExpr
- type FuncNode
- type GrantLevel
- type GrantLevelType
- type GrantRoleStmt
- type GrantStmt
- type GroupByClause
- type HandleRange
- type HavingClause
- type HintTable
- type Ident
- type IndexColName
- type IndexHint
- type IndexHintScope
- type IndexHintType
- type IndexOption
- type InsertStmt
- type IsNullExpr
- func (n *IsNullExpr) Accept(v Visitor) (Node, bool)
- func (n *IsNullExpr) Format(w io.Writer)
- func (en *IsNullExpr) GetFlag() uint64
- func (en *IsNullExpr) GetType() *types.FieldType
- func (n *IsNullExpr) Restore(ctx *RestoreCtx) error
- func (en *IsNullExpr) SetFlag(flag uint64)
- func (en *IsNullExpr) SetType(tp *types.FieldType)
- type IsTruthExpr
- func (n *IsTruthExpr) Accept(v Visitor) (Node, bool)
- func (n *IsTruthExpr) Format(w io.Writer)
- func (en *IsTruthExpr) GetFlag() uint64
- func (en *IsTruthExpr) GetType() *types.FieldType
- func (n *IsTruthExpr) Restore(ctx *RestoreCtx) error
- func (en *IsTruthExpr) SetFlag(flag uint64)
- func (en *IsTruthExpr) SetType(tp *types.FieldType)
- type Join
- type JoinType
- type KillStmt
- type Limit
- type LinesClause
- type LoadDataStmt
- type LoadStatsStmt
- type LockType
- type MatchType
- type MaxValueExpr
- func (n *MaxValueExpr) Accept(v Visitor) (Node, bool)
- func (n *MaxValueExpr) Format(w io.Writer)
- func (en *MaxValueExpr) GetFlag() uint64
- func (en *MaxValueExpr) GetType() *types.FieldType
- func (n *MaxValueExpr) Restore(ctx *RestoreCtx) error
- func (en *MaxValueExpr) SetFlag(flag uint64)
- func (en *MaxValueExpr) SetType(tp *types.FieldType)
- type Node
- type ObjectTypeType
- type OnCondition
- type OnDeleteOpt
- type OnDuplicateKeyHandlingType
- type OnUpdateOpt
- type OptBinary
- type OrderByClause
- type ParamMarkerExpr
- type ParenthesesExpr
- func (n *ParenthesesExpr) Accept(v Visitor) (Node, bool)
- func (n *ParenthesesExpr) Format(w io.Writer)
- func (en *ParenthesesExpr) GetFlag() uint64
- func (en *ParenthesesExpr) GetType() *types.FieldType
- func (n *ParenthesesExpr) Restore(ctx *RestoreCtx) error
- func (en *ParenthesesExpr) SetFlag(flag uint64)
- func (en *ParenthesesExpr) SetType(tp *types.FieldType)
- type PartitionByClause
- type PartitionDefinition
- type PartitionDefinitionClause
- type PartitionDefinitionClauseHistory
- type PartitionDefinitionClauseIn
- type PartitionDefinitionClauseLessThan
- type PartitionDefinitionClauseNone
- type PartitionMethod
- type PartitionOptions
- type PasswordOrLockOption
- type PatternInExpr
- func (n *PatternInExpr) Accept(v Visitor) (Node, bool)
- func (n *PatternInExpr) Format(w io.Writer)
- func (en *PatternInExpr) GetFlag() uint64
- func (en *PatternInExpr) GetType() *types.FieldType
- func (n *PatternInExpr) Restore(ctx *RestoreCtx) error
- func (en *PatternInExpr) SetFlag(flag uint64)
- func (en *PatternInExpr) SetType(tp *types.FieldType)
- type PatternLikeExpr
- func (n *PatternLikeExpr) Accept(v Visitor) (Node, bool)
- func (n *PatternLikeExpr) Format(w io.Writer)
- func (en *PatternLikeExpr) GetFlag() uint64
- func (en *PatternLikeExpr) GetType() *types.FieldType
- func (n *PatternLikeExpr) Restore(ctx *RestoreCtx) error
- func (en *PatternLikeExpr) SetFlag(flag uint64)
- func (en *PatternLikeExpr) SetType(tp *types.FieldType)
- type PatternRegexpExpr
- func (n *PatternRegexpExpr) Accept(v Visitor) (Node, bool)
- func (n *PatternRegexpExpr) Format(w io.Writer)
- func (en *PatternRegexpExpr) GetFlag() uint64
- func (en *PatternRegexpExpr) GetType() *types.FieldType
- func (n *PatternRegexpExpr) Restore(ctx *RestoreCtx) error
- func (en *PatternRegexpExpr) SetFlag(flag uint64)
- func (en *PatternRegexpExpr) SetType(tp *types.FieldType)
- type PositionExpr
- func (n *PositionExpr) Accept(v Visitor) (Node, bool)
- func (n *PositionExpr) Format(w io.Writer)
- func (en *PositionExpr) GetFlag() uint64
- func (en *PositionExpr) GetType() *types.FieldType
- func (n *PositionExpr) Restore(ctx *RestoreCtx) error
- func (en *PositionExpr) SetFlag(flag uint64)
- func (en *PositionExpr) SetType(tp *types.FieldType)
- type PrepareStmt
- type Prepared
- type PrivElem
- type RecoverTableStmt
- type ReferOptionType
- type ReferenceDef
- type RenameTableStmt
- type ResourceOption
- type ResultField
- type ResultSetNode
- type RevokeRoleStmt
- type RevokeStmt
- type RollbackStmt
- type RowExpr
- func (n *RowExpr) Accept(v Visitor) (Node, bool)
- func (n *RowExpr) Format(w io.Writer)
- func (en *RowExpr) GetFlag() uint64
- func (en *RowExpr) GetType() *types.FieldType
- func (n *RowExpr) Restore(ctx *RestoreCtx) error
- func (en *RowExpr) SetFlag(flag uint64)
- func (en *RowExpr) SetType(tp *types.FieldType)
- type SelectField
- type SelectLockType
- type SelectStmt
- type SelectStmtOpts
- type SensitiveStmtNode
- type SetDefaultRoleStmt
- type SetPwdStmt
- type SetRoleStmt
- type SetRoleStmtType
- type SetStmt
- type ShowSlow
- type ShowSlowKind
- type ShowSlowType
- type ShowStmt
- type ShowStmtType
- type ShutdownStmt
- type SplitOption
- type SplitRegionStmt
- type SplitSyntaxOption
- type StmtNode
- type SubPartitionDefinition
- type SubqueryExpr
- func (n *SubqueryExpr) Accept(v Visitor) (Node, bool)
- func (n *SubqueryExpr) Format(w io.Writer)
- func (en *SubqueryExpr) GetFlag() uint64
- func (en *SubqueryExpr) GetType() *types.FieldType
- func (n *SubqueryExpr) Restore(ctx *RestoreCtx) error
- func (en *SubqueryExpr) SetFlag(flag uint64)
- func (en *SubqueryExpr) SetType(tp *types.FieldType)
- type TLSOption
- type TableName
- type TableOptimizerHint
- type TableOption
- type TableOptionType
- type TableRefsClause
- type TableSource
- type TableToTable
- type TexprNode
- type TraceStmt
- type TrimDirectionType
- type TruncateTableStmt
- type TypeOpt
- type UnaryOperationExpr
- func (n *UnaryOperationExpr) Accept(v Visitor) (Node, bool)
- func (n *UnaryOperationExpr) Format(w io.Writer)
- func (en *UnaryOperationExpr) GetFlag() uint64
- func (en *UnaryOperationExpr) GetType() *types.FieldType
- func (n *UnaryOperationExpr) Restore(ctx *RestoreCtx) error
- func (en *UnaryOperationExpr) SetFlag(flag uint64)
- func (en *UnaryOperationExpr) SetType(tp *types.FieldType)
- type UnionSelectList
- type UnionStmt
- type UpdateStmt
- type UseStmt
- type UserSpec
- type ValueExpr
- type ValuesExpr
- func (n *ValuesExpr) Accept(v Visitor) (Node, bool)
- func (n *ValuesExpr) Format(w io.Writer)
- func (en *ValuesExpr) GetFlag() uint64
- func (en *ValuesExpr) GetType() *types.FieldType
- func (n *ValuesExpr) Restore(ctx *RestoreCtx) error
- func (en *ValuesExpr) SetFlag(flag uint64)
- func (en *ValuesExpr) SetType(tp *types.FieldType)
- type VariableAssignment
- type VariableExpr
- func (n *VariableExpr) Accept(v Visitor) (Node, bool)
- func (n *VariableExpr) Format(w io.Writer)
- func (en *VariableExpr) GetFlag() uint64
- func (en *VariableExpr) GetType() *types.FieldType
- func (n *VariableExpr) Restore(ctx *RestoreCtx) error
- func (en *VariableExpr) SetFlag(flag uint64)
- func (en *VariableExpr) SetType(tp *types.FieldType)
- type Visitor
- type WhenClause
- type WildCardField
- type WindowFuncExpr
- type WindowSpec
Constants ¶
const ( FlagConstant uint64 = 0 FlagHasParamMarker uint64 = 1 << iota FlagHasFunc FlagHasReference FlagHasAggregateFunc FlagHasSubquery FlagHasVariable FlagHasDefault FlagPreEvaluated FlagHasWindowFunc )
Flags indicates whether an expression contains certain types of expression.
const ( RowFormatDefault uint64 = iota + 1 RowFormatDynamic RowFormatFixed RowFormatCompressed RowFormatRedundant RowFormatCompact TokuDBRowFormatDefault TokuDBRowFormatFast TokuDBRowFormatSmall TokuDBRowFormatZlib TokuDBRowFormatQuickLZ TokuDBRowFormatLzma TokuDBRowFormatSnappy TokuDBRowFormatUncompressed )
RowFormat types
const ( Terminated = iota Enclosed Escaped )
const ( ShowNone = iota ShowEngines ShowDatabases ShowTables ShowTableStatus ShowColumns ShowWarnings ShowCharset ShowVariables ShowStatus ShowCollation ShowCreateTable ShowCreateView ShowCreateUser ShowGrants ShowTriggers ShowProcedureStatus ShowIndex ShowProcessList ShowCreateDatabase ShowEvents ShowStatsMeta ShowStatsHistograms ShowStatsBuckets ShowStatsHealthy ShowPlugins ShowProfile ShowProfiles ShowMasterStatus ShowPrivileges ShowErrors ShowBindings ShowPumpStatus ShowDrainerStatus ShowOpenTables ShowAnalyzeStatus ShowRegions )
Show statement types.
const ( ProfileTypeInvalid = iota ProfileTypeCPU ProfileTypeMemory ProfileTypeBlockIo ProfileTypeContextSwitch ProfileTypePageFaults ProfileTypeIpc ProfileTypeSwaps ProfileTypeSource ProfileTypeAll )
const ( Rows = iota Ranges Groups )
Window function frame types. MySQL only supports `ROWS` and `RANGES`.
const ( Following = iota Preceding CurrentRow )
Frame bound types.
const ( LogicAnd = "and" Cast = "cast" LeftShift = "leftshift" RightShift = "rightshift" LogicOr = "or" GE = "ge" LE = "le" EQ = "eq" NE = "ne" LT = "lt" GT = "gt" Plus = "plus" Minus = "minus" And = "bitand" Or = "bitor" Mod = "mod" Xor = "bitxor" Div = "div" Mul = "mul" UnaryNot = "not" // Avoid name conflict with Not in github/pingcap/check. BitNeg = "bitneg" IntDiv = "intdiv" LogicXor = "xor" NullEQ = "nulleq" UnaryPlus = "unaryplus" UnaryMinus = "unaryminus" In = "in" Like = "like" Case = "case" Regexp = "regexp" IsNull = "isnull" IsTruth = "istrue" // Avoid name conflict with IsTrue in github/pingcap/check. IsFalsity = "isfalse" // Avoid name conflict with IsFalse in github/pingcap/check. RowFunc = "row" SetVar = "setvar" GetVar = "getvar" Values = "values" BitCount = "bit_count" GetParam = "getparam" // common functions Coalesce = "coalesce" Greatest = "greatest" Least = "least" Interval = "interval" // math functions Abs = "abs" Acos = "acos" Asin = "asin" Atan = "atan" Atan2 = "atan2" Ceil = "ceil" Ceiling = "ceiling" Conv = "conv" Cos = "cos" Cot = "cot" CRC32 = "crc32" Degrees = "degrees" Exp = "exp" Floor = "floor" Ln = "ln" Log = "log" Log2 = "log2" Log10 = "log10" PI = "pi" Pow = "pow" Power = "power" Radians = "radians" Rand = "rand" Round = "round" Sign = "sign" Sin = "sin" Sqrt = "sqrt" Tan = "tan" Truncate = "truncate" // time functions AddDate = "adddate" AddTime = "addtime" ConvertTz = "convert_tz" Curdate = "curdate" CurrentDate = "current_date" CurrentTime = "current_time" CurrentTimestamp = "current_timestamp" Curtime = "curtime" Date = "date" DateLiteral = "dateliteral" DateAdd = "date_add" DateFormat = "date_format" DateSub = "date_sub" DateDiff = "datediff" Day = "day" DayName = "dayname" DayOfMonth = "dayofmonth" DayOfWeek = "dayofweek" DayOfYear = "dayofyear" Extract = "extract" FromDays = "from_days" FromUnixTime = "from_unixtime" GetFormat = "get_format" Hour = "hour" LocalTime = "localtime" LocalTimestamp = "localtimestamp" MakeDate = "makedate" MakeTime = "maketime" MicroSecond = "microsecond" Minute = "minute" Month = "month" MonthName = "monthname" Now = "now" PeriodAdd = "period_add" PeriodDiff = "period_diff" Quarter = "quarter" SecToTime = "sec_to_time" Second = "second" StrToDate = "str_to_date" SubDate = "subdate" SubTime = "subtime" Sysdate = "sysdate" Time = "time" TimeLiteral = "timeliteral" TimeFormat = "time_format" TimeToSec = "time_to_sec" TimeDiff = "timediff" Timestamp = "timestamp" TimestampLiteral = "timestampliteral" TimestampAdd = "timestampadd" TimestampDiff = "timestampdiff" ToDays = "to_days" ToSeconds = "to_seconds" UnixTimestamp = "unix_timestamp" UTCDate = "utc_date" UTCTime = "utc_time" UTCTimestamp = "utc_timestamp" Week = "week" Weekday = "weekday" WeekOfYear = "weekofyear" Year = "year" YearWeek = "yearweek" LastDay = "last_day" TiDBParseTso = "tidb_parse_tso" // string functions ASCII = "ascii" Bin = "bin" Concat = "concat" ConcatWS = "concat_ws" Convert = "convert" Elt = "elt" ExportSet = "export_set" Field = "field" Format = "format" FromBase64 = "from_base64" InsertFunc = "insert_func" Instr = "instr" Lcase = "lcase" Left = "left" Length = "length" LoadFile = "load_file" Locate = "locate" Lower = "lower" Lpad = "lpad" LTrim = "ltrim" MakeSet = "make_set" Mid = "mid" Oct = "oct" Ord = "ord" Position = "position" Quote = "quote" Repeat = "repeat" Replace = "replace" Reverse = "reverse" Right = "right" RTrim = "rtrim" Space = "space" Strcmp = "strcmp" Substring = "substring" Substr = "substr" SubstringIndex = "substring_index" ToBase64 = "to_base64" Trim = "trim" Upper = "upper" Ucase = "ucase" Hex = "hex" Unhex = "unhex" Rpad = "rpad" BitLength = "bit_length" CharFunc = "char_func" CharLength = "char_length" CharacterLength = "character_length" FindInSet = "find_in_set" // information functions Benchmark = "benchmark" Charset = "charset" Coercibility = "coercibility" Collation = "collation" ConnectionID = "connection_id" CurrentUser = "current_user" CurrentRole = "current_role" Database = "database" FoundRows = "found_rows" LastInsertId = "last_insert_id" RowCount = "row_count" Schema = "schema" SessionUser = "session_user" SystemUser = "system_user" User = "user" Version = "version" TiDBVersion = "tidb_version" TiDBIsDDLOwner = "tidb_is_ddl_owner" TiDBDecodePlan = "tidb_decode_plan" // control functions If = "if" Ifnull = "ifnull" Nullif = "nullif" // miscellaneous functions AnyValue = "any_value" DefaultFunc = "default_func" InetAton = "inet_aton" InetNtoa = "inet_ntoa" Inet6Aton = "inet6_aton" Inet6Ntoa = "inet6_ntoa" IsFreeLock = "is_free_lock" IsIPv4 = "is_ipv4" IsIPv4Compat = "is_ipv4_compat" IsIPv4Mapped = "is_ipv4_mapped" IsIPv6 = "is_ipv6" IsUsedLock = "is_used_lock" MasterPosWait = "master_pos_wait" NameConst = "name_const" ReleaseAllLocks = "release_all_locks" Sleep = "sleep" UUID = "uuid" UUIDShort = "uuid_short" // get_lock() and release_lock() is parsed but do nothing. // It is used for preventing error in Ruby's activerecord migrations. GetLock = "get_lock" ReleaseLock = "release_lock" // encryption and compression functions AesDecrypt = "aes_decrypt" AesEncrypt = "aes_encrypt" Compress = "compress" Decode = "decode" DesDecrypt = "des_decrypt" DesEncrypt = "des_encrypt" Encode = "encode" Encrypt = "encrypt" MD5 = "md5" OldPassword = "old_password" PasswordFunc = "password_func" RandomBytes = "random_bytes" SHA1 = "sha1" SHA = "sha" SHA2 = "sha2" Uncompress = "uncompress" UncompressedLength = "uncompressed_length" ValidatePasswordStrength = "validate_password_strength" // json functions JSONType = "json_type" JSONExtract = "json_extract" JSONUnquote = "json_unquote" JSONArray = "json_array" JSONObject = "json_object" JSONMerge = "json_merge" JSONSet = "json_set" JSONInsert = "json_insert" JSONReplace = "json_replace" JSONRemove = "json_remove" JSONContains = "json_contains" JSONContainsPath = "json_contains_path" JSONValid = "json_valid" JSONArrayAppend = "json_array_append" JSONArrayInsert = "json_array_insert" JSONMergePatch = "json_merge_patch" JSONMergePreserve = "json_merge_preserve" JSONPretty = "json_pretty" JSONQuote = "json_quote" JSONSearch = "json_search" JSONStorageSize = "json_storage_size" JSONDepth = "json_depth" JSONKeys = "json_keys" JSONLength = "json_length" )
List scalar function names.
const ( // AggFuncCount is the name of Count function. AggFuncCount = "count" // AggFuncSum is the name of Sum function. AggFuncSum = "sum" // AggFuncAvg is the name of Avg function. AggFuncAvg = "avg" // AggFuncFirstRow is the name of FirstRowColumn function. AggFuncFirstRow = "firstrow" // AggFuncMax is the name of max function. AggFuncMax = "max" // AggFuncMin is the name of min function. AggFuncMin = "min" // AggFuncGroupConcat is the name of group_concat function. AggFuncGroupConcat = "group_concat" // AggFuncBitOr is the name of bit_or function. AggFuncBitOr = "bit_or" // AggFuncBitXor is the name of bit_xor function. AggFuncBitXor = "bit_xor" // AggFuncBitAnd is the name of bit_and function. AggFuncBitAnd = "bit_and" // AggFuncVarPop is the name of var_pop function AggFuncVarPop = "var_pop" // AggFuncVarSamp is the name of var_samp function AggFuncVarSamp = "var_samp" // AggFuncStddevPop is the name of stddev_pop function AggFuncStddevPop = "stddev_pop" // AggFuncStddevSamp is the name of stddev_samp function AggFuncStddevSamp = "stddev_samp" )
const ( // WindowFuncRowNumber is the name of row_number function. WindowFuncRowNumber = "row_number" // WindowFuncRank is the name of rank function. WindowFuncRank = "rank" // WindowFuncDenseRank is the name of dense_rank function. WindowFuncDenseRank = "dense_rank" // WindowFuncCumeDist is the name of cume_dist function. WindowFuncCumeDist = "cume_dist" // WindowFuncPercentRank is the name of percent_rank function. WindowFuncPercentRank = "percent_rank" // WindowFuncNtile is the name of ntile function. WindowFuncNtile = "ntile" // WindowFuncLead is the name of lead function. WindowFuncLead = "lead" // WindowFuncLag is the name of lag function. WindowFuncLag = "lag" // WindowFuncFirstValue is the name of first_value function. WindowFuncFirstValue = "first_value" // WindowFuncLastValue is the name of last_value function. WindowFuncLastValue = "last_value" // WindowFuncNthValue is the name of nth_value function. WindowFuncNthValue = "nth_value" )
const ( ReadCommitted = "READ-COMMITTED" ReadUncommitted = "READ-UNCOMMITTED" Serializable = "SERIALIZABLE" RepeatableRead = "REPEATABLE-READ" // Valid formats for explain statement. ExplainFormatROW = "row" ExplainFormatDOT = "dot" PumpType = "PUMP" DrainerType = "DRAINER" )
Isolation level constants.
const ( Optimistic = "OPTIMISTIC" Pessimistic = "PESSIMISTIC" )
Transaction mode constants.
const ( TslNone = iota Ssl X509 Cipher Issuer Subject )
const ( MaxQueriesPerHour = iota + 1 MaxUpdatesPerHour MaxConnectionsPerHour MaxUserConnections )
const ( PasswordExpire = iota + 1 PasswordExpireDefault PasswordExpireNever PasswordExpireInterval Lock Unlock )
const ( AdminShowDDL = iota + 1 AdminCheckTable AdminShowDDLJobs AdminCancelDDLJobs AdminCheckIndex AdminRecoverIndex AdminCleanupIndex AdminCheckIndexRange AdminShowDDLJobQueries AdminChecksumTable AdminShowSlow AdminShowNextRowID AdminReloadExprPushdownBlacklist AdminReloadOptRuleBlacklist AdminPluginDisable AdminPluginEnable )
Admin statement types.
const ( // SetNames is the const for set names/charset stmt. // If VariableAssignment.Name == Names, it should be set names/charset stmt. SetNames = "SetNAMES" )
Variables ¶
var ( ErrNoParts = terror.ClassDDL.NewStd(mysql.ErrNoParts) ErrPartitionColumnList = terror.ClassDDL.NewStd(mysql.ErrPartitionColumnList) ErrPartitionRequiresValues = terror.ClassDDL.NewStd(mysql.ErrPartitionRequiresValues) ErrPartitionsMustBeDefined = terror.ClassDDL.NewStd(mysql.ErrPartitionsMustBeDefined) ErrPartitionWrongNoPart = terror.ClassDDL.NewStd(mysql.ErrPartitionWrongNoPart) ErrPartitionWrongNoSubpart = terror.ClassDDL.NewStd(mysql.ErrPartitionWrongNoSubpart) ErrPartitionWrongValues = terror.ClassDDL.NewStd(mysql.ErrPartitionWrongValues) ErrRowSinglePartitionField = terror.ClassDDL.NewStd(mysql.ErrRowSinglePartitionField) ErrSubpartition = terror.ClassDDL.NewStd(mysql.ErrSubpartition) ErrSystemVersioningWrongPartitions = terror.ClassDDL.NewStd(mysql.ErrSystemVersioningWrongPartitions) ErrTooManyValues = terror.ClassDDL.NewStd(mysql.ErrTooManyValues) ErrWrongPartitionTypeExpectedSystemTime = terror.ClassDDL.NewStd(mysql.ErrWrongPartitionTypeExpectedSystemTime) )
var ( // ExplainFormats stores the valid formats for explain statement, used by validator. ExplainFormats = []string{ ExplainFormatROW, ExplainFormatDOT, } )
var NewBitLiteral func(string) (interface{}, error)
NewBitLiteral creates a types.BitLiteral value, it's provided by parser driver.
var NewDecimal func(string) (interface{}, error)
NewDecimal creates a types.Decimal value, it's provided by parser driver.
var NewHexLiteral func(string) (interface{}, error)
NewHexLiteral creates a types.HexLiteral value, it's provided by parser driver.
var NewParamMarkerExpr func(offset int) ParamMarkerExpr
NewParamMarkerExpr creates a ParamMarkerExpr.
var NewValueExpr func(interface{}) ValueExpr
NewValueExpr creates a ValueExpr with value, and sets default field type.
Functions ¶
func HasAggFlag ¶
HasAggFlag checks if the expr contains FlagHasAggregateFunc.
func HasWindowFlag ¶
func IsReadOnly ¶
IsReadOnly checks whether the input ast is readOnly.
Types ¶
type AdminStmt ¶
type AdminStmt struct { Tp AdminStmtType Index string Tables []*TableName JobIDs []int64 JobNumber int64 HandleRanges []HandleRange ShowSlow *ShowSlow Plugins []string // contains filtered or unexported fields }
AdminStmt is the struct for Admin statement.
type AggregateFuncExpr ¶
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 }
AggregateFuncExpr represents aggregate function expression.
func (*AggregateFuncExpr) Accept ¶
func (n *AggregateFuncExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*AggregateFuncExpr) Format ¶
func (n *AggregateFuncExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*AggregateFuncExpr) Restore ¶
func (n *AggregateFuncExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type AlterAlgorithm ¶
type AlterAlgorithm byte
AlterAlgorithm is the algorithm of the DDL operations. See https://dev.mysql.com/doc/refman/8.0/en/alter-table.html#alter-table-performance.
const ( AlterAlgorithmDefault AlterAlgorithm = iota AlterAlgorithmCopy AlterAlgorithmInplace AlterAlgorithmInstant )
DDL alter algorithms. For now, TiDB only supported inplace and instance algorithms. If the user specify `copy`, will get an error.
func (AlterAlgorithm) String ¶
func (a AlterAlgorithm) String() string
type AlterDatabaseStmt ¶
type AlterDatabaseStmt struct { Name string AlterDefaultDatabase bool Options []*DatabaseOption // contains filtered or unexported fields }
AlterDatabaseStmt is a statement to change the structure of a database. See https://dev.mysql.com/doc/refman/5.7/en/alter-database.html
func (*AlterDatabaseStmt) Accept ¶
func (n *AlterDatabaseStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*AlterDatabaseStmt) Restore ¶
func (n *AlterDatabaseStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type AlterTableSpec ¶
type AlterTableSpec struct { Tp AlterTableType Name string Constraint *Constraint Options []*TableOption NewTable *TableName NewColumns []*ColumnDef OldColumnName *ColumnName Position *ColumnPosition LockType LockType Algorithm AlterAlgorithm Comment string FromKey model.CIStr ToKey model.CIStr Partition *PartitionOptions PartitionNames []model.CIStr PartDefinitions []*PartitionDefinition Num uint64 // contains filtered or unexported fields }
AlterTableSpec represents alter table specification.
func (*AlterTableSpec) Accept ¶
func (n *AlterTableSpec) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*AlterTableSpec) Restore ¶
func (n *AlterTableSpec) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type AlterTableStmt ¶
type AlterTableStmt struct { Table *TableName Specs []*AlterTableSpec // contains filtered or unexported fields }
AlterTableStmt is a statement to change the structure of a table. See https://dev.mysql.com/doc/refman/5.7/en/alter-table.html
func (*AlterTableStmt) Accept ¶
func (n *AlterTableStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*AlterTableStmt) Restore ¶
func (n *AlterTableStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type AlterTableType ¶
type AlterTableType int
AlterTableType is the type for AlterTableSpec.
const ( AlterTableOption AlterTableType = iota + 1 AlterTableAddColumns AlterTableAddConstraint AlterTableDropColumn AlterTableDropPrimaryKey AlterTableDropIndex AlterTableDropForeignKey AlterTableModifyColumn AlterTableChangeColumn AlterTableRenameTable AlterTableAlterColumn AlterTableLock AlterTableAlgorithm AlterTableRenameIndex AlterTableForce AlterTableAddPartitions AlterTableCoalescePartitions AlterTableDropPartition AlterTableTruncatePartition AlterTablePartition AlterTableEnableKeys AlterTableDisableKeys )
AlterTable types.
type AlterUserStmt ¶
type AlterUserStmt struct { IfExists bool CurrentAuth *AuthOption Specs []*UserSpec TLSOptions []*TLSOption ResourceOptions []*ResourceOption PasswordOrLockOptions []*PasswordOrLockOption // contains filtered or unexported fields }
AlterUserStmt modifies user account. See https://dev.mysql.com/doc/refman/5.7/en/alter-user.html
func (*AlterUserStmt) Accept ¶
func (n *AlterUserStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*AlterUserStmt) Restore ¶
func (n *AlterUserStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
func (*AlterUserStmt) SecureText ¶
func (n *AlterUserStmt) SecureText() string
SecureText implements SensitiveStatement interface.
type AnalyzeTableStmt ¶
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 Incremental bool // contains filtered or unexported fields }
AnalyzeTableStmt is used to create table statistics.
func (*AnalyzeTableStmt) Accept ¶
func (n *AnalyzeTableStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*AnalyzeTableStmt) Restore ¶
func (n *AnalyzeTableStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type Assignment ¶
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 }
Assignment is the expression for assignment, like a = 1.
func (*Assignment) Accept ¶
func (n *Assignment) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*Assignment) Restore ¶
func (n *Assignment) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type AuthOption ¶
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 }
AuthOption is used for parsing create use statement.
func (*AuthOption) Restore ¶
func (n *AuthOption) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type BeginStmt ¶
type BeginStmt struct { Mode string // contains filtered or unexported fields }
BeginStmt is a statement to start a new transaction. See https://dev.mysql.com/doc/refman/5.7/en/commit.html
type BetweenExpr ¶
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 }
BetweenExpr is for "between and" or "not between and" expression.
func (*BetweenExpr) Accept ¶
func (n *BetweenExpr) Accept(v Visitor) (Node, bool)
Accept implements Node interface.
func (*BetweenExpr) Format ¶
func (n *BetweenExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*BetweenExpr) GetFlag ¶
func (en *BetweenExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*BetweenExpr) Restore ¶
func (n *BetweenExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type BinaryOperationExpr ¶
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 }
BinaryOperationExpr is for binary operation like `1 + 1`, `1 - 1`, etc.
func (*BinaryOperationExpr) Accept ¶
func (n *BinaryOperationExpr) Accept(v Visitor) (Node, bool)
Accept implements Node interface.
func (*BinaryOperationExpr) Format ¶
func (n *BinaryOperationExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*BinaryOperationExpr) GetFlag ¶
func (en *BinaryOperationExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*BinaryOperationExpr) Restore ¶
func (n *BinaryOperationExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type BinlogStmt ¶
type BinlogStmt struct { Str string // contains filtered or unexported fields }
BinlogStmt is an internal-use statement. We just parse and ignore it. See http://dev.mysql.com/doc/refman/5.7/en/binlog.html
func (*BinlogStmt) Accept ¶
func (n *BinlogStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*BinlogStmt) Restore ¶
func (n *BinlogStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ByItem ¶
ByItem represents an item in order by or group by.
type CaseExpr ¶
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 }
CaseExpr is the case expression.
func (*CaseExpr) GetFlag ¶
func (en *CaseExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
type CastFunctionType ¶
type CastFunctionType int
CastFunctionType is the type for cast function.
const ( CastFunction CastFunctionType = iota + 1 CastConvertFunction CastBinaryOperator )
CastFunction types
type ChangeStmt ¶
type ChangeStmt struct { NodeType string State string NodeID string // contains filtered or unexported fields }
func (*ChangeStmt) Accept ¶
func (n *ChangeStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ChangeStmt) Restore ¶
func (n *ChangeStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
func (*ChangeStmt) SecureText ¶
func (n *ChangeStmt) SecureText() string
SecureText implements SensitiveStatement interface.
type CharsetOpt ¶
CharsetOpt is used for parsing charset option from SQL.
type ColumnDef ¶
type ColumnDef struct { Name *ColumnName Tp *types.FieldType Options []*ColumnOption // contains filtered or unexported fields }
ColumnDef is used for parsing column definition from SQL.
type ColumnName ¶
type ColumnName struct { Schema model.CIStr Table model.CIStr Name model.CIStr // contains filtered or unexported fields }
ColumnName represents column name.
func (*ColumnName) Accept ¶
func (n *ColumnName) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ColumnName) OrigColName ¶
func (n *ColumnName) OrigColName() (ret string)
OrigColName returns the full original column name.
func (*ColumnName) Restore ¶
func (n *ColumnName) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
func (*ColumnName) SetText ¶
func (n *ColumnName) SetText(text string)
SetText implements Node interface.
func (*ColumnName) String ¶
func (n *ColumnName) String() string
String implements Stringer interface.
type ColumnNameExpr ¶
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 }
ColumnNameExpr represents a column name expression.
func (*ColumnNameExpr) Accept ¶
func (n *ColumnNameExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ColumnNameExpr) Format ¶
func (n *ColumnNameExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*ColumnNameExpr) GetFlag ¶
func (en *ColumnNameExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*ColumnNameExpr) Restore ¶
func (n *ColumnNameExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ColumnNameOrUserVar ¶
type ColumnNameOrUserVar struct { ColumnName *ColumnName UserVar *VariableExpr }
type ColumnOption ¶
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 // Enforced is only for Check, default is true. Enforced bool // contains filtered or unexported fields }
ColumnOption is used for parsing column constraint info from SQL.
func (*ColumnOption) Accept ¶
func (n *ColumnOption) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ColumnOption) Restore ¶
func (n *ColumnOption) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ColumnOptionType ¶
type ColumnOptionType int
ColumnOptionType is the type for ColumnOption.
const ( ColumnOptionNoOption ColumnOptionType = iota ColumnOptionPrimaryKey ColumnOptionNotNull ColumnOptionAutoIncrement ColumnOptionDefaultValue ColumnOptionUniqKey ColumnOptionNull ColumnOptionOnUpdate // For Timestamp and Datetime only. ColumnOptionFulltext ColumnOptionComment ColumnOptionGenerated ColumnOptionReference ColumnOptionCollate ColumnOptionCheck )
ColumnOption types.
type ColumnPosition ¶
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 }
ColumnPosition represent the position of the newly added column
func (*ColumnPosition) Accept ¶
func (n *ColumnPosition) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ColumnPosition) Restore ¶
func (n *ColumnPosition) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ColumnPositionType ¶
type ColumnPositionType int
ColumnPositionType is the type for ColumnPosition.
const ( ColumnPositionNone ColumnPositionType = iota ColumnPositionFirst ColumnPositionAfter )
ColumnPosition Types
type CommitStmt ¶
type CommitStmt struct {
// contains filtered or unexported fields
}
CommitStmt is a statement to commit the current transaction. See https://dev.mysql.com/doc/refman/5.7/en/commit.html
func (*CommitStmt) Accept ¶
func (n *CommitStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*CommitStmt) Restore ¶
func (n *CommitStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type CompareSubqueryExpr ¶
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 }
CompareSubqueryExpr is the expression for "expr cmp (select ...)". See https://dev.mysql.com/doc/refman/5.7/en/comparisons-using-subqueries.html See https://dev.mysql.com/doc/refman/5.7/en/any-in-some-subqueries.html See https://dev.mysql.com/doc/refman/5.7/en/all-subqueries.html
func (*CompareSubqueryExpr) Accept ¶
func (n *CompareSubqueryExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*CompareSubqueryExpr) Format ¶
func (n *CompareSubqueryExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*CompareSubqueryExpr) GetFlag ¶
func (en *CompareSubqueryExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*CompareSubqueryExpr) Restore ¶
func (n *CompareSubqueryExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type Constraint ¶
type Constraint struct { Tp ConstraintType Name string Keys []*IndexColName // Used for PRIMARY KEY, UNIQUE, ...... Refer *ReferenceDef // Used for foreign key. Option *IndexOption // Index Options Expr ExprNode // Used for Check Enforced bool // Used for Check // contains filtered or unexported fields }
Constraint is constraint for table definition.
func (*Constraint) Accept ¶
func (n *Constraint) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*Constraint) Restore ¶
func (n *Constraint) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ConstraintType ¶
type ConstraintType int
ConstraintType is the type for Constraint.
const ( ConstraintNoConstraint ConstraintType = iota ConstraintPrimaryKey ConstraintKey ConstraintIndex ConstraintUniq ConstraintUniqKey ConstraintUniqIndex ConstraintForeignKey ConstraintFulltext ConstraintCheck )
ConstraintTypes
type CreateBindingStmt ¶
type CreateBindingStmt struct { GlobalScope bool OriginSel StmtNode HintedSel StmtNode // contains filtered or unexported fields }
CreateBindingStmt creates sql binding hint.
func (*CreateBindingStmt) Restore ¶
func (n *CreateBindingStmt) Restore(ctx *RestoreCtx) error
type CreateDatabaseStmt ¶
type CreateDatabaseStmt struct { IfNotExists bool Name string Options []*DatabaseOption // contains filtered or unexported fields }
CreateDatabaseStmt is a statement to create a database. See https://dev.mysql.com/doc/refman/5.7/en/create-database.html
func (*CreateDatabaseStmt) Accept ¶
func (n *CreateDatabaseStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*CreateDatabaseStmt) Restore ¶
func (n *CreateDatabaseStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type CreateIndexStmt ¶
type CreateIndexStmt struct { IndexName string Table *TableName Unique bool IndexColNames []*IndexColName IndexOption *IndexOption // contains filtered or unexported fields }
CreateIndexStmt is a statement to create an index. See https://dev.mysql.com/doc/refman/5.7/en/create-index.html
func (*CreateIndexStmt) Accept ¶
func (n *CreateIndexStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*CreateIndexStmt) Restore ¶
func (n *CreateIndexStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type CreateTableStmt ¶
type CreateTableStmt struct { IfNotExists bool Table *TableName ReferTable *TableName Cols []*ColumnDef Constraints []*Constraint Options []*TableOption Partition *PartitionOptions OnDuplicate OnDuplicateKeyHandlingType Select ResultSetNode // contains filtered or unexported fields }
CreateTableStmt is a statement to create a table. See https://dev.mysql.com/doc/refman/5.7/en/create-table.html
func (*CreateTableStmt) Accept ¶
func (n *CreateTableStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*CreateTableStmt) Restore ¶
func (n *CreateTableStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type CreateUserStmt ¶
type CreateUserStmt struct { IsCreateRole bool IfNotExists bool Specs []*UserSpec TLSOptions []*TLSOption ResourceOptions []*ResourceOption PasswordOrLockOptions []*PasswordOrLockOption // contains filtered or unexported fields }
CreateUserStmt creates user account. See https://dev.mysql.com/doc/refman/5.7/en/create-user.html
func (*CreateUserStmt) Accept ¶
func (n *CreateUserStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*CreateUserStmt) Restore ¶
func (n *CreateUserStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
func (*CreateUserStmt) SecureText ¶
func (n *CreateUserStmt) SecureText() string
SecureText implements SensitiveStatement interface.
type CreateViewStmt ¶
type CreateViewStmt struct { OrReplace bool ViewName *TableName Cols []model.CIStr Select StmtNode SchemaCols []model.CIStr Algorithm model.ViewAlgorithm Definer *auth.UserIdentity Security model.ViewSecurity CheckOption model.ViewCheckOption // contains filtered or unexported fields }
CreateViewStmt is a statement to create a View. See https://dev.mysql.com/doc/refman/5.7/en/create-view.html
func (*CreateViewStmt) Accept ¶
func (n *CreateViewStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*CreateViewStmt) Restore ¶
func (n *CreateViewStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type DDLNode ¶
type DDLNode interface { StmtNode // contains filtered or unexported methods }
DDLNode represents DDL statement node.
type DMLNode ¶
type DMLNode interface { StmtNode // contains filtered or unexported methods }
DMLNode represents DML statement node.
type DatabaseOption ¶
type DatabaseOption struct { Tp DatabaseOptionType Value string }
DatabaseOption represents database option.
func (*DatabaseOption) Restore ¶
func (n *DatabaseOption) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type DatabaseOptionType ¶
type DatabaseOptionType int
DatabaseOptionType is the type for database options.
const ( DatabaseOptionNone DatabaseOptionType = iota DatabaseOptionCharset DatabaseOptionCollate )
Database option types.
type DateArithType ¶
type DateArithType byte
DateArithType is type for DateArith type.
const ( // DateArithAdd is to run adddate or date_add function option. // See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_adddate // See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_date-add DateArithAdd DateArithType = iota + 1 // DateArithSub is to run subdate or date_sub function option. // See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_subdate // See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_date-sub DateArithSub )
type DeallocateStmt ¶
type DeallocateStmt struct { Name string // contains filtered or unexported fields }
DeallocateStmt is a statement to release PreparedStmt. See https://dev.mysql.com/doc/refman/5.7/en/deallocate-prepare.html
func (*DeallocateStmt) Accept ¶
func (n *DeallocateStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*DeallocateStmt) Restore ¶
func (n *DeallocateStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type DefaultExpr ¶
type DefaultExpr struct { // Name is the column name. Name *ColumnName // contains filtered or unexported fields }
DefaultExpr is the default expression using default value for a column.
func (*DefaultExpr) Accept ¶
func (n *DefaultExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*DefaultExpr) Format ¶
func (n *DefaultExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*DefaultExpr) GetFlag ¶
func (en *DefaultExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*DefaultExpr) Restore ¶
func (n *DefaultExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type DeleteStmt ¶
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 }
DeleteStmt is a statement to delete rows from table. See https://dev.mysql.com/doc/refman/5.7/en/delete.html
func (*DeleteStmt) Accept ¶
func (n *DeleteStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*DeleteStmt) Restore ¶
func (n *DeleteStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type DeleteTableList ¶
type DeleteTableList struct { Tables []*TableName // contains filtered or unexported fields }
DeleteTableList is the tablelist used in delete statement multi-table mode.
func (*DeleteTableList) Accept ¶
func (n *DeleteTableList) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*DeleteTableList) Restore ¶
func (n *DeleteTableList) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type DoStmt ¶
type DoStmt struct { Exprs []ExprNode // contains filtered or unexported fields }
DoStmt is the struct for DO statement.
type DropBindingStmt ¶
type DropBindingStmt struct { GlobalScope bool OriginSel StmtNode // contains filtered or unexported fields }
DropBindingStmt deletes sql binding hint.
func (*DropBindingStmt) Restore ¶
func (n *DropBindingStmt) Restore(ctx *RestoreCtx) error
type DropDatabaseStmt ¶
type DropDatabaseStmt struct { IfExists bool Name string // contains filtered or unexported fields }
DropDatabaseStmt is a statement to drop a database and all tables in the database. See https://dev.mysql.com/doc/refman/5.7/en/drop-database.html
func (*DropDatabaseStmt) Accept ¶
func (n *DropDatabaseStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*DropDatabaseStmt) Restore ¶
func (n *DropDatabaseStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type DropIndexStmt ¶
type DropIndexStmt struct { IfExists bool IndexName string Table *TableName // contains filtered or unexported fields }
DropIndexStmt is a statement to drop the index. See https://dev.mysql.com/doc/refman/5.7/en/drop-index.html
func (*DropIndexStmt) Accept ¶
func (n *DropIndexStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*DropIndexStmt) Restore ¶
func (n *DropIndexStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type DropStatsStmt ¶
type DropStatsStmt struct { Table *TableName // contains filtered or unexported fields }
DropStatsStmt is used to drop table statistics.
func (*DropStatsStmt) Accept ¶
func (n *DropStatsStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*DropStatsStmt) Restore ¶
func (n *DropStatsStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type DropTableStmt ¶
type DropTableStmt struct { IfExists bool Tables []*TableName IsView bool // contains filtered or unexported fields }
DropTableStmt is a statement to drop one or more tables. See https://dev.mysql.com/doc/refman/5.7/en/drop-table.html
func (*DropTableStmt) Accept ¶
func (n *DropTableStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*DropTableStmt) Restore ¶
func (n *DropTableStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type DropUserStmt ¶
type DropUserStmt struct { IfExists bool IsDropRole bool UserList []*auth.UserIdentity // contains filtered or unexported fields }
DropUserStmt creates user account. See http://dev.mysql.com/doc/refman/5.7/en/drop-user.html
func (*DropUserStmt) Accept ¶
func (n *DropUserStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*DropUserStmt) Restore ¶
func (n *DropUserStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ExecuteStmt ¶
type ExecuteStmt struct { Name string UsingVars []ExprNode ExecID uint32 // contains filtered or unexported fields }
ExecuteStmt is a statement to execute PreparedStmt. See https://dev.mysql.com/doc/refman/5.7/en/execute.html
func (*ExecuteStmt) Accept ¶
func (n *ExecuteStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ExecuteStmt) Restore ¶
func (n *ExecuteStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ExistsSubqueryExpr ¶
type ExistsSubqueryExpr struct { // Sel is the subquery, may be rewritten to other type of expression. Sel ExprNode // Not is true, the expression is "not exists". Not bool // contains filtered or unexported fields }
ExistsSubqueryExpr is the expression for "exists (select ...)". See https://dev.mysql.com/doc/refman/5.7/en/exists-and-not-exists-subqueries.html
func (*ExistsSubqueryExpr) Accept ¶
func (n *ExistsSubqueryExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ExistsSubqueryExpr) Format ¶
func (n *ExistsSubqueryExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*ExistsSubqueryExpr) GetFlag ¶
func (en *ExistsSubqueryExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*ExistsSubqueryExpr) Restore ¶
func (n *ExistsSubqueryExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ExplainForStmt ¶
type ExplainForStmt struct { Format string ConnectionID uint64 // contains filtered or unexported fields }
ExplainForStmt is a statement to provite information about how is SQL statement executeing in connection #ConnectionID See https://dev.mysql.com/doc/refman/5.7/en/explain.html
func (*ExplainForStmt) Accept ¶
func (n *ExplainForStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ExplainForStmt) Restore ¶
func (n *ExplainForStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ExplainStmt ¶
type ExplainStmt struct { Stmt StmtNode Format string Analyze bool // contains filtered or unexported fields }
ExplainStmt is a statement to provide information about how is SQL statement executed or get columns information in a table. See https://dev.mysql.com/doc/refman/5.7/en/explain.html
func (*ExplainStmt) Accept ¶
func (n *ExplainStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ExplainStmt) Restore ¶
func (n *ExplainStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ExprNode ¶
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) }
ExprNode is a node that can be evaluated. Name of implementations should have 'Expr' suffix.
type FieldList ¶
type FieldList struct { Fields []*SelectField // contains filtered or unexported fields }
FieldList represents field list in select statement.
type FieldsClause ¶
FieldsClause represents fields references clause in load data statement.
func (*FieldsClause) Restore ¶
func (n *FieldsClause) Restore(ctx *RestoreCtx) error
Restore for FieldsClause
type FloatOpt ¶
FloatOpt is used for parsing floating-point type option from SQL. See http://dev.mysql.com/doc/refman/5.7/en/floating-point-types.html
type FlushStmt ¶
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 }
FlushStmt is a statement to flush tables/privileges/optimizer costs and so on.
type FlushStmtType ¶
type FlushStmtType int
FlushStmtType is the type for FLUSH statement.
const ( FlushNone FlushStmtType = iota FlushTables FlushPrivileges FlushStatus FlushTiDBPlugin )
Flush statement types.
type FrameBound ¶
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 }
FrameBound represents frame bound.
func (*FrameBound) Accept ¶
func (n *FrameBound) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*FrameBound) Restore ¶
func (n *FrameBound) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type FrameClause ¶
type FrameClause struct { Type FrameType Extent FrameExtent // contains filtered or unexported fields }
FrameClause represents frame clause.
func (*FrameClause) Accept ¶
func (n *FrameClause) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*FrameClause) Restore ¶
func (n *FrameClause) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type FrameExtent ¶
type FrameExtent struct { Start FrameBound End FrameBound }
FrameExtent represents frame extent.
type FuncCallExpr ¶
type FuncCallExpr struct { // FnName is the function name. FnName model.CIStr // Args is the function args. Args []ExprNode // contains filtered or unexported fields }
FuncCallExpr is for function expression.
func (*FuncCallExpr) Accept ¶
func (n *FuncCallExpr) Accept(v Visitor) (Node, bool)
Accept implements Node interface.
func (*FuncCallExpr) Format ¶
func (n *FuncCallExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*FuncCallExpr) Restore ¶
func (n *FuncCallExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type FuncCastExpr ¶
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 }
FuncCastExpr is the cast function converting value to another type, e.g, cast(expr AS signed). See https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html
func (*FuncCastExpr) Accept ¶
func (n *FuncCastExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*FuncCastExpr) Format ¶
func (n *FuncCastExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*FuncCastExpr) Restore ¶
func (n *FuncCastExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type FuncNode ¶
type FuncNode interface { ExprNode // contains filtered or unexported methods }
FuncNode represents function call expression node.
type GrantLevel ¶
type GrantLevel struct { Level GrantLevelType DBName string TableName string }
GrantLevel is used for store the privilege scope.
func (*GrantLevel) Restore ¶
func (n *GrantLevel) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type GrantLevelType ¶
type GrantLevelType int
GrantLevelType is the type for grant level.
const ( // GrantLevelNone is the dummy const for default value. GrantLevelNone GrantLevelType = iota + 1 // GrantLevelGlobal means the privileges are administrative or apply to all databases on a given server. GrantLevelGlobal // GrantLevelDB means the privileges apply to all objects in a given database. GrantLevelDB // GrantLevelTable means the privileges apply to all columns in a given table. GrantLevelTable )
type GrantRoleStmt ¶
type GrantRoleStmt struct { Roles []*auth.RoleIdentity Users []*auth.UserIdentity // contains filtered or unexported fields }
GrantRoleStmt is the struct for GRANT TO statement.
func (*GrantRoleStmt) Accept ¶
func (n *GrantRoleStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*GrantRoleStmt) Restore ¶
func (n *GrantRoleStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
func (*GrantRoleStmt) SecureText ¶
func (n *GrantRoleStmt) SecureText() string
SecureText implements SensitiveStatement interface.
type GrantStmt ¶
type GrantStmt struct { Privs []*PrivElem ObjectType ObjectTypeType Level *GrantLevel Users []*UserSpec TLSOptions []*TLSOption WithGrant bool // contains filtered or unexported fields }
GrantStmt is the struct for GRANT statement.
func (*GrantStmt) SecureText ¶
SecureText implements SensitiveStatement interface.
type GroupByClause ¶
type GroupByClause struct { Items []*ByItem // contains filtered or unexported fields }
GroupByClause represents group by clause.
func (*GroupByClause) Accept ¶
func (n *GroupByClause) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*GroupByClause) Restore ¶
func (n *GroupByClause) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type HandleRange ¶
HandleRange represents a range where handle value >= Begin and < End.
type HavingClause ¶
type HavingClause struct { Expr ExprNode // contains filtered or unexported fields }
HavingClause represents having clause.
func (*HavingClause) Accept ¶
func (n *HavingClause) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*HavingClause) Restore ¶
func (n *HavingClause) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type IndexColName ¶
type IndexColName struct { Column *ColumnName Length int // contains filtered or unexported fields }
IndexColName is used for parsing index column name from SQL.
func (*IndexColName) Accept ¶
func (n *IndexColName) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*IndexColName) Restore ¶
func (n *IndexColName) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type IndexHint ¶
type IndexHint struct { IndexNames []model.CIStr HintType IndexHintType HintScope IndexHintScope }
IndexHint represents a hint for optimizer to use/ignore/force for join/order by/group by.
type IndexHintScope ¶
type IndexHintScope int
IndexHintScope is the type for index hint for join, order by or group by.
const ( HintForScan IndexHintScope = 1 HintForJoin IndexHintScope = 2 HintForOrderBy IndexHintScope = 3 HintForGroupBy IndexHintScope = 4 )
Index hint scopes.
type IndexHintType ¶
type IndexHintType int
IndexHintType is the type for index hint use, ignore or force.
const ( HintUse IndexHintType = 1 HintIgnore IndexHintType = 2 HintForce IndexHintType = 3 )
IndexHintUseType values.
type IndexOption ¶
type IndexOption struct { KeyBlockSize uint64 Tp model.IndexType Comment string // contains filtered or unexported fields }
IndexOption is the index options.
KEY_BLOCK_SIZE [=] value | index_type | WITH PARSER parser_name | COMMENT 'string'
See http://dev.mysql.com/doc/refman/5.7/en/create-table.html
func (*IndexOption) Accept ¶
func (n *IndexOption) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*IndexOption) Restore ¶
func (n *IndexOption) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type InsertStmt ¶
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 }
InsertStmt is a statement to insert new rows into an existing table. See https://dev.mysql.com/doc/refman/5.7/en/insert.html
func (*InsertStmt) Accept ¶
func (n *InsertStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*InsertStmt) Restore ¶
func (n *InsertStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type IsNullExpr ¶
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 }
IsNullExpr is the expression for null check.
func (*IsNullExpr) Accept ¶
func (n *IsNullExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*IsNullExpr) Format ¶
func (n *IsNullExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*IsNullExpr) GetFlag ¶
func (en *IsNullExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*IsNullExpr) Restore ¶
func (n *IsNullExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type IsTruthExpr ¶
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 }
IsTruthExpr is the expression for true/false check.
func (*IsTruthExpr) Accept ¶
func (n *IsTruthExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*IsTruthExpr) Format ¶
func (n *IsTruthExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*IsTruthExpr) GetFlag ¶
func (en *IsTruthExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*IsTruthExpr) Restore ¶
func (n *IsTruthExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type Join ¶
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 }
Join represents table join.
type KillStmt ¶
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 }
KillStmt is a statement to kill a query or connection.
type Limit ¶
Limit is the limit clause.
type LinesClause ¶
LinesClause represents lines references clause in load data statement.
func (*LinesClause) Restore ¶
func (n *LinesClause) Restore(ctx *RestoreCtx) error
Restore for LinesClause
type LoadDataStmt ¶
type LoadDataStmt struct { IsLocal bool Path string OnDuplicate OnDuplicateKeyHandlingType Table *TableName Columns []*ColumnName FieldsInfo *FieldsClause LinesInfo *LinesClause IgnoreLines uint64 ColumnAssignments []*Assignment ColumnsAndUserVars []*ColumnNameOrUserVar // contains filtered or unexported fields }
LoadDataStmt is a statement to load data from a specified file, then insert this rows into an existing table. See https://dev.mysql.com/doc/refman/5.7/en/load-data.html
func (*LoadDataStmt) Accept ¶
func (n *LoadDataStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*LoadDataStmt) Restore ¶
func (n *LoadDataStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type LoadStatsStmt ¶
type LoadStatsStmt struct { Path string // contains filtered or unexported fields }
LoadStatsStmt is the statement node for loading statistic.
func (*LoadStatsStmt) Accept ¶
func (n *LoadStatsStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*LoadStatsStmt) Restore ¶
func (n *LoadStatsStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type LockType ¶
type LockType byte
LockType is the type for AlterTableSpec. See https://dev.mysql.com/doc/refman/5.7/en/alter-table.html#alter-table-concurrency
type MaxValueExpr ¶
type MaxValueExpr struct {
// contains filtered or unexported fields
}
MaxValueExpr is the expression for "maxvalue" used in partition.
func (*MaxValueExpr) Accept ¶
func (n *MaxValueExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*MaxValueExpr) Format ¶
func (n *MaxValueExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*MaxValueExpr) GetFlag ¶
func (en *MaxValueExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*MaxValueExpr) Restore ¶
func (n *MaxValueExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type Node ¶
type Node interface { // Restore returns the sql text from ast tree Restore(ctx *RestoreCtx) error // 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) }
Node is the basic element of the AST. Interfaces embed Node should have 'Node' name suffix.
type ObjectTypeType ¶
type ObjectTypeType int
ObjectTypeType is the type for object type.
const ( // ObjectTypeNone is for empty object type. ObjectTypeNone ObjectTypeType = iota + 1 // ObjectTypeTable means the following object is a table. ObjectTypeTable )
func (ObjectTypeType) Restore ¶
func (n ObjectTypeType) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type OnCondition ¶
type OnCondition struct { Expr ExprNode // contains filtered or unexported fields }
OnCondition represents JOIN on condition.
func (*OnCondition) Accept ¶
func (n *OnCondition) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*OnCondition) Restore ¶
func (n *OnCondition) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type OnDeleteOpt ¶
type OnDeleteOpt struct { ReferOpt ReferOptionType // contains filtered or unexported fields }
OnDeleteOpt is used for optional on delete clause.
func (*OnDeleteOpt) Accept ¶
func (n *OnDeleteOpt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*OnDeleteOpt) Restore ¶
func (n *OnDeleteOpt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type OnDuplicateKeyHandlingType ¶
type OnDuplicateKeyHandlingType int
OnDuplicateKeyHandlingType is the option that handle unique key values in 'CREATE TABLE ... SELECT' or `LOAD DATA`. See https://dev.mysql.com/doc/refman/5.7/en/create-table-select.html See https://dev.mysql.com/doc/refman/5.7/en/load-data.html
const ( OnDuplicateKeyHandlingError OnDuplicateKeyHandlingType = iota OnDuplicateKeyHandlingIgnore OnDuplicateKeyHandlingReplace )
OnDuplicateKeyHandling types
type OnUpdateOpt ¶
type OnUpdateOpt struct { ReferOpt ReferOptionType // contains filtered or unexported fields }
OnUpdateOpt is used for optional on update clause.
func (*OnUpdateOpt) Accept ¶
func (n *OnUpdateOpt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*OnUpdateOpt) Restore ¶
func (n *OnUpdateOpt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type OrderByClause ¶
type OrderByClause struct { Items []*ByItem ForUnion bool // contains filtered or unexported fields }
OrderByClause represents order by clause.
func (*OrderByClause) Accept ¶
func (n *OrderByClause) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*OrderByClause) Restore ¶
func (n *OrderByClause) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ParamMarkerExpr ¶
ParamMarkerExpr expression holds a place for another expression. Used in parsing prepare statement.
type ParenthesesExpr ¶
type ParenthesesExpr struct { // Expr is the expression in parentheses. Expr ExprNode // contains filtered or unexported fields }
ParenthesesExpr is the parentheses expression.
func (*ParenthesesExpr) Accept ¶
func (n *ParenthesesExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ParenthesesExpr) Format ¶
func (n *ParenthesesExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*ParenthesesExpr) GetFlag ¶
func (en *ParenthesesExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*ParenthesesExpr) Restore ¶
func (n *ParenthesesExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type PartitionByClause ¶
type PartitionByClause struct { Items []*ByItem // contains filtered or unexported fields }
PartitionByClause represents partition by clause.
func (*PartitionByClause) Accept ¶
func (n *PartitionByClause) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*PartitionByClause) Restore ¶
func (n *PartitionByClause) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type PartitionDefinition ¶
type PartitionDefinition struct { Name model.CIStr Clause PartitionDefinitionClause Options []*TableOption Sub []*SubPartitionDefinition }
PartitionDefinition defines a single partition.
func (*PartitionDefinition) Comment ¶
func (n *PartitionDefinition) Comment() (string, bool)
Comment returns the comment option given to this definition. The second return value indicates if the comment option exists.
func (*PartitionDefinition) Restore ¶
func (n *PartitionDefinition) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type PartitionDefinitionClause ¶
type PartitionDefinitionClause interface { // Validate checks if the clause is consistent with the given options. // `pt` can be 0 and `columns` can be -1 to skip checking the clause against // the partition type or number of columns in the expression list. Validate(pt model.PartitionType, columns int) error // contains filtered or unexported methods }
type PartitionDefinitionClauseHistory ¶
type PartitionDefinitionClauseHistory struct {
Current bool
}
func (*PartitionDefinitionClauseHistory) Validate ¶
func (n *PartitionDefinitionClauseHistory) Validate(pt model.PartitionType, columns int) error
type PartitionDefinitionClauseIn ¶
type PartitionDefinitionClauseIn struct {
Values [][]ExprNode
}
func (*PartitionDefinitionClauseIn) Validate ¶
func (n *PartitionDefinitionClauseIn) Validate(pt model.PartitionType, columns int) error
type PartitionDefinitionClauseLessThan ¶
type PartitionDefinitionClauseLessThan struct {
Exprs []ExprNode
}
func (*PartitionDefinitionClauseLessThan) Validate ¶
func (n *PartitionDefinitionClauseLessThan) Validate(pt model.PartitionType, columns int) error
type PartitionDefinitionClauseNone ¶
type PartitionDefinitionClauseNone struct{}
func (*PartitionDefinitionClauseNone) Validate ¶
func (n *PartitionDefinitionClauseNone) Validate(pt model.PartitionType, columns int) error
type PartitionMethod ¶
type PartitionMethod struct { // Tp is the type of the partition function Tp model.PartitionType // Linear is a modifier to the HASH and KEY type for choosing a different // algorithm Linear bool // Expr is an expression used as argument of HASH, RANGE, LIST and // SYSTEM_TIME types Expr ExprNode // ColumnNames is a list of column names used as argument of KEY, // RANGE COLUMNS and LIST COLUMNS types ColumnNames []*ColumnName // Unit is a time unit used as argument of SYSTEM_TIME type Unit ValueExpr // Limit is a row count used as argument of the SYSTEM_TIME type Limit uint64 // Num is the number of (sub)partitions required by the method. Num uint64 }
PartitionMethod describes how partitions or subpartitions are constructed.
func (*PartitionMethod) Restore ¶
func (n *PartitionMethod) Restore(ctx *RestoreCtx) error
Restore implements the Node interface
type PartitionOptions ¶
type PartitionOptions struct { PartitionMethod Sub *PartitionMethod Definitions []*PartitionDefinition // contains filtered or unexported fields }
PartitionOptions specifies the partition options.
func (*PartitionOptions) Restore ¶
func (n *PartitionOptions) Restore(ctx *RestoreCtx) error
func (*PartitionOptions) SetText ¶
func (n *PartitionOptions) SetText(text string)
SetText implements Node interface.
func (*PartitionOptions) Text ¶
func (n *PartitionOptions) Text() string
Text implements Node interface.
func (*PartitionOptions) Validate ¶
func (n *PartitionOptions) Validate() error
Validate checks if the partition is well-formed.
type PasswordOrLockOption ¶
func (*PasswordOrLockOption) Restore ¶
func (p *PasswordOrLockOption) Restore(ctx *RestoreCtx) error
type PatternInExpr ¶
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 }
PatternInExpr is the expression for in operator, like "expr in (1, 2, 3)" or "expr in (select c from t)".
func (*PatternInExpr) Accept ¶
func (n *PatternInExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*PatternInExpr) Format ¶
func (n *PatternInExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*PatternInExpr) GetFlag ¶
func (en *PatternInExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*PatternInExpr) Restore ¶
func (n *PatternInExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type PatternLikeExpr ¶
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 }
PatternLikeExpr is the expression for like operator, e.g, expr like "%123%"
func (*PatternLikeExpr) Accept ¶
func (n *PatternLikeExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*PatternLikeExpr) Format ¶
func (n *PatternLikeExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*PatternLikeExpr) GetFlag ¶
func (en *PatternLikeExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*PatternLikeExpr) Restore ¶
func (n *PatternLikeExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type PatternRegexpExpr ¶
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 }
PatternRegexpExpr is the pattern expression for pattern match.
func (*PatternRegexpExpr) Accept ¶
func (n *PatternRegexpExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*PatternRegexpExpr) Format ¶
func (n *PatternRegexpExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*PatternRegexpExpr) GetFlag ¶
func (en *PatternRegexpExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*PatternRegexpExpr) Restore ¶
func (n *PatternRegexpExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type PositionExpr ¶
type PositionExpr struct { // N is the position, started from 1 now. N int // P is the parameterized position. P ExprNode // Refer is the result field the position refers to. Refer *ResultField // contains filtered or unexported fields }
PositionExpr is the expression for order by and group by position. MySQL use position expression started from 1, it looks a little confused inner. maybe later we will use 0 at first.
func (*PositionExpr) Accept ¶
func (n *PositionExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*PositionExpr) Format ¶
func (n *PositionExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*PositionExpr) GetFlag ¶
func (en *PositionExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*PositionExpr) Restore ¶
func (n *PositionExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type PrepareStmt ¶
type PrepareStmt struct { Name string SQLText string SQLVar *VariableExpr // contains filtered or unexported fields }
PrepareStmt is a statement to prepares a SQL statement which contains placeholders, and it is executed with ExecuteStmt and released with DeallocateStmt. See https://dev.mysql.com/doc/refman/5.7/en/prepare.html
func (*PrepareStmt) Accept ¶
func (n *PrepareStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*PrepareStmt) Restore ¶
func (n *PrepareStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type Prepared ¶
type Prepared struct { Stmt StmtNode StmtType string Params []ParamMarkerExpr SchemaVersion int64 UseCache bool }
Prepared represents a prepared statement.
type PrivElem ¶
type PrivElem struct { Priv mysql.PrivilegeType Cols []*ColumnName // contains filtered or unexported fields }
PrivElem is the privilege type and optional column list.
type RecoverTableStmt ¶
type RecoverTableStmt struct { JobID int64 Table *TableName JobNum int64 // contains filtered or unexported fields }
RecoverTableStmt is a statement to recover dropped table.
func (*RecoverTableStmt) Accept ¶
func (n *RecoverTableStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*RecoverTableStmt) Restore ¶
func (n *RecoverTableStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ReferOptionType ¶
type ReferOptionType int
ReferOptionType is the type for refer options.
const ( ReferOptionNoOption ReferOptionType = iota ReferOptionRestrict ReferOptionCascade ReferOptionSetNull ReferOptionNoAction ReferOptionSetDefault )
Refer option types.
func (ReferOptionType) String ¶
func (r ReferOptionType) String() string
String implements fmt.Stringer interface.
type ReferenceDef ¶
type ReferenceDef struct { Table *TableName IndexColNames []*IndexColName OnDelete *OnDeleteOpt OnUpdate *OnUpdateOpt Match MatchType // contains filtered or unexported fields }
ReferenceDef is used for parsing foreign key reference option from SQL. See http://dev.mysql.com/doc/refman/5.7/en/create-table-foreign-keys.html
func (*ReferenceDef) Accept ¶
func (n *ReferenceDef) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ReferenceDef) Restore ¶
func (n *ReferenceDef) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type RenameTableStmt ¶
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 }
RenameTableStmt is a statement to rename a table. See http://dev.mysql.com/doc/refman/5.7/en/rename-table.html
func (*RenameTableStmt) Accept ¶
func (n *RenameTableStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*RenameTableStmt) Restore ¶
func (n *RenameTableStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type ResourceOption ¶
func (*ResourceOption) Restore ¶
func (r *ResourceOption) Restore(ctx *RestoreCtx) error
type ResultField ¶
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 }
ResultField represents a result field which can be a column from a table, or an expression in select field. It is a generated property during binding process. ResultField is the key element to evaluate a ColumnNameExpr. After resolving process, every ColumnNameExpr will be resolved to a ResultField. During execution, every row retrieved from table will set the row value to ResultFields of that table, so ColumnNameExpr resolved to that ResultField can be easily evaluated.
type ResultSetNode ¶
type ResultSetNode interface { Node }
ResultSetNode interface has a ResultFields property, represents a Node that returns result set. Implementations include SelectStmt, SubqueryExpr, TableSource, TableName and Join.
type RevokeRoleStmt ¶
type RevokeRoleStmt struct { Roles []*auth.RoleIdentity Users []*auth.UserIdentity // contains filtered or unexported fields }
RevokeStmt is the struct for REVOKE statement.
func (*RevokeRoleStmt) Accept ¶
func (n *RevokeRoleStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*RevokeRoleStmt) Restore ¶
func (n *RevokeRoleStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type RevokeStmt ¶
type RevokeStmt struct { Privs []*PrivElem ObjectType ObjectTypeType Level *GrantLevel Users []*UserSpec // contains filtered or unexported fields }
RevokeStmt is the struct for REVOKE statement.
func (*RevokeStmt) Accept ¶
func (n *RevokeStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*RevokeStmt) Restore ¶
func (n *RevokeStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type RollbackStmt ¶
type RollbackStmt struct {
// contains filtered or unexported fields
}
RollbackStmt is a statement to roll back the current transaction. See https://dev.mysql.com/doc/refman/5.7/en/commit.html
func (*RollbackStmt) Accept ¶
func (n *RollbackStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*RollbackStmt) Restore ¶
func (n *RollbackStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type RowExpr ¶
type RowExpr struct { Values []ExprNode // contains filtered or unexported fields }
RowExpr is the expression for row constructor. See https://dev.mysql.com/doc/refman/5.7/en/row-subqueries.html
func (*RowExpr) GetFlag ¶
func (en *RowExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
type SelectField ¶
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 }
SelectField represents fields in select statement. There are two type of select field: wildcard and expression with optional alias name.
func (*SelectField) Accept ¶
func (n *SelectField) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*SelectField) Restore ¶
func (n *SelectField) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type SelectLockType ¶
type SelectLockType int
SelectLockType is the lock type for SelectStmt.
const ( SelectLockNone SelectLockType = iota SelectLockForUpdate SelectLockForUpdateNoWait )
Select lock types.
func (SelectLockType) String ¶
func (slt SelectLockType) String() string
String implements fmt.Stringer.
type SelectStmt ¶
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 // QueryBlockOffset indicates the order of this SelectStmt if counted from left to right in the sql text. QueryBlockOffset int // contains filtered or unexported fields }
SelectStmt represents the select query node. See https://dev.mysql.com/doc/refman/5.7/en/select.html
func (*SelectStmt) Accept ¶
func (n *SelectStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*SelectStmt) Restore ¶
func (n *SelectStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type SelectStmtOpts ¶
type SelectStmtOpts struct { Distinct bool SQLBigResult bool SQLBufferResult bool SQLCache bool SQLSmallResult bool CalcFoundRows bool StraightJoin bool Priority mysql.PriorityEnum TableHints []*TableOptimizerHint }
SelectStmtOpts wrap around select hints and switches
type SensitiveStmtNode ¶
type SensitiveStmtNode interface { StmtNode // SecureText is different from Text that it hide password information. SecureText() string }
SensitiveStmtNode overloads StmtNode and provides a SecureText method.
type SetDefaultRoleStmt ¶
type SetDefaultRoleStmt struct { SetRoleOpt SetRoleStmtType RoleList []*auth.RoleIdentity UserList []*auth.UserIdentity // contains filtered or unexported fields }
func (*SetDefaultRoleStmt) Accept ¶
func (n *SetDefaultRoleStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*SetDefaultRoleStmt) Restore ¶
func (n *SetDefaultRoleStmt) Restore(ctx *RestoreCtx) error
type SetPwdStmt ¶
type SetPwdStmt struct { User *auth.UserIdentity Password string // contains filtered or unexported fields }
SetPwdStmt is a statement to assign a password to user account. See https://dev.mysql.com/doc/refman/5.7/en/set-password.html
func (*SetPwdStmt) Accept ¶
func (n *SetPwdStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*SetPwdStmt) Restore ¶
func (n *SetPwdStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
func (*SetPwdStmt) SecureText ¶
func (n *SetPwdStmt) SecureText() string
SecureText implements SensitiveStatement interface.
type SetRoleStmt ¶
type SetRoleStmt struct { SetRoleOpt SetRoleStmtType RoleList []*auth.RoleIdentity // contains filtered or unexported fields }
func (*SetRoleStmt) Accept ¶
func (n *SetRoleStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*SetRoleStmt) Restore ¶
func (n *SetRoleStmt) Restore(ctx *RestoreCtx) error
type SetRoleStmtType ¶
type SetRoleStmtType int
SetRoleStmtType is the type for FLUSH statement.
const ( SetRoleDefault SetRoleStmtType = iota SetRoleNone SetRoleAll SetRoleAllExcept SetRoleRegular )
SetRole statement types.
type SetStmt ¶
type SetStmt struct { // Variables is the list of variable assignment. Variables []*VariableAssignment // contains filtered or unexported fields }
SetStmt is the statement to set variables.
type ShowSlow ¶
type ShowSlow struct { Tp ShowSlowType Count uint64 Kind ShowSlowKind }
ShowSlow is used for the following command:
admin show slow top [ internal | all] N admin show slow recent N
type ShowSlowKind ¶
type ShowSlowKind int
ShowSlowKind defines the kind for SlowSlow statement when the type is ShowSlowTop.
const ( // ShowSlowKindDefault is a ShowSlowKind constant. ShowSlowKindDefault ShowSlowKind = iota // ShowSlowKindInternal is a ShowSlowKind constant. ShowSlowKindInternal // ShowSlowKindAll is a ShowSlowKind constant. ShowSlowKindAll )
type ShowSlowType ¶
type ShowSlowType int
ShowSlowType defines the type for SlowSlow statement.
const ( // ShowSlowTop is a ShowSlowType constant. ShowSlowTop ShowSlowType = iota // ShowSlowRecent is a ShowSlowType constant. ShowSlowRecent )
type ShowStmt ¶
type ShowStmt struct { Tp ShowStmtType // Databases/Tables/Columns/.... DBName string Table *TableName // Used for showing columns. Column *ColumnName // Used for `desc table column`. IndexName model.CIStr Flag int // Some flag parsed from sql, such as FULL. Full bool User *auth.UserIdentity // Used for show grants/create user. Roles []*auth.RoleIdentity // Used for show grants .. using IfNotExists bool // Used for `show create database if not exists` // GlobalScope is used by `show variables` and `show bindings` GlobalScope bool Pattern *PatternLikeExpr Where ExprNode ShowProfileTypes []int // Used for `SHOW PROFILE` syntax ShowProfileArgs *int64 // Used for `SHOW PROFILE` syntax ShowProfileLimit *Limit // Used for `SHOW PROFILE` syntax // contains filtered or unexported fields }
ShowStmt is a statement to provide information about databases, tables, columns and so on. See https://dev.mysql.com/doc/refman/5.7/en/show.html
type ShutdownStmt ¶
type ShutdownStmt struct {
// contains filtered or unexported fields
}
ShutdownStmt is a statement to stop the TiDB server. See https://dev.mysql.com/doc/refman/5.7/en/shutdown.html
func (*ShutdownStmt) Accept ¶
func (n *ShutdownStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ShutdownStmt) Restore ¶
func (n *ShutdownStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type SplitOption ¶
func (*SplitOption) Restore ¶
func (n *SplitOption) Restore(ctx *RestoreCtx) error
type SplitRegionStmt ¶
type SplitRegionStmt struct { Table *TableName IndexName model.CIStr PartitionNames []model.CIStr SplitSyntaxOpt *SplitSyntaxOption SplitOpt *SplitOption // contains filtered or unexported fields }
func (*SplitRegionStmt) Restore ¶
func (n *SplitRegionStmt) Restore(ctx *RestoreCtx) error
type SplitSyntaxOption ¶
type StmtNode ¶
type StmtNode interface { Node // contains filtered or unexported methods }
StmtNode represents statement node. Name of implementations should have 'Stmt' suffix.
type SubPartitionDefinition ¶
type SubPartitionDefinition struct { Name model.CIStr Options []*TableOption }
func (*SubPartitionDefinition) Restore ¶
func (spd *SubPartitionDefinition) Restore(ctx *RestoreCtx) error
type SubqueryExpr ¶
type SubqueryExpr struct { // Query is the query SelectNode. Query ResultSetNode Evaluated bool MultiRows bool Exists bool // contains filtered or unexported fields }
SubqueryExpr represents a subquery.
func (*SubqueryExpr) Accept ¶
func (n *SubqueryExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*SubqueryExpr) Format ¶
func (n *SubqueryExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*SubqueryExpr) GetFlag ¶
func (en *SubqueryExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*SubqueryExpr) Restore ¶
func (n *SubqueryExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type TableName ¶
type TableName struct { Schema model.CIStr Name model.CIStr DBInfo *model.DBInfo TableInfo *model.TableInfo IndexHints []*IndexHint PartitionNames []model.CIStr // contains filtered or unexported fields }
TableName represents a table name.
type TableOptimizerHint ¶
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 // QBName is the default effective query block of this hint. QBName model.CIStr Tables []HintTable Indexes []model.CIStr StoreType 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 MemoryQuota int64 QueryType model.CIStr HintFlag bool // contains filtered or unexported fields }
TableOptimizerHint is Table level optimizer hint
func (*TableOptimizerHint) Accept ¶
func (n *TableOptimizerHint) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*TableOptimizerHint) Restore ¶
func (n *TableOptimizerHint) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type TableOption ¶
type TableOption struct { Tp TableOptionType StrValue string UintValue uint64 }
TableOption is used for parsing table option from SQL.
func (*TableOption) Restore ¶
func (n *TableOption) Restore(ctx *RestoreCtx) error
type TableOptionType ¶
type TableOptionType int
TableOptionType is the type for TableOption
const ( TableOptionNone TableOptionType = iota TableOptionEngine TableOptionCharset TableOptionCollate TableOptionAutoIncrement TableOptionComment TableOptionAvgRowLength TableOptionCheckSum TableOptionCompression TableOptionConnection TableOptionPassword TableOptionKeyBlockSize TableOptionMaxRows TableOptionMinRows TableOptionDelayKeyWrite TableOptionRowFormat TableOptionStatsPersistent TableOptionShardRowID TableOptionPreSplitRegion TableOptionPackKeys TableOptionTablespace TableOptionNodegroup TableOptionDataDirectory TableOptionIndexDirectory )
TableOption types.
type TableRefsClause ¶
type TableRefsClause struct { TableRefs *Join // contains filtered or unexported fields }
TableRefsClause represents table references clause in dml statement.
func (*TableRefsClause) Accept ¶
func (n *TableRefsClause) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*TableRefsClause) Restore ¶
func (n *TableRefsClause) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type TableSource ¶
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 }
TableSource represents table source with a name.
func (*TableSource) Accept ¶
func (n *TableSource) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*TableSource) Restore ¶
func (n *TableSource) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type TableToTable ¶
type TableToTable struct { OldTable *TableName NewTable *TableName // contains filtered or unexported fields }
TableToTable represents renaming old table to new table used in RenameTableStmt.
func (*TableToTable) Accept ¶
func (n *TableToTable) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*TableToTable) Restore ¶
func (n *TableToTable) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type TraceStmt ¶
TraceStmt is a statement to trace what sql actually does at background.
type TrimDirectionType ¶
type TrimDirectionType int
TrimDirectionType is the type for trim direction.
const ( // TrimBothDefault trims from both direction by default. TrimBothDefault TrimDirectionType = iota // TrimBoth trims from both direction with explicit notation. TrimBoth // TrimLeading trims from left. TrimLeading // TrimTrailing trims from right. TrimTrailing )
type TruncateTableStmt ¶
type TruncateTableStmt struct { Table *TableName // contains filtered or unexported fields }
TruncateTableStmt is a statement to empty a table completely. See https://dev.mysql.com/doc/refman/5.7/en/truncate-table.html
func (*TruncateTableStmt) Accept ¶
func (n *TruncateTableStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*TruncateTableStmt) Restore ¶
func (n *TruncateTableStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type UnaryOperationExpr ¶
type UnaryOperationExpr struct { // Op is the operator opcode. Op opcode.Op // V is the unary expression. V ExprNode // contains filtered or unexported fields }
UnaryOperationExpr is the expression for unary operator.
func (*UnaryOperationExpr) Accept ¶
func (n *UnaryOperationExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*UnaryOperationExpr) Format ¶
func (n *UnaryOperationExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*UnaryOperationExpr) GetFlag ¶
func (en *UnaryOperationExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*UnaryOperationExpr) Restore ¶
func (n *UnaryOperationExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type UnionSelectList ¶
type UnionSelectList struct { Selects []*SelectStmt // contains filtered or unexported fields }
UnionSelectList represents the select list in a union statement.
func (*UnionSelectList) Accept ¶
func (n *UnionSelectList) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*UnionSelectList) Restore ¶
func (n *UnionSelectList) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type UnionStmt ¶
type UnionStmt struct { SelectList *UnionSelectList OrderBy *OrderByClause Limit *Limit // contains filtered or unexported fields }
UnionStmt represents "union statement" See https://dev.mysql.com/doc/refman/5.7/en/union.html
type UpdateStmt ¶
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 }
UpdateStmt is a statement to update columns of existing rows in tables with new values. See https://dev.mysql.com/doc/refman/5.7/en/update.html
func (*UpdateStmt) Accept ¶
func (n *UpdateStmt) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*UpdateStmt) Restore ¶
func (n *UpdateStmt) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type UseStmt ¶
type UseStmt struct { DBName string // contains filtered or unexported fields }
UseStmt is a statement to use the DBName database as the current database. See https://dev.mysql.com/doc/refman/5.7/en/use.html
type UserSpec ¶
type UserSpec struct { User *auth.UserIdentity AuthOpt *AuthOption IsRole bool }
UserSpec is used for parsing create user statement.
func (*UserSpec) EncodedPassword ¶
EncodedPassword returns the encoded password (which is the real data mysql.user). The boolean value indicates input's password format is legal or not.
func (*UserSpec) SecurityString ¶
SecurityString formats the UserSpec without password information.
type ValueExpr ¶
type ValueExpr interface { ExprNode SetValue(val interface{}) GetValue() interface{} GetDatumString() string GetString() string GetProjectionOffset() int SetProjectionOffset(offset int) }
ValueExpr define a interface for ValueExpr.
type ValuesExpr ¶
type ValuesExpr struct { // Column is column name. Column *ColumnNameExpr // contains filtered or unexported fields }
ValuesExpr is the expression used in INSERT VALUES.
func (*ValuesExpr) Accept ¶
func (n *ValuesExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*ValuesExpr) Format ¶
func (n *ValuesExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*ValuesExpr) GetFlag ¶
func (en *ValuesExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*ValuesExpr) Restore ¶
func (n *ValuesExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type VariableAssignment ¶
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 }
VariableAssignment is a variable assignment struct.
func (*VariableAssignment) Accept ¶
func (n *VariableAssignment) Accept(v Visitor) (Node, bool)
Accept implements Node interface.
func (*VariableAssignment) Restore ¶
func (n *VariableAssignment) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type VariableExpr ¶
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 }
VariableExpr is the expression for variable.
func (*VariableExpr) Accept ¶
func (n *VariableExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*VariableExpr) Format ¶
func (n *VariableExpr) Format(w io.Writer)
Format the ExprNode into a Writer.
func (*VariableExpr) GetFlag ¶
func (en *VariableExpr) GetFlag() uint64
GetFlag implements ExprNode interface.
func (*VariableExpr) Restore ¶
func (n *VariableExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type Visitor ¶
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) }
Visitor visits a Node.
type WhenClause ¶
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 }
WhenClause is the when clause in Case expression for "when condition then result".
func (*WhenClause) Accept ¶
func (n *WhenClause) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*WhenClause) Restore ¶
func (n *WhenClause) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type WildCardField ¶
type WildCardField struct { Table model.CIStr Schema model.CIStr // contains filtered or unexported fields }
WildCardField is a special type of select field content.
func (*WildCardField) Accept ¶
func (n *WildCardField) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*WildCardField) Restore ¶
func (n *WildCardField) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type WindowFuncExpr ¶
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 }
WindowFuncExpr represents window function expression.
func (*WindowFuncExpr) Accept ¶
func (n *WindowFuncExpr) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*WindowFuncExpr) Format ¶
func (n *WindowFuncExpr) Format(w io.Writer)
Format formats the window function expression into a Writer.
func (*WindowFuncExpr) Restore ¶
func (n *WindowFuncExpr) Restore(ctx *RestoreCtx) error
Restore implements Node interface.
type WindowSpec ¶
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 // OnlyAlias will set to true of the first following case. // To make compatible with MySQL, we need to distinguish `select func over w` from `select func over (w)`. OnlyAlias bool // contains filtered or unexported fields }
WindowSpec is the specification of a window.
func (*WindowSpec) Accept ¶
func (n *WindowSpec) Accept(v Visitor) (Node, bool)
Accept implements Node Accept interface.
func (*WindowSpec) Restore ¶
func (n *WindowSpec) Restore(ctx *RestoreCtx) error
Restore implements Node interface.