Documentation
¶
Index ¶
- Constants
- Variables
- func Append(buf *strings.Builder, node SQLNode)
- func EncodeValue(buf *strings.Builder, value *querypb.BindVariable)
- func ExtractMysqlComment(sql string) (version string, innerSQL string)
- func FetchBindVar(name string, bindVariables map[string]*querypb.BindVariable) (val *querypb.BindVariable, isList bool, err error)
- func FormatImpossibleQuery(buf *TrackedBuffer, node SQLNode)
- func GetBindvars(stmt Statement) map[string]struct{}
- func KeywordString(id int) string
- func Normalize(stmt Statement, bindVars map[string]*querypb.BindVariable, prefix string)
- func ParseTokenizer(tokenizer *Tokenizer) int
- func RedactSQLQuery(sql string) (string, error)
- func SkipQueryPlanCacheDirective(stmt Statement) bool
- func SplitStatement(blob string) (string, string, error)
- func SplitStatementToPieces(blob string) (pieces []string, err error)
- func String(node SQLNode) string
- func StripComments(sql string) string
- func StripLeadingComments(sql string) string
- func TruncateForLog(query string) string
- func TruncateForUI(query string) string
- func VarScopeForColName(colName *ColName) (*ColName, SetScope, error)
- func Walk(visit Visit, nodes ...SQLNode) error
- type AccountLimitItem
- type AccountLimitItemType
- type AccountLimits
- type AccountName
- type AccountRename
- type AccountWithAuth
- type AliasedExpr
- type AliasedTableExpr
- type AndExpr
- type AsOf
- type AssignmentExpr
- type AssignmentExprs
- type Authentication
- type AutoIncSpec
- type Begin
- type BeginEndBlock
- type BinaryExpr
- type BoolVal
- type Call
- type CaseExpr
- type CaseStatement
- type CaseStatementCase
- type Characteristic
- type CharacteristicValue
- type CheckConstraintDefinition
- type ColIdent
- func (node ColIdent) CompliantName() string
- func (node ColIdent) Equal(in ColIdent) bool
- func (node ColIdent) EqualString(str string) bool
- func (node ColIdent) Format(buf *TrackedBuffer)
- func (node ColIdent) IsEmpty() bool
- func (node ColIdent) Lowered() string
- func (node ColIdent) MarshalJSON() ([]byte, error)
- func (node ColIdent) String() string
- func (node *ColIdent) UnmarshalJSON(b []byte) error
- type ColName
- type ColTuple
- type CollateExpr
- type ColumnDefinition
- type ColumnKeyOption
- type ColumnOrder
- type ColumnType
- type Columns
- type CommentDirectives
- type Comments
- type Commit
- type CommonTableExpr
- type ComparisonExpr
- type ConstraintDefinition
- type ConstraintInfo
- type ConvertExpr
- type ConvertType
- type ConvertUsingExpr
- type CreateRole
- type CreateUser
- type CurTimeFuncExpr
- type DBDDL
- type DDL
- type Declare
- type DeclareCondition
- type DeclareCursor
- type DeclareHandler
- type DeclareHandlerAction
- type DeclareHandlerCondition
- type DeclareHandlerConditionValue
- type DeclareVariables
- type Default
- type DefaultSpec
- type Delete
- type DropRole
- type DropUser
- type EnclosedBy
- type Encodable
- type ExistsExpr
- type Explain
- type Expr
- type Exprs
- type Fields
- type ForeignKeyDefinition
- type FuncExpr
- type GrantObjectType
- type GrantPrivilege
- type GrantProxy
- type GrantRole
- type GrantUserAssumption
- type GrantUserAssumptionType
- type GroupBy
- type GroupConcatExpr
- type IfStatement
- type IfStatementCondition
- type IndexColumn
- type IndexDefinition
- type IndexHints
- type IndexInfo
- type IndexOption
- type IndexSpec
- type Insert
- type InsertRows
- type InsertValues
- type IntervalExpr
- type IsExpr
- type JoinCondition
- type JoinTableExpr
- type LengthScaleOption
- type Limit
- type Lines
- type ListArg
- type Load
- type LoadStatement
- type LockTables
- type LockType
- type MarginComments
- type MatchExpr
- type MultiAlterDDL
- type Nextval
- type NodeFormatter
- type NotExpr
- type NullVal
- type OnDup
- type OptLike
- type OptSelect
- type OrExpr
- type Order
- type OrderBy
- type OtherAdmin
- type OtherRead
- type Over
- type ParenExpr
- type ParenSelect
- type ParenTableExpr
- type ParsedQuery
- type PartitionDefinition
- type PartitionSpec
- type Partitions
- type PassLockItem
- type PassLockItemType
- type PasswordOptions
- type Privilege
- type PrivilegeLevel
- type PrivilegeType
- type ProcedureParam
- type ProcedureParamDirection
- type ProcedureSpec
- type RangeCond
- type ReferenceAction
- type ReleaseSavepoint
- type RenameUser
- type Resignal
- type RevokeAllPrivileges
- type RevokePrivilege
- type RevokeProxy
- type RevokeRole
- type Rollback
- type RollbackSavepoint
- type SQLNode
- type SQLVal
- type Savepoint
- type Select
- func (node *Select) AddHaving(expr Expr)
- func (node *Select) AddOrder(order *Order)
- func (node *Select) AddWhere(expr Expr)
- func (node *Select) Format(buf *TrackedBuffer)
- func (node *Select) SetLimit(limit *Limit)
- func (node *Select) SetLock(lock string)
- func (node *Select) SetOrderBy(orderBy OrderBy)
- type SelectExpr
- type SelectExprs
- type SelectStatement
- type Set
- type SetScope
- type SetVarExpr
- type SetVarExprs
- type Show
- type ShowFilter
- type ShowGrants
- type ShowPrivileges
- type ShowTablesOpt
- type Signal
- type SignalConditionItemName
- type SignalInfo
- type SimpleTableExpr
- type StarExpr
- type Statement
- type Statements
- type Stream
- type Subquery
- type SubstrExpr
- type TLSOptionItem
- type TLSOptionItemType
- type TLSOptions
- type TableAndLockType
- type TableAndLockTypes
- type TableExpr
- type TableExprs
- type TableIdent
- type TableName
- type TableNames
- type TableSpec
- type TimestampFuncExpr
- type Tokenizer
- type TrackedBuffer
- type TriggerOrder
- type TriggerSpec
- type TupleEqualityList
- type UnaryExpr
- type Union
- type UnlockTables
- type Update
- type Use
- type ValTuple
- type ValType
- type Values
- type ValuesFuncExpr
- type ValuesStatement
- type Visit
- type When
- type Where
Constants ¶
const ( DistinctStr = "distinct " StraightJoinHint = "straight_join " )
Select.Distinct
const ( ForUpdateStr = " for update" )
Select.Lock
const ( SQLCacheStr = "sql_cache " SQLNoCacheStr = "sql_no_cache " )
Select.Cache
const ( UnionStr = "union" UnionAllStr = "union all" UnionDistinctStr = "union distinct" )
Union.Type
const ( SessionStr = "session" GlobalStr = "global" )
Show.Scope
const ( CreateStr = "create" AlterStr = "alter" AddStr = "add" DropStr = "drop" RenameStr = "rename" ModifyStr = "modify" ChangeStr = "change" TruncateStr = "truncate" FlushStr = "flush" IndexStr = "index" BeforeStr = "before" AfterStr = "after" InsertStr = "insert" UpdateStr = "update" DeleteStr = "delete" FollowsStr = "follows" PrecedesStr = "precedes" AddAutoIncStr = "add auto_increment" UniqueStr = "unique" SpatialStr = "spatial" FulltextStr = "fulltext" SetStr = "set" TemporaryStr = "temporary" PrimaryStr = "primary" )
DDL strings.
const ( TraditionalStr = "traditional" TreeStr = "tree" JsonStr = "json" )
Format strings for explain statements
const ( JoinStr = "join" StraightJoinStr = "straight_join" LeftJoinStr = "left join" RightJoinStr = "right join" NaturalJoinStr = "natural join" NaturalLeftJoinStr = "natural left join" NaturalRightJoinStr = "natural right join" )
JoinTableExpr.Join
const ( UseStr = "use " IgnoreStr = "ignore " ForceStr = "force " )
Index hints.
const ( WhereStr = "where" HavingStr = "having" )
Where.Type
const ( EqualStr = "=" LessThanStr = "<" GreaterThanStr = ">" LessEqualStr = "<=" GreaterEqualStr = ">=" NotEqualStr = "!=" NullSafeEqualStr = "<=>" InStr = "in" NotInStr = "not in" LikeStr = "like" NotLikeStr = "not like" RegexpStr = "regexp" NotRegexpStr = "not regexp" JSONExtractOp = "->" JSONUnquoteExtractOp = "->>" )
ComparisonExpr.Operator
const ( BetweenStr = "between" NotBetweenStr = "not between" )
RangeCond.Operator
const ( IsNullStr = "is null" IsNotNullStr = "is not null" IsTrueStr = "is true" IsNotTrueStr = "is not true" IsFalseStr = "is false" IsNotFalseStr = "is not false" )
IsExpr.Operator
const ( StrVal = ValType(iota) IntVal FloatVal HexNum HexVal ValArg BitVal )
These are the possible Valtype values. HexNum represents a 0x... value. It cannot be treated as a simple value because it can be interpreted differently depending on the context.
const ( BitAndStr = "&" BitOrStr = "|" BitXorStr = "^" PlusStr = "+" MinusStr = "-" MultStr = "*" DivStr = "/" IntDivStr = "div" ModStr = "%" ShiftLeftStr = "<<" ShiftRightStr = ">>" )
BinaryExpr.Operator
const ( UPlusStr = "+" UMinusStr = "-" TildaStr = "~" BangStr = "!" BinaryStr = "binary " UBinaryStr = "_binary " Utf8mb4Str = "_utf8mb4 " )
UnaryExpr.Operator
const ( CharacterSetStr = " character set" CharsetStr = "charset" )
this string is "character set" and this comment is required
const ( BooleanModeStr = " in boolean mode" NaturalLanguageModeStr = " in natural language mode" NaturalLanguageModeWithQueryExpansionStr = " in natural language mode with query expansion" QueryExpansionStr = " with query expansion" )
MatchExpr.Option
const ( AscScr = "asc" DescScr = "desc" )
Order.Direction
const ( // TransactionStr is the Name for a SET TRANSACTION statement TransactionStr = "transaction" IsolationLevelReadUncommitted = "isolation level read uncommitted" IsolationLevelReadCommitted = "isolation level read committed" IsolationLevelRepeatableRead = "isolation level repeatable read" IsolationLevelSerializable = "isolation level serializable" TxReadOnly = "read only" TxReadWrite = "read write" )
SetVarExpr.Expr, for SET TRANSACTION ... or START TRANSACTION
const ( // DirectiveMultiShardAutocommit is the query comment directive to allow // single round trip autocommit with a multi-shard statement. DirectiveMultiShardAutocommit = "MULTI_SHARD_AUTOCOMMIT" // DirectiveSkipQueryPlanCache skips query plan cache when set. DirectiveSkipQueryPlanCache = "SKIP_QUERY_PLAN_CACHE" // DirectiveQueryTimeout sets a query timeout in vtgate. Only supported for SELECTS. DirectiveQueryTimeout = "QUERY_TIMEOUT_MS" // DirectiveScatterErrorsAsWarnings enables partial success scatter select queries DirectiveScatterErrorsAsWarnings = "SCATTER_ERRORS_AS_WARNINGS" )
const ACTION = 57478
const ACTIVE = 57704
const ADD = 57460
const ADMIN = 57705
const AFTER = 57486
const AGAINST = 57689
const ALL = 57363
const ALTER = 57456
const ANALYZE = 57459
const AND = 57426
const APPROXNUM = 57610
const ARRAY = 57696
const AS = 57365
const ASC = 57367
const AUTO_INCREMENT = 57609
const AVG = 57660
const BEFORE = 57511
const BEGIN = 57550
const BETWEEN = 57428
const BIGINT = 57564
const BINARY = 57449
const BIT = 57558
const BIT_AND = 57661
const BIT_LITERAL = 57420
const BIT_OR = 57662
const BIT_XOR = 57663
const BLOB = 57592
const BOOL = 57580
const BOOLEAN = 57690
const BUCKETS = 57706
const BY = 57358
const CALL = 57362
const CASCADE = 57479
const CASE = 57429
const CAST = 57649
const CATALOG_NAME = 57532
const CHANGE = 57463
const CHAR = 57578
const CHARACTER = 57581
const CHARSET = 57625
const CHECK = 57477
const CLASS_ORIGIN = 57525
const CLONE = 57707
const COLLATE = 57448
const COLLATION = 57614
const COLUMN = 57473
const COLUMNS = 57620
const COLUMN_NAME = 57535
const COMMENT = 57418
const COMMENT_KEYWORD = 57419
const COMMIT = 57553
const COMMITTED = 57634
const COMPONENT = 57708
const CONDITION = 57541
const CONSTRAINT = 57480
const CONSTRAINT_CATALOG = 57529
const CONSTRAINT_NAME = 57531
const CONSTRAINT_SCHEMA = 57530
const CONTAINS = 57519
const CONTINUE = 57543
const CONVERT = 57648
const COUNT = 57664
const CREATE = 57455
const CROSS = 57404
const CUME_DIST = 57677
const CURRENT_DATE = 57639
const CURRENT_TIME = 57641
const CURRENT_TIMESTAMP = 57637
const CURRENT_USER = 57640
const CURSOR = 57542
const CURSOR_NAME = 57536
const (
CreateTriggerStr = "create trigger"
)
const DATA = 57378
const DATABASE = 57638
const DATABASES = 57615
const DATE = 57490
const DATETIME = 57576
const DEC = 57571
const DECIMAL = 57569
const DECLARE = 57540
const DEFAULT = 57371
const DEFINER = 57514
const DEFINITION = 57709
const DELETE = 57352
const DENSE_RANK = 57678
const DESC = 57368
const DESCRIBE = 57488
const DESCRIPTION = 57697
const DETERMINISTIC = 57518
const DISTINCT = 57364
const DIV = 57445
const DOUBLE = 57567
const DROP = 57457
const DUPLICATE = 57370
const EACH = 57509
const ELSE = 57432
const ELSEIF = 57433
const EMPTY = 57698
const ENCLOSED = 57383
const END = 57434
const ENFORCED = 57710
const ENGINES = 57622
const ENUM = 57597
const ESCAPE = 57491
const ESCAPED = 57382
const EXCEPT = 57699
const EXCLUDE = 57711
const EXISTS = 57366
const EXIT = 57544
const EXPANSION = 57694
const EXPLAIN = 57489
const FALSE = 57423
const FIELDS = 57621
const FIRST = 57485
const FIRST_VALUE = 57679
const FIXED = 57572
const FLOAT = 57414
const FLOAT_TYPE = 57568
const FLUSH = 57461
const FOLLOWING = 57712
const FOLLOWS = 57512
const FOR = 57361
const FORCE = 57407
const FOREIGN = 57481
const FORMAT = 57495
const FOUND = 57547
const FROM = 57353
const FULL = 57618
const FULLTEXT = 57475
const FUNCTION = 57504
const GE = 57436
const GEOMCOLLECTION = 57713
const GEOMETRY = 57598
const GEOMETRYCOLLECTION = 57602
const GET_MASTER_PUBLIC_KEY = 57714
const GLOBAL = 57626
const GROUP = 57355
const GROUPING = 57658
const GROUPS = 57659
const GROUP_CONCAT = 57652
const HANDLER = 57546
const HAVING = 57356
const HEX = 57411
const HEXNUM = 57415
const HISTOGRAM = 57715
const HISTORY = 57716
const ID = 57410
const IF = 57471
const IGNORE = 57470
const IN = 57442
const INACTIVE = 57717
const INDEX = 57466
const INDEXES = 57467
const INFILE = 57761
const INNER = 57402
const INOUT = 57516
const INSERT = 57350
const INT = 57562
const INTEGER = 57563
const INTEGRAL = 57413
const INTERVAL = 57452
const INTNUM = 57565
const INTO = 57369
const INVISIBLE = 57718
const INVOKER = 57515
const IS = 57439
const ISOLATION = 57628
const JOIN = 57398
const JSON = 57596
const JSON_ARRAYAGG = 57665
const JSON_EXTRACT_OP = 57453
const JSON_OBJECTAGG = 57666
const JSON_TABLE = 57700
const JSON_UNQUOTE_EXTRACT_OP = 57454
const KEY = 57387
const KEYS = 57375
const KEY_BLOCK_SIZE = 57476
const LAG = 57680
const LANGUAGE = 57691
const LAST_INSERT_ID = 57390
const LAST_VALUE = 57681
const LATERAL = 57701
const LE = 57435
const LEAD = 57682
const LEFT = 57400
const LESS = 57499
const LEVEL = 57629
const LEX_ERROR = 57346
const LIKE = 57440
const LIMIT = 57359
const LINES = 57380
const LINESTRING = 57600
const LIST_ARG = 57417
const LOAD = 57379
const LOCAL = 57606
const LOCALTIME = 57642
const LOCALTIMESTAMP = 57643
const LOCK = 57373
const LOCKED = 57719
const LONG = 57591
const LONGBLOB = 57595
const LONGTEXT = 57590
const LOW_PRIORITY = 57607
const MASTER_COMPRESSION_ALGORITHMS = 57720
const MASTER_PUBLIC_KEY_PATH = 57721
const MASTER_TLS_CIPHERSUITES = 57722
const MASTER_ZSTD_COMPRESSION_LEVEL = 57723
const MATCH = 57688
const MAX = 57667
const MAXVALUE = 57496
const MEDIUMBLOB = 57594
const MEDIUMINT = 57561
const MEDIUMTEXT = 57589
const MEMBER = 57702
const MESSAGE_TEXT = 57527
const MIN = 57668
const MOD = 57446
const MODE = 57395
const MODIFIES = 57521
const MODIFY = 57462
const MULTILINESTRING = 57604
const MULTIPOINT = 57603
const MULTIPOLYGON = 57605
const MYSQL_ERRNO = 57528
const NAMES = 57624
const NATIONAL = 57585
const NATURAL = 57405
const NCHAR = 57583
const NE = 57437
const NESTED = 57724
const NETWORK_NAMESPACE = 57725
const NEXT = 57392
const NO = 57482
const NOT = 57427
const NOWAIT = 57726
const NTH_VALUE = 57683
const NTILE = 57684
const NULL = 57421
const NULLS = 57727
const NULLX = 57608
const NULL_SAFE_EQUAL = 57438
const NUMERIC = 57570
const NVARCHAR = 57584
const OF = 57376
const OFF = 57424
const OFFSET = 57360
const OJ = 57728
const OLD = 57729
const ON = 57408
const ONLY = 57632
const OPTIMIZE = 57493
const OPTIONAL = 57730
const OPTIONALLY = 57384
const OR = 57425
const ORDER = 57357
const ORDINALITY = 57731
const ORGANIZATION = 57732
const OTHERS = 57733
const OUT = 57517
const OUTER = 57403
const OUTFILE = 57377
const OVER = 57656
const PARTITION = 57497
const PATH = 57734
const PERCENT_RANK = 57686
const PERSIST = 57735
const PERSIST_ONLY = 57736
const PLUGINS = 57623
const POINT = 57599
const POLYGON = 57601
const PRECEDES = 57513
const PRECEDING = 57737
const PRECISION = 57573
const PRIMARY = 57472
const PRIVILEGE_CHECKS_USER = 57738
const PROCEDURE = 57501
const PROCESS = 57739
const PROCESSLIST = 57619
const QUERY = 57693
const RANDOM = 57740
const RANK = 57687
const READ = 57630
const READS = 57520
const REAL = 57566
const RECURSIVE = 57703
const REFERENCE = 57741
const REFERENCES = 57483
const REGEXP = 57441
const RELEASE = 57557
const RENAME = 57458
const REORGANIZE = 57498
const REPAIR = 57492
const REPEATABLE = 57633
const REPLACE = 57647
const REQUIRE_ROW_FORMAT = 57742
const RESIGNAL = 57538
const RESOURCE = 57743
const RESPECT = 57744
const RESTART = 57745
const RESTRICT = 57484
const RETAIN = 57746
const REUSE = 57747
const RIGHT = 57401
const ROLE = 57748
const ROLLBACK = 57554
const ROW = 57510
const ROW_NUMBER = 57685
const (
ReorganizeStr = "reorganize partition"
)
Partition strings
const (
ReplaceStr = "replace"
)
const SAVEPOINT = 57555
const SCHEMA = 57464
const SCHEMAS = 57616
const SCHEMA_NAME = 57533
const SECONDARY = 57749
const SECONDARY_ENGINE = 57750
const SECONDARY_LOAD = 57751
const SECONDARY_UNLOAD = 57752
const SECURITY = 57523
const SELECT = 57348
const SEPARATOR = 57653
const SEQUENCE = 57508
const SERIALIZABLE = 57636
const SESSION = 57627
const SET = 57372
const SHARE = 57394
const SHIFT_LEFT = 57443
const SHIFT_RIGHT = 57444
const SHOW = 57487
const SIGNAL = 57537
const SIGNED = 57611
const SKIP = 57753
const SMALLINT = 57560
const SPATIAL = 57474
const SQL = 57522
const SQLEXCEPTION = 57549
const SQLSTATE = 57539
const SQLWARNING = 57548
const SQL_CACHE = 57397
const SQL_CALC_FOUND_ROWS = 57391
const SQL_NO_CACHE = 57396
const SRID = 57754
const START = 57551
const STARTING = 57385
const STATUS = 57505
const STD = 57671
const STDDEV = 57670
const STDDEV_POP = 57669
const STDDEV_SAMP = 57672
const STRAIGHT_JOIN = 57399
const STREAM = 57349
const STRING = 57412
const SUBCLASS_ORIGIN = 57526
const SUBSTR = 57650
const SUBSTRING = 57651
const SUM = 57673
const SYSTEM = 57760
const SYSTEM_TIME = 57388
const TABLE = 57465
const TABLES = 57617
const TABLE_NAME = 57534
const TEMPORARY = 57524
const TERMINATED = 57381
const TEXT = 57587
const THAN = 57500
const THEN = 57431
const THREAD_PRIORITY = 57755
const TIES = 57756
const TIME = 57574
const TIMESTAMP = 57575
const TIMESTAMPADD = 57654
const TIMESTAMPDIFF = 57655
const TINYBLOB = 57593
const TINYINT = 57559
const TINYTEXT = 57588
const TO = 57469
const TRANSACTION = 57552
const TRIGGER = 57502
const TRIGGERS = 57503
const TRUE = 57422
const TRUNCATE = 57494
const UNARY = 57447
const UNBOUNDED = 57757
const UNCOMMITTED = 57635
const UNDERSCORE_BINARY = 57450
const UNDERSCORE_UTF8MB4 = 57451
const UNDO = 57545
const UNION = 57347
const UNIQUE = 57386
const UNLOCK = 57374
const UNSIGNED = 57612
const UNUSED = 57695
const UPDATE = 57351
const USE = 57406
const USING = 57409
const UTC_DATE = 57644
const UTC_TIME = 57645
const UTC_TIMESTAMP = 57646
const VALUE = 57393
const VALUES = 57389
const VALUE_ARG = 57416
const VARBINARY = 57582
const VARCHAR = 57579
const VARIABLES = 57506
const VARIANCE = 57675
const VARYING = 57586
const VAR_POP = 57674
const VAR_SAMP = 57676
const VCPU = 57758
const VIEW = 57468
const VISIBLE = 57759
const WARNINGS = 57507
const WHEN = 57430
const WHERE = 57354
const WINDOW = 57657
const WITH = 57692
const WORK = 57556
const WRITE = 57631
const YEAR = 57577
const ZEROFILL = 57613
Variables ¶
var ( // TruncateUILen truncate queries in debug UIs to the given length. 0 means unlimited. TruncateUILen = flag.Int("sql-max-length-ui", 512, "truncate queries in debug UIs to the given length (default 512)") // TruncateErrLen truncate queries in error logs to the given length. 0 means unlimited. TruncateErrLen = flag.Int("sql-max-length-errors", 0, "truncate queries in error logs to the given length (default unlimited)") )
var Aggregates = map[string]bool{ "avg": true, "bit_and": true, "bit_or": true, "bit_xor": true, "count": true, "group_concat": true, "json_arrayagg": true, "json_objectagg": true, "max": true, "min": true, "std": true, "stddev_pop": true, "stddev_samp": true, "stddev": true, "sum": true, "var_pop": true, "var_samp": true, "variance": true, }
Aggregates is a map of all aggregate functions.
var ErrEmpty = errors.New("empty statement")
ErrEmpty is a sentinel error returned when parsing empty statements.
Functions ¶
func EncodeValue ¶
func EncodeValue(buf *strings.Builder, value *querypb.BindVariable)
EncodeValue encodes one bind variable value into the query.
func ExtractMysqlComment ¶
ExtractMysqlComment extracts the version and SQL from a comment-only query such as /*!50708 sql here */
func FetchBindVar ¶
func FetchBindVar(name string, bindVariables map[string]*querypb.BindVariable) (val *querypb.BindVariable, isList bool, err error)
FetchBindVar resolves the bind variable by fetching it from bindVariables.
func FormatImpossibleQuery ¶
func FormatImpossibleQuery(buf *TrackedBuffer, node SQLNode)
FormatImpossibleQuery creates an impossible query in a TrackedBuffer. An impossible query is a modified version of a query where all selects have where clauses that are impossible for mysql to resolve. This is used in the vtgate and vttablet:
- In the vtgate it's used for joins: if the first query returns no result, then vtgate uses the impossible query just to fetch field info from vttablet - In the vttablet, it's just an optimization: the field info is fetched once form MySQL, cached and reused for subsequent queries
func GetBindvars ¶
GetBindvars returns a map of the bind vars referenced in the statement. TODO(sougou); This function gets called again from vtgate/planbuilder. Ideally, this should be done only once.
func KeywordString ¶
KeywordString returns the string corresponding to the given keyword
func Normalize ¶
func Normalize(stmt Statement, bindVars map[string]*querypb.BindVariable, prefix string)
Normalize changes the statement to use bind values, and updates the bind vars to those values. The supplied prefix is used to generate the bind var names. The function ensures that there are no collisions with existing bind vars. Within Select constructs, bind vars are deduped. This allows us to identify vindex equality. Otherwise, every value is treated as distinct.
func ParseTokenizer ¶
ParseTokenizer is a raw interface to parse from the given tokenizer. This does not used pooled parsers, and should not be used in general.
func RedactSQLQuery ¶
RedactSQLQuery returns a sql string with the params stripped out for display
func SkipQueryPlanCacheDirective ¶
SkipQueryPlanCacheDirective returns true if skip query plan cache directive is set to true in query.
func SplitStatement ¶
SplitStatement returns the first sql statement up to either a ; or EOF and the remainder from the given buffer
func SplitStatementToPieces ¶
SplitStatementToPieces split raw sql statement that may have multi sql pieces to sql pieces returns the sql pieces blob contains; or error if sql cannot be parsed
func StripComments ¶
StripComments removes all comments from the string regardless of where they occur
func StripLeadingComments ¶
StripLeadingComments trims the SQL string and removes any leading comments
func TruncateForLog ¶
TruncateForLog is used when displaying queries as part of error logs to avoid overwhelming logging systems with potentially long queries and bind value data.
func TruncateForUI ¶
TruncateForUI is used when displaying queries on various Vitess status pages to keep the pages small enough to load and render properly
func VarScopeForColName ¶
VarScopeForColName returns the SetScope of the given ColName, along with a new ColName without the scope information.
Types ¶
type AccountLimitItem ¶
type AccountLimitItem struct {
AccountLimitItemType
Count *SQLVal
}
AccountLimitItem represents one of the available account limitations.
type AccountLimitItemType ¶
type AccountLimitItemType byte
AccountLimitItemType defines the type that an AccountLimitItem represents.
const ( AccountLimitItemType_Queries_PH AccountLimitItemType = iota AccountLimitItemType_Updates_PH AccountLimitItemType_Connections_PH AccountLimitItemType_Connections )
type AccountLimits ¶
type AccountLimits struct {
MaxQueriesPerHour *SQLVal
MaxUpdatesPerHour *SQLVal
MaxConnectionsPerHour *SQLVal
MaxUserConnections *SQLVal
}
AccountLimits represents a new user's maximum limits.
func NewAccountLimits ¶
func NewAccountLimits(items []AccountLimitItem) (*AccountLimits, error)
NewAccountLimits returns a new AccountLimits from the given items.
func (*AccountLimits) String ¶
func (al *AccountLimits) String() string
String returns the AccountLimits as a formatted string.
type AccountName ¶
AccountName represents either a user or role name, which has the format `name`@`host`.
func (*AccountName) String ¶
func (an *AccountName) String() string
String returns the AccountName as a formatted string.
type AccountRename ¶
type AccountRename struct {
From AccountName
To AccountName
}
AccountRename represents an account changing its name.
func (*AccountRename) String ¶
func (ar *AccountRename) String() string
String returns the AccountRename as a formatted string.
type AccountWithAuth ¶
type AccountWithAuth struct {
AccountName
Auth1 *Authentication
Auth2 *Authentication
Auth3 *Authentication
AuthInitial *Authentication
}
AccountWithAuth represents a new account with all of its authentication information.
func (*AccountWithAuth) String ¶
func (awa *AccountWithAuth) String() string
String returns AccountWithAuth as a formatted string.
type AliasedExpr ¶
type AliasedExpr struct {
Expr Expr
As ColIdent
StartParsePos int
EndParsePos int
InputExpression string
}
AliasedExpr defines an aliased SELECT expression.
func (*AliasedExpr) Format ¶
func (node *AliasedExpr) Format(buf *TrackedBuffer)
Format formats the node.
type AliasedTableExpr ¶
type AliasedTableExpr struct {
Expr SimpleTableExpr
Partitions Partitions
As TableIdent
Hints *IndexHints
AsOf *AsOf
}
AliasedTableExpr represents a table expression coupled with an optional alias, AS OF expression, and index hints. If As is empty, no alias was used.
func (*AliasedTableExpr) Format ¶
func (node *AliasedTableExpr) Format(buf *TrackedBuffer)
Format formats the node.
func (*AliasedTableExpr) RemoveHints ¶
func (node *AliasedTableExpr) RemoveHints() *AliasedTableExpr
RemoveHints returns a new AliasedTableExpr with the hints removed.
type AsOf ¶
type AsOf struct {
Time Expr
}
func (*AsOf) Format ¶
func (node *AsOf) Format(buf *TrackedBuffer)
type AssignmentExpr ¶
AssignmentExpr represents an assignment expression.
func (*AssignmentExpr) Format ¶
func (node *AssignmentExpr) Format(buf *TrackedBuffer)
Format formats the node.
type AssignmentExprs ¶
type AssignmentExprs []*AssignmentExpr
AssignmentExprs represents a list of assignment expressions.
func (AssignmentExprs) Format ¶
func (node AssignmentExprs) Format(buf *TrackedBuffer)
Format formats the node.
type Authentication ¶
Authentication represents an account's authentication.
func (*Authentication) String ¶
func (auth *Authentication) String() string
String returns this Authentication as a formatted string.
type AutoIncSpec ¶
AutoIncSpec defines an autoincrement value for a ADD AUTO_INCREMENT statement
func (*AutoIncSpec) Format ¶
func (node *AutoIncSpec) Format(buf *TrackedBuffer)
Format formats the node.
type Begin ¶
type Begin struct {
TransactionCharacteristic string
}
Begin represents a Begin statement.
type BeginEndBlock ¶
type BeginEndBlock struct {
Statements Statements
}
BeginEndBlock represents a BEGIN .. END block with one or more statements nested within
func (*BeginEndBlock) Format ¶
func (b *BeginEndBlock) Format(buf *TrackedBuffer)
type BinaryExpr ¶
BinaryExpr represents a binary value expression.
func (*BinaryExpr) Format ¶
func (node *BinaryExpr) Format(buf *TrackedBuffer)
Format formats the node.
type Call ¶
Call represents the CALL statement
func (*Call) Format ¶
func (c *Call) Format(buf *TrackedBuffer)
type CaseStatement ¶
type CaseStatement struct {
Expr Expr // The case expression to switch on
Cases []CaseStatementCase // The set of WHEN values and attached statements
Else Statements // The set of statements for the ELSE clause
}
CaseStatement represents a CASE .. WHEN .. ELSE statement in a stored procedure / trigger
func (*CaseStatement) Format ¶
func (c *CaseStatement) Format(buf *TrackedBuffer)
type CaseStatementCase ¶
type CaseStatementCase struct {
Case Expr // The expression to match for this WHEN clause to match
Statements Statements // The list of statements to execute in the case of a match with Case
}
CaseStatementCase represents a single WHEN .. THEN clause in a CaseStatement
type Characteristic ¶
type Characteristic struct {
Type CharacteristicValue
Comment string
}
func (Characteristic) String ¶
func (c Characteristic) String() string
type CharacteristicValue ¶
type CharacteristicValue string
const ( CharacteristicValue_Comment CharacteristicValue = "comment" CharacteristicValue_LanguageSql CharacteristicValue = "language sql" CharacteristicValue_Deterministic CharacteristicValue = "deterministic" CharacteristicValue_NotDeterministic CharacteristicValue = "not deterministic" CharacteristicValue_ContainsSql CharacteristicValue = "contains sql" CharacteristicValue_NoSql CharacteristicValue = "no sql" CharacteristicValue_ReadsSqlData CharacteristicValue = "reads sql data" CharacteristicValue_ModifiesSqlData CharacteristicValue = "modifies sql data" CharacteristicValue_SqlSecurityDefiner CharacteristicValue = "sql security definer" CharacteristicValue_SqlSecurityInvoker CharacteristicValue = "sql security invoker" )
type CheckConstraintDefinition ¶
func (*CheckConstraintDefinition) Format ¶
func (c *CheckConstraintDefinition) Format(buf *TrackedBuffer)
Format formats the node.
type ColIdent ¶
type ColIdent struct {
// contains filtered or unexported fields
}
ColIdent is a case insensitive SQL identifier. It will be escaped with backquotes if necessary.
func (ColIdent) CompliantName ¶
CompliantName returns a compliant id name that can be used for a bind var.
func (ColIdent) EqualString ¶
EqualString performs a case-insensitive compare with str.
func (ColIdent) Lowered ¶
Lowered returns a lower-cased column name. This function should generally be used only for optimizing comparisons.
func (ColIdent) MarshalJSON ¶
MarshalJSON marshals into JSON.
func (ColIdent) String ¶
String returns the unescaped column name. It must not be used for SQL generation. Use sqlparser.String instead. The Stringer conformance is for usage in templates.
func (*ColIdent) UnmarshalJSON ¶
UnmarshalJSON unmarshals from JSON.
type ColName ¶
type ColName struct {
// Metadata is not populated by the parser.
// It's a placeholder for analyzers to store
// additional data, typically info about which
// table or column this node references.
Metadata interface{}
Name ColIdent
Qualifier TableName
}
ColName represents a column name.
func NewColName ¶
NewColName returns a simple ColName with no table qualifier
func (*ColName) EqualString ¶
Equal returns true if the column name matches the string given. Only true for column names with no qualifier.
type ColTuple ¶
type ColTuple interface {
Expr
// contains filtered or unexported methods
}
ColTuple represents a list of column values. It can be ValTuple, Subquery, ListArg.
type CollateExpr ¶
CollateExpr represents dynamic collate operator.
func (*CollateExpr) Format ¶
func (node *CollateExpr) Format(buf *TrackedBuffer)
Format formats the node.
type ColumnDefinition ¶
type ColumnDefinition struct {
Name ColIdent
Type ColumnType
}
ColumnDefinition describes a column in a CREATE TABLE statement
func (*ColumnDefinition) Format ¶
func (col *ColumnDefinition) Format(buf *TrackedBuffer)
Format formats the node.
type ColumnKeyOption ¶
type ColumnKeyOption int
ColumnKeyOption indicates whether or not the given column is defined as an index element and contains the type of the option
type ColumnOrder ¶
type ColumnOrder struct {
// First is true if this column should be first in the schema
First bool
// AfterColumn is set if this column should be after the one named
AfterColumn ColIdent
}
ColumnOrder is used in some DDL statements to specify or change the order of a column in a schema.
type ColumnType ¶
type ColumnType struct {
// The base type string
Type string
// Generic field options.
NotNull BoolVal
Autoincrement BoolVal
Default Expr
OnUpdate Expr
Comment *SQLVal
// Numeric field options
Length *SQLVal
Unsigned BoolVal
Zerofill BoolVal
Scale *SQLVal
// Text field options
Charset string
Collate string
// Enum values
EnumValues []string
// Key specification
KeyOpt ColumnKeyOption
// contains filtered or unexported fields
}
ColumnType represents a sql type in a CREATE TABLE or ALTER TABLE statement All optional fields are nil if not specified
func (*ColumnType) DescribeType ¶
func (ct *ColumnType) DescribeType() string
DescribeType returns the abbreviated type information as required for describe table
func (*ColumnType) Format ¶
func (ct *ColumnType) Format(buf *TrackedBuffer)
Format returns a canonical string representation of the type and all relevant options
func (*ColumnType) SQLType ¶
func (ct *ColumnType) SQLType() querypb.Type
SQLType returns the sqltypes type code for the given column
func (*ColumnType) String ¶
func (ct *ColumnType) String() string
String returns a canonical string representation of the type and all relevant options
type Columns ¶
type Columns []ColIdent
Columns represents an insert column list.
func (Columns) FindColumn ¶
FindColumn finds a column in the column list, returning the index if it exists or -1 otherwise
type CommentDirectives ¶
type CommentDirectives map[string]interface{}
CommentDirectives is the parsed representation for execution directives conveyed in query comments
func ExtractCommentDirectives ¶
func ExtractCommentDirectives(comments Comments) CommentDirectives
ExtractCommentDirectives parses the comment list for any execution directives of the form:
/*vt+ OPTION_ONE=1 OPTION_TWO OPTION_THREE=abcd */
It returns the map of the directive values or nil if there aren't any.
func (CommentDirectives) IsSet ¶
func (d CommentDirectives) IsSet(key string) bool
IsSet checks the directive map for the named directive and returns true if the directive is set and has a true/false or 0/1 value
type CommonTableExpr ¶
type CommonTableExpr struct {
*AliasedTableExpr
Columns Columns
}
func (*CommonTableExpr) Format ¶
func (e *CommonTableExpr) Format(buf *TrackedBuffer)
type ComparisonExpr ¶
ComparisonExpr represents a two-value comparison expression.
func (*ComparisonExpr) Format ¶
func (node *ComparisonExpr) Format(buf *TrackedBuffer)
Format formats the node.
func (*ComparisonExpr) IsImpossible ¶
func (node *ComparisonExpr) IsImpossible() bool
IsImpossible returns true if the comparison in the expression can never evaluate to true. Note that this is not currently exhaustive to ALL impossible comparisons.
type ConstraintDefinition ¶
type ConstraintDefinition struct {
Name string
Details ConstraintInfo
}
ConstraintDefinition describes a constraint in a CREATE TABLE statement
func (*ConstraintDefinition) Format ¶
func (c *ConstraintDefinition) Format(buf *TrackedBuffer)
Format formats the node.
type ConstraintInfo ¶
type ConstraintInfo interface {
SQLNode
// contains filtered or unexported methods
}
ConstraintInfo details a constraint in a CREATE TABLE statement
type ConvertExpr ¶
type ConvertExpr struct {
Expr Expr
Type *ConvertType
}
ConvertExpr represents a call to CONVERT(expr, type) or it's equivalent CAST(expr AS type). Both are rewritten to the former.
func (*ConvertExpr) Format ¶
func (node *ConvertExpr) Format(buf *TrackedBuffer)
Format formats the node.
type ConvertType ¶
ConvertType represents the type in call to CONVERT(expr, type)
func (*ConvertType) Format ¶
func (node *ConvertType) Format(buf *TrackedBuffer)
Format formats the node.
type ConvertUsingExpr ¶
ConvertUsingExpr represents a call to CONVERT(expr USING charset).
func (*ConvertUsingExpr) Format ¶
func (node *ConvertUsingExpr) Format(buf *TrackedBuffer)
Format formats the node.
type CreateRole ¶
type CreateRole struct {
IfNotExists bool
Roles []AccountName
}
CreateRole represents the CREATE ROLE statement.
func (*CreateRole) Format ¶
func (c *CreateRole) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type CreateUser ¶
type CreateUser struct {
IfNotExists bool
Users []AccountWithAuth
DefaultRoles []AccountName
TLSOptions *TLSOptions
AccountLimits *AccountLimits
PasswordOptions *PasswordOptions
Locked bool
Attribute string
}
CreateUser represents the CREATE USER statement.
func (*CreateUser) Format ¶
func (c *CreateUser) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type CurTimeFuncExpr ¶
type CurTimeFuncExpr struct {
Name ColIdent
Fsp Expr // fractional seconds precision, integer from 0 to 6
}
CurTimeFuncExpr represents the function and arguments for CURRENT DATE/TIME functions supported functions are documented in the grammar
func (*CurTimeFuncExpr) Format ¶
func (node *CurTimeFuncExpr) Format(buf *TrackedBuffer)
Format formats the node.
type DBDDL ¶
type DBDDL struct {
Action string
DBName string
IfNotExists bool
IfExists bool
Collate string
Charset string
}
DBDDL represents a CREATE, DROP database statement.
type DDL ¶
type DDL struct {
Action string
// Set for column alter statements
ColumnAction string
// Set for constraint alter statements
ConstraintAction string
// Set for column add / drop / rename statements
Column ColIdent
// Set for column add / drop / modify statements that specify a column order
ColumnOrder *ColumnOrder
// Set for column rename
ToColumn ColIdent
// FromTables is set if Action is RenameStr or DropStr.
FromTables TableNames
// ToTables is set if Action is RenameStr.
ToTables TableNames
// Table is set if Action is other than RenameStr or DropStr.
Table TableName
// View name.
View TableName
ViewExpr SelectStatement
// This exposes the start and end index of the string that makes up the sub statement of the query given.
// Meaning is specific to the different kinds of statements with sub statements, e.g. views, trigger definitions.
SubStatementPositionStart int
SubStatementPositionEnd int
// FromViews is set if Action is DropStr.
FromViews TableNames
// The following fields are set if a DDL was fully analyzed.
IfExists bool
IfNotExists bool
OrReplace bool
// TableSpec contains the full table spec in case of a create, or a single column in case of an add, drop, or alter.
TableSpec *TableSpec
OptLike *OptLike
PartitionSpec *PartitionSpec
// AutoIncSpec is set for AddAutoIncStr.
AutoIncSpec *AutoIncSpec
// IndexSpec is set for all ALTER operations on an index
IndexSpec *IndexSpec
// DefaultSpec is set for SET / DROP DEFAULT operations
DefaultSpec *DefaultSpec
// TriggerSpec is set for CREATE / ALTER / DROP trigger operations
TriggerSpec *TriggerSpec
// ProcedureSpec is set for CREATE PROCEDURE operations
ProcedureSpec *ProcedureSpec
// Temporary is set for CREATE TEMPORARY TABLE operations.
Temporary bool
// OptSelect is set for CREATE TABLE <> AS SELECT operations.
OptSelect *OptSelect
}
DDL represents a CREATE, ALTER, DROP, RENAME, TRUNCATE or ANALYZE statement.
func (*DDL) AffectedTables ¶
func (node *DDL) AffectedTables() TableNames
AffectedTables returns the list table names affected by the DDL.
func (*DDL) Format ¶
func (node *DDL) Format(buf *TrackedBuffer)
Format formats the node. TODO: add newly added fields here
type Declare ¶
type Declare struct {
Condition *DeclareCondition
Cursor *DeclareCursor
Handler *DeclareHandler
Variables *DeclareVariables
}
Declare represents the DECLARE statement
func (*Declare) Format ¶
func (d *Declare) Format(buf *TrackedBuffer)
type DeclareCondition ¶
DeclareCondition represents the DECLARE CONDITION statement
type DeclareCursor ¶
type DeclareCursor struct {
Name string
SelectStmt SelectStatement
}
DeclareCursor represents the DECLARE CURSOR statement
type DeclareHandler ¶
type DeclareHandler struct {
Action DeclareHandlerAction
ConditionValues []DeclareHandlerCondition
Statement Statement
}
DeclareHandler represents the DECLARE HANDLER statement
type DeclareHandlerAction ¶
type DeclareHandlerAction string
DeclareHandlerAction represents the action for the handler
const ( DeclareHandlerAction_Continue DeclareHandlerAction = "continue" DeclareHandlerAction_Exit DeclareHandlerAction = "exit" DeclareHandlerAction_Undo DeclareHandlerAction = "undo" )
type DeclareHandlerCondition ¶
type DeclareHandlerCondition struct {
ValueType DeclareHandlerConditionValue
MysqlErrorCode *SQLVal
String string // May hold either the SqlState or condition name
}
DeclareHandlerCondition represents the conditions for a handler
type DeclareHandlerConditionValue ¶
type DeclareHandlerConditionValue string
DeclareHandlerConditionValue represents the condition values for a handler
const ( DeclareHandlerCondition_MysqlErrorCode DeclareHandlerConditionValue = "mysql_err_code" DeclareHandlerCondition_SqlState DeclareHandlerConditionValue = "sqlstate" DeclareHandlerCondition_ConditionName DeclareHandlerConditionValue = "condition_name" DeclareHandlerCondition_SqlWarning DeclareHandlerConditionValue = "sqlwarning" DeclareHandlerCondition_NotFound DeclareHandlerConditionValue = "not_found" DeclareHandlerCondition_SqlException DeclareHandlerConditionValue = "sqlexception" )
type DeclareVariables ¶
type DeclareVariables struct {
Names []ColIdent
VarType ColumnType
}
DeclareVariables represents the DECLARE statement for declaring variables
type DefaultSpec ¶
DefaultSpec defines a SET / DROP on a column for its default value.
func (*DefaultSpec) Format ¶
func (node *DefaultSpec) Format(buf *TrackedBuffer)
Format implements SQLNode.
type Delete ¶
type Delete struct {
Comments Comments
Targets TableNames
TableExprs TableExprs
Partitions Partitions
Where *Where
OrderBy OrderBy
Limit *Limit
}
Delete represents a DELETE statement. If you add fields here, consider adding them to calls to validateUnshardedRoute.
type DropRole ¶
type DropRole struct {
IfExists bool
Roles []AccountName
}
DropRole represents the DROP ROLE statement.
func (*DropRole) Format ¶
func (d *DropRole) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type DropUser ¶
type DropUser struct {
IfExists bool
AccountNames []AccountName
}
DropUser represents the DROP USER statement.
func (*DropUser) Format ¶
func (d *DropUser) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type EnclosedBy ¶
func (*EnclosedBy) Format ¶
func (node *EnclosedBy) Format(buf *TrackedBuffer)
type ExistsExpr ¶
type ExistsExpr struct {
Subquery *Subquery
}
ExistsExpr represents an EXISTS expression.
func (*ExistsExpr) Format ¶
func (node *ExistsExpr) Format(buf *TrackedBuffer)
Format formats the node.
type Expr ¶
type Expr interface {
SQLNode
// contains filtered or unexported methods
}
Expr represents an expression.
func ExprFromValue ¶
ExprFromValue converts the given Value into an Expr or returns an error.
func ReplaceExpr ¶
ReplaceExpr finds the from expression from root and replaces it with to. If from matches root, then to is returned.
type Exprs ¶
type Exprs []Expr
Exprs represents a list of value expressions. It's not a valid expression because it's not parenthesized.
type Fields ¶
type Fields struct {
TerminatedBy *SQLVal
*EnclosedBy
EscapedBy *SQLVal
SQLNode
}
func (*Fields) Format ¶
func (node *Fields) Format(buf *TrackedBuffer)
type ForeignKeyDefinition ¶
type ForeignKeyDefinition struct {
Source Columns
ReferencedTable TableName
ReferencedColumns Columns
OnDelete ReferenceAction
OnUpdate ReferenceAction
}
ForeignKeyDefinition describes a foreign key
func (*ForeignKeyDefinition) Format ¶
func (f *ForeignKeyDefinition) Format(buf *TrackedBuffer)
Format formats the node.
type FuncExpr ¶
type FuncExpr struct {
Qualifier TableIdent
Name ColIdent
Distinct bool
Exprs SelectExprs
Over *Over
}
FuncExpr represents a function call.
func (*FuncExpr) IsAggregate ¶
IsAggregate returns true if the function is an aggregate.
type GrantObjectType ¶
type GrantObjectType byte
GrantObjectType represents the object type that the GRANT or REVOKE statement will apply to.
const ( GrantObjectType_Any GrantObjectType = iota GrantObjectType_Table GrantObjectType_Function GrantObjectType_Procedure )
type GrantPrivilege ¶
type GrantPrivilege struct {
Privileges []Privilege
ObjectType GrantObjectType
PrivilegeLevel PrivilegeLevel
To []AccountName
WithGrantOption bool
As *GrantUserAssumption
}
GrantPrivilege represents the GRANT...ON...TO statement.
func (*GrantPrivilege) Format ¶
func (g *GrantPrivilege) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type GrantProxy ¶
type GrantProxy struct {
On AccountName
To []AccountName
WithGrantOption bool
}
GrantProxy represents the GRANT PROXY statement.
func (*GrantProxy) Format ¶
func (g *GrantProxy) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type GrantRole ¶
type GrantRole struct {
Roles []AccountName
To []AccountName
WithAdminOption bool
}
GrantRole represents the GRANT...TO statement.
func (*GrantRole) Format ¶
func (g *GrantRole) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type GrantUserAssumption ¶
type GrantUserAssumption struct {
Type GrantUserAssumptionType
User AccountName
Roles []AccountName
}
GrantUserAssumption represents the target user that the user executing the GRANT statement will assume the identity of.
func (*GrantUserAssumption) String ¶
func (gau *GrantUserAssumption) String() string
String returns this GrantUserAssumption as a formatted string.
type GrantUserAssumptionType ¶
type GrantUserAssumptionType byte
GrantUserAssumptionType is the assumption type that the user executing the GRANT statement will use.
const ( GrantUserAssumptionType_Default GrantUserAssumptionType = iota GrantUserAssumptionType_None GrantUserAssumptionType_All GrantUserAssumptionType_AllExcept GrantUserAssumptionType_Roles )
type GroupConcatExpr ¶
type GroupConcatExpr struct {
Distinct string
Exprs SelectExprs
OrderBy OrderBy
Separator string
}
GroupConcatExpr represents a call to GROUP_CONCAT
func (*GroupConcatExpr) Format ¶
func (node *GroupConcatExpr) Format(buf *TrackedBuffer)
Format formats the node
type IfStatement ¶
type IfStatement struct {
Conditions []IfStatementCondition // The initial IF condition, followed by any ELSEIF conditions, in order.
Else Statements // The statements of the ELSE clause, if any
}
IfStatement represents an IF .. THEN .. ELSE statement in a stored procedure / trigger.
func (*IfStatement) Format ¶
func (i *IfStatement) Format(buf *TrackedBuffer)
type IfStatementCondition ¶
type IfStatementCondition struct {
Expr Expr
Statements Statements
}
IfStatementCondition represents a single IF / ELSEIF branch in an IfStatement
type IndexColumn ¶
IndexColumn describes a column in an index definition with optional length and direction
type IndexDefinition ¶
type IndexDefinition struct {
Info *IndexInfo
Columns []*IndexColumn
Options []*IndexOption
}
IndexDefinition describes an index in a CREATE TABLE statement
func (*IndexDefinition) Format ¶
func (idx *IndexDefinition) Format(buf *TrackedBuffer)
Format formats the node.
type IndexHints ¶
IndexHints represents a list of index hints.
func (*IndexHints) Format ¶
func (node *IndexHints) Format(buf *TrackedBuffer)
Format formats the node.
type IndexOption ¶
IndexOption is used for trailing options for indexes: COMMENT, KEY_BLOCK_SIZE, USING
type IndexSpec ¶
type IndexSpec struct {
// Action states whether it's a CREATE, DROP, or RENAME
Action string
// FromName states the old name when renaming
FromName ColIdent
// ToName states the name to set when renaming or references the target table
ToName ColIdent
// Using states whether you're using BTREE, HASH, or none
Using ColIdent
// Type specifies whether this is UNIQUE, FULLTEXT, SPATIAL, or normal (nothing)
Type string
// Columns contains the column names when creating an index
Columns []*IndexColumn
// Options contains the index options when creating an index
Options []*IndexOption
}
IndexSpec describes an index operation in an ALTER statement
func (*IndexSpec) Format ¶
func (idx *IndexSpec) Format(buf *TrackedBuffer)
type Insert ¶
type Insert struct {
Action string
Comments Comments
Ignore string
Table TableName
Partitions Partitions
Columns Columns
Rows InsertRows
OnDup OnDup
}
Insert represents an INSERT or REPLACE statement. Per the MySQL docs, http://dev.mysql.com/doc/refman/5.7/en/replace.html Replace is the counterpart to `INSERT IGNORE`, and works exactly like a normal INSERT except if the row exists. In that case it first deletes the row and re-inserts with new values. For that reason we keep it as an Insert struct.
type InsertRows ¶
type InsertRows interface {
SQLNode
// contains filtered or unexported methods
}
InsertRows represents the rows for an INSERT statement.
type InsertValues ¶
InsertValues is a custom SQL encoder for the values of an insert statement.
func (InsertValues) EncodeSQL ¶
func (iv InsertValues) EncodeSQL(buf *strings.Builder)
EncodeSQL performs the SQL encoding for InsertValues.
type IntervalExpr ¶
IntervalExpr represents a date-time INTERVAL expression.
func (*IntervalExpr) Format ¶
func (node *IntervalExpr) Format(buf *TrackedBuffer)
Format formats the node.
type JoinCondition ¶
JoinCondition represents the join conditions (either a ON or USING clause) of a JoinTableExpr.
func (JoinCondition) Format ¶
func (node JoinCondition) Format(buf *TrackedBuffer)
Format formats the node.
type JoinTableExpr ¶
type JoinTableExpr struct {
LeftExpr TableExpr
Join string
RightExpr TableExpr
Condition JoinCondition
}
JoinTableExpr represents a TableExpr that's a JOIN operation.
func (*JoinTableExpr) Format ¶
func (node *JoinTableExpr) Format(buf *TrackedBuffer)
Format formats the node.
type LengthScaleOption ¶
LengthScaleOption is used for types that have an optional length and scale
type Load ¶
type Load struct {
Local BoolVal
Infile string
Table TableName
Partition Partitions
Charset string
*Fields
*Lines
IgnoreNum *SQLVal
Columns
}
Load represents a LOAD statement
func (*Load) Format ¶
func (node *Load) Format(buf *TrackedBuffer)
type LoadStatement ¶
type LoadStatement interface {
SQLNode
// contains filtered or unexported methods
}
LoadStatement any LOAD statement.
type LockTables ¶
type LockTables struct {
Tables TableAndLockTypes
SQLNode
}
LockTables represents the lock statement
func (*LockTables) Format ¶
func (node *LockTables) Format(buf *TrackedBuffer)
type MarginComments ¶
MarginComments holds the leading and trailing comments that surround a query.
func SplitMarginComments ¶
func SplitMarginComments(sql string) (query string, comments MarginComments)
SplitMarginComments pulls out any leading or trailing comments from a raw sql query. This function also trims leading (if there's a comment) and trailing whitespace.
type MatchExpr ¶
type MatchExpr struct {
Columns SelectExprs
Expr Expr
Option string
}
MatchExpr represents a call to the MATCH function
func (*MatchExpr) Format ¶
func (node *MatchExpr) Format(buf *TrackedBuffer)
Format formats the node
type MultiAlterDDL ¶
MultiAlterDDL represents multiple ALTER statements on a single table.
func (*MultiAlterDDL) Format ¶
func (m *MultiAlterDDL) Format(buf *TrackedBuffer)
Format implements SQLNode.
type NodeFormatter ¶
type NodeFormatter func(buf *TrackedBuffer, node SQLNode)
NodeFormatter defines the signature of a custom node formatter function that can be given to TrackedBuffer for code generation.
type OptLike ¶
type OptLike struct {
LikeTable TableName
}
OptLike works for create table xxx like xxx
type OptSelect ¶
type OptSelect struct {
Select SelectStatement
}
func (*OptSelect) Format ¶
func (node *OptSelect) Format(buf *TrackedBuffer)
Format formats the node.
type OtherAdmin ¶
type OtherAdmin struct{}
OtherAdmin represents a misc statement that relies on ADMIN privileges, such as REPAIR, OPTIMIZE, or TRUNCATE statement. It should be used only as an indicator. It does not contain the full AST for the statement.
func (*OtherAdmin) Format ¶
func (node *OtherAdmin) Format(buf *TrackedBuffer)
Format formats the node.
type OtherRead ¶
type OtherRead struct{}
OtherRead represents a DESCRIBE, or EXPLAIN statement. It should be used only as an indicator. It does not contain the full AST for the statement.
func (*OtherRead) Format ¶
func (node *OtherRead) Format(buf *TrackedBuffer)
Format formats the node.
type ParenExpr ¶
type ParenExpr struct {
Expr Expr
}
ParenExpr represents a parenthesized boolean expression.
func (*ParenExpr) Format ¶
func (node *ParenExpr) Format(buf *TrackedBuffer)
Format formats the node.
type ParenSelect ¶
type ParenSelect struct {
Select SelectStatement
}
ParenSelect is a parenthesized SELECT statement.
func (*ParenSelect) AddOrder ¶
func (node *ParenSelect) AddOrder(order *Order)
AddOrder adds an order by element
func (*ParenSelect) Format ¶
func (node *ParenSelect) Format(buf *TrackedBuffer)
Format formats the node.
func (*ParenSelect) SetLimit ¶
func (node *ParenSelect) SetLimit(limit *Limit)
SetLimit sets the limit clause
func (*ParenSelect) SetLock ¶
func (node *ParenSelect) SetLock(lock string)
func (*ParenSelect) SetOrderBy ¶
func (node *ParenSelect) SetOrderBy(orders OrderBy)
type ParenTableExpr ¶
type ParenTableExpr struct {
Exprs TableExprs
}
ParenTableExpr represents a parenthesized list of TableExpr.
func (*ParenTableExpr) Format ¶
func (node *ParenTableExpr) Format(buf *TrackedBuffer)
Format formats the node.
type ParsedQuery ¶
type ParsedQuery struct {
Query string
// contains filtered or unexported fields
}
ParsedQuery represents a parsed query where bind locations are precompued for fast substitutions.
func BuildParsedQuery ¶
func BuildParsedQuery(in string, vars ...interface{}) *ParsedQuery
BuildParsedQuery builds a ParsedQuery from the input.
func NewParsedQuery ¶
func NewParsedQuery(node SQLNode) *ParsedQuery
NewParsedQuery returns a ParsedQuery of the ast.
func (*ParsedQuery) Append ¶
func (pq *ParsedQuery) Append(buf *strings.Builder, bindVariables map[string]*querypb.BindVariable, extras map[string]Encodable) error
Append appends the generated query to the provided buffer.
func (*ParsedQuery) GenerateQuery ¶
func (pq *ParsedQuery) GenerateQuery(bindVariables map[string]*querypb.BindVariable, extras map[string]Encodable) (string, error)
GenerateQuery generates a query by substituting the specified bindVariables. The extras parameter specifies special parameters that can perform custom encoding.
func (*ParsedQuery) MarshalJSON ¶
func (pq *ParsedQuery) MarshalJSON() ([]byte, error)
MarshalJSON is a custom JSON marshaler for ParsedQuery. Note that any queries longer that 512 bytes will be truncated.
type PartitionDefinition ¶
PartitionDefinition describes a very minimal partition definition
func (*PartitionDefinition) Format ¶
func (node *PartitionDefinition) Format(buf *TrackedBuffer)
Format formats the node
type PartitionSpec ¶
type PartitionSpec struct {
Action string
Name ColIdent
Definitions []*PartitionDefinition
}
PartitionSpec describe partition actions (for alter and create)
func (*PartitionSpec) Format ¶
func (node *PartitionSpec) Format(buf *TrackedBuffer)
Format formats the node.
type Partitions ¶
type Partitions Columns
Partitions is a type alias for Columns so we can handle printing efficiently
func (Partitions) Format ¶
func (node Partitions) Format(buf *TrackedBuffer)
Format formats the node
type PassLockItem ¶
type PassLockItem struct {
PassLockItemType
Value *SQLVal
}
PassLockItem represents one of the available password or account options.
type PassLockItemType ¶
type PassLockItemType byte
PassLockItemType defines the type that a PassLockItem represents.
const ( PassLockItemType_PassExpireDefault PassLockItemType = iota PassLockItemType_PassExpireNever PassLockItemType_PassExpireInterval PassLockItemType_PassHistory PassLockItemType_PassReuseInterval PassLockItemType_PassReqCurrentDefault PassLockItemType_PassReqCurrentOptional PassLockItemType_PassFailedLogins PassLockItemType_PassLockTime PassLockItemType_AccountLock PassLockItemType_AccountUnlock )
type PasswordOptions ¶
type PasswordOptions struct {
RequireCurrentOptional bool
ExpirationTime *SQLVal // nil represents the default
History *SQLVal // nil represents the default
ReuseInterval *SQLVal // nil represents the default
FailedAttempts *SQLVal // will always be set
LockTime *SQLVal // nil represents an unbounded lock time
}
PasswordOptions represents which options may be given to new user account on how to handle passwords.
func NewPasswordOptionsWithLock ¶
func NewPasswordOptionsWithLock(items []PassLockItem) (*PasswordOptions, bool)
NewPasswordOptionsWithLock returns a new PasswordOptions, along with whether to lock the account, from the given items.
func (*PasswordOptions) String ¶
func (po *PasswordOptions) String() string
String returns PasswordOptions as a formatted string.
type Privilege ¶
type Privilege struct {
Type PrivilegeType
DynamicName string
Columns []string
}
Privilege specifies a privilege to be used in a GRANT or REVOKE statement.
type PrivilegeLevel ¶
PrivilegeLevel defines the level that a privilege applies to.
func (*PrivilegeLevel) String ¶
func (p *PrivilegeLevel) String() string
String returns the PrivilegeLevel as a formatted string.
type PrivilegeType ¶
type PrivilegeType byte
PrivilegeType is the type of privilege that is being granted or revoked.
const ( PrivilegeType_All PrivilegeType = iota PrivilegeType_Alter PrivilegeType_AlterRoutine PrivilegeType_Create PrivilegeType_CreateRole PrivilegeType_CreateRoutine PrivilegeType_CreateTablespace PrivilegeType_CreateTemporaryTables PrivilegeType_CreateUser PrivilegeType_CreateView PrivilegeType_Delete PrivilegeType_Drop PrivilegeType_DropRole PrivilegeType_Event PrivilegeType_Execute PrivilegeType_File PrivilegeType_GrantOption PrivilegeType_Index PrivilegeType_Insert PrivilegeType_LockTables PrivilegeType_Process PrivilegeType_References PrivilegeType_Reload PrivilegeType_ReplicationClient PrivilegeType_ReplicationSlave PrivilegeType_Select PrivilegeType_ShowDatabases PrivilegeType_ShowView PrivilegeType_Shutdown PrivilegeType_Super PrivilegeType_Trigger PrivilegeType_Update PrivilegeType_Usage PrivilegeType_Dynamic // Dynamic privileges are defined at runtime, rather than enforced at the parser )
type ProcedureParam ¶
type ProcedureParam struct {
Direction ProcedureParamDirection
Name string
Type ColumnType
}
type ProcedureParamDirection ¶
type ProcedureParamDirection string
const ( ProcedureParamDirection_In ProcedureParamDirection = "in" ProcedureParamDirection_Inout ProcedureParamDirection = "inout" ProcedureParamDirection_Out ProcedureParamDirection = "out" )
type ProcedureSpec ¶
type ProcedureSpec struct {
Name string
Definer string
Params []ProcedureParam
Characteristics []Characteristic
Body Statement
}
type RangeCond ¶
RangeCond represents a BETWEEN or a NOT BETWEEN expression.
func (*RangeCond) Format ¶
func (node *RangeCond) Format(buf *TrackedBuffer)
Format formats the node.
type ReferenceAction ¶
type ReferenceAction int
ReferenceAction indicates the action takes by a referential constraint e.g. the `CASCADE` in a `FOREIGN KEY .. ON DELETE CASCADE` table definition.
const ( // DefaultAction indicates no action was explicitly specified. DefaultAction ReferenceAction = iota Restrict Cascade NoAction SetNull SetDefault )
These map to the SQL-defined reference actions. See https://dev.mysql.com/doc/refman/8.0/en/create-table-foreign-keys.html#foreign-keys-referential-actions
func (ReferenceAction) Format ¶
func (a ReferenceAction) Format(buf *TrackedBuffer)
Format formats the node.
type ReleaseSavepoint ¶
type ReleaseSavepoint struct {
Identifier string
}
ReleaseSavepoint represents a RELEASE SAVEPOINT statement.
func (*ReleaseSavepoint) Format ¶
func (node *ReleaseSavepoint) Format(buf *TrackedBuffer)
Format implements the SQLNode interface.
type RenameUser ¶
type RenameUser struct {
Accounts []AccountRename
}
RenameUser represents the RENAME USER statement.
func (*RenameUser) Format ¶
func (r *RenameUser) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type Resignal ¶
type Resignal struct {
Signal
}
Resignal represents the RESIGNAL statement
func (*Resignal) Format ¶
func (s *Resignal) Format(buf *TrackedBuffer)
type RevokeAllPrivileges ¶
type RevokeAllPrivileges struct {
From []AccountName
}
RevokeAllPrivileges represents the REVOKE ALL statement.
func (*RevokeAllPrivileges) Format ¶
func (r *RevokeAllPrivileges) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type RevokePrivilege ¶
type RevokePrivilege struct {
Privileges []Privilege
ObjectType GrantObjectType
PrivilegeLevel PrivilegeLevel
From []AccountName
}
RevokePrivilege represents the REVOKE...ON...FROM statement.
func (*RevokePrivilege) Format ¶
func (r *RevokePrivilege) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type RevokeProxy ¶
type RevokeProxy struct {
On AccountName
From []AccountName
}
RevokeProxy represents the REVOKE PROXY statement.
func (*RevokeProxy) Format ¶
func (r *RevokeProxy) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type RevokeRole ¶
type RevokeRole struct {
Roles []AccountName
From []AccountName
}
RevokeRole represents the REVOKE...FROM statement.
func (*RevokeRole) Format ¶
func (r *RevokeRole) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type RollbackSavepoint ¶
type RollbackSavepoint struct {
Identifier string
}
RollbackSavepoint represents a ROLLBACK TO statement.
func (*RollbackSavepoint) Format ¶
func (node *RollbackSavepoint) Format(buf *TrackedBuffer)
Format implements the SQLNode interface.
type SQLNode ¶
type SQLNode interface {
Format(buf *TrackedBuffer)
// contains filtered or unexported methods
}
SQLNode defines the interface for all nodes generated by the parser.
type SQLVal ¶
SQLVal represents a single value.
type Savepoint ¶
type Savepoint struct {
Identifier string
}
Savepoint represents a SAVEPOINT statement.
func (*Savepoint) Format ¶
func (node *Savepoint) Format(buf *TrackedBuffer)
Format implements the SQLNode interface.
type Select ¶
type Select struct {
Cache string
CalcFoundRows bool
Comments Comments
Distinct string
Hints string
CommonTableExprs TableExprs
SelectExprs SelectExprs
From TableExprs
Where *Where
GroupBy GroupBy
Having *Where
OrderBy OrderBy
Limit *Limit
Lock string
}
Select represents a SELECT statement.
func (*Select) AddHaving ¶
AddHaving adds the boolean expression to the HAVING clause as an AND condition. If the expression is an OR clause, it parenthesizes it. Currently, the OR operator is the only one that's lower precedence than AND.
func (*Select) AddWhere ¶
AddWhere adds the boolean expression to the WHERE clause as an AND condition. If the expression is an OR clause, it parenthesizes it. Currently, the OR operator is the only one that's lower precedence than AND.
func (*Select) SetOrderBy ¶
type SelectExpr ¶
type SelectExpr interface {
SQLNode
// contains filtered or unexported methods
}
SelectExpr represents a SELECT expression.
type SelectExprs ¶
type SelectExprs []SelectExpr
SelectExprs represents SELECT expressions.
func (SelectExprs) Format ¶
func (node SelectExprs) Format(buf *TrackedBuffer)
Format formats the node.
type SelectStatement ¶
type SelectStatement interface {
AddOrder(*Order)
SetLimit(*Limit)
SetLock(string)
SetOrderBy(OrderBy)
SQLNode
// contains filtered or unexported methods
}
SelectStatement any SELECT statement.
type SetScope ¶
type SetScope string
SetScope represents the scope of the set expression.
func VarScope ¶
VarScope returns the SetScope of the given name, broken into parts. For example, `@@GLOBAL.sys_var` would become `[]string{"@@GLOBAL", "sys_var"}`. Returns the variable name without any scope specifiers, so the aforementioned variable would simply return "sys_var". `[]string{"@@other_var"}` would return "other_var". If the name parts do not specify a variable (returns SetScope_None), then it is recommended to use the original non-broken string, as this will always only return the last part. `[]string{"my_db", "my_tbl", "my_col"}` will return "my_col" with SetScope_None.
type SetVarExpr ¶
SetVarExpr represents a set expression.
func (*SetVarExpr) Format ¶
func (node *SetVarExpr) Format(buf *TrackedBuffer)
Format formats the node.
type SetVarExprs ¶
type SetVarExprs []*SetVarExpr
SetVarExprs represents a list of set expressions.
func (SetVarExprs) Format ¶
func (node SetVarExprs) Format(buf *TrackedBuffer)
Format formats the node.
type Show ¶
type Show struct {
Type string
OnTable TableName
Table TableName
Database string
IfNotExists bool
ShowTablesOpt *ShowTablesOpt
Scope string
ShowCollationFilterOpt *Expr
ShowIndexFilterOpt Expr
Filter *ShowFilter
}
Show represents a show statement.
func (*Show) HasOnTable ¶
HasOnTable returns true if the show statement has an "on" clause
type ShowFilter ¶
ShowFilter is show tables filter
func (*ShowFilter) Format ¶
func (node *ShowFilter) Format(buf *TrackedBuffer)
Format formats the node.
type ShowGrants ¶
type ShowGrants struct {
CurrentUser bool
For *AccountName
Using []AccountName
}
ShowGrants represents the SHOW GRANTS statement.
func (*ShowGrants) Format ¶
func (s *ShowGrants) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type ShowPrivileges ¶
type ShowPrivileges struct{}
ShowPrivileges represents the SHOW PRIVILEGES statement.
func (*ShowPrivileges) Format ¶
func (s *ShowPrivileges) Format(buf *TrackedBuffer)
Format implements the interface Statement.
type ShowTablesOpt ¶
type ShowTablesOpt struct {
Full string
DbName string
Filter *ShowFilter
AsOf Expr
}
ShowTablesOpt is show tables option
type Signal ¶
type Signal struct {
ConditionName string // Previously declared condition name
SqlStateValue string // Always a 5-character string
Info []SignalInfo // The list of name-value pairs of signal information provided
}
Signal represents the SIGNAL statement
func (*Signal) Format ¶
func (s *Signal) Format(buf *TrackedBuffer)
type SignalConditionItemName ¶
type SignalConditionItemName string
SignalConditionItemName represents the item name for the set conditions of a SIGNAL statement.
const ( SignalConditionItemName_ClassOrigin SignalConditionItemName = "class_origin" SignalConditionItemName_SubclassOrigin SignalConditionItemName = "subclass_origin" SignalConditionItemName_MessageText SignalConditionItemName = "message_text" SignalConditionItemName_MysqlErrno SignalConditionItemName = "mysql_errno" SignalConditionItemName_ConstraintCatalog SignalConditionItemName = "constraint_catalog" SignalConditionItemName_ConstraintSchema SignalConditionItemName = "constraint_schema" SignalConditionItemName_ConstraintName SignalConditionItemName = "constraint_name" SignalConditionItemName_CatalogName SignalConditionItemName = "catalog_name" SignalConditionItemName_SchemaName SignalConditionItemName = "schema_name" SignalConditionItemName_TableName SignalConditionItemName = "table_name" SignalConditionItemName_ColumnName SignalConditionItemName = "column_name" SignalConditionItemName_CursorName SignalConditionItemName = "cursor_name" )
type SignalInfo ¶
type SignalInfo struct {
ConditionItemName SignalConditionItemName
Value *SQLVal
}
SignalInfo represents a piece of information for a SIGNAL statement
type SimpleTableExpr ¶
type SimpleTableExpr interface {
SQLNode
// contains filtered or unexported methods
}
SimpleTableExpr represents a simple table expression.
type StarExpr ¶
type StarExpr struct {
TableName TableName
}
StarExpr defines a '*' or 'table.*' expression.
type Statement ¶
type Statement interface {
SQLNode
// contains filtered or unexported methods
}
Statement represents a statement.
func Parse ¶
Parse parses the SQL in full and returns a Statement, which is the AST representation of the query. If a DDL statement is partially parsed but still contains a syntax error, the error is ignored and the DDL is returned anyway.
func ParseNext ¶
ParseNext parses a single SQL statement from the tokenizer returning a Statement which is the AST representation of the query. The tokenizer will always read up to the end of the statement, allowing for the next call to ParseNext to parse any subsequent SQL statements. When there are no more statements to parse, a error of io.EOF is returned.
func ParseNextStrictDDL ¶
ParseNextStrictDDL is the same as ParseNext except it errors on partially parsed DDL statements.
func ParseStrictDDL ¶
ParseStrictDDL is the same as Parse except it errors on partially parsed DDL statements.
type Statements ¶
type Statements []Statement
type Stream ¶
type Stream struct {
Comments Comments
SelectExpr SelectExpr
Table TableName
}
Stream represents a SELECT statement.
type Subquery ¶
type Subquery struct {
Select SelectStatement
Columns Columns
}
Subquery represents a subquery.
type SubstrExpr ¶
SubstrExpr represents a call to SubstrExpr(column, value_expression) or SubstrExpr(column, value_expression,value_expression) also supported syntax SubstrExpr(column from value_expression for value_expression). Additionally to column names, SubstrExpr is also supported for string values, e.g.: SubstrExpr('static string value', value_expression, value_expression) In this case StrVal will be set instead of Name.
func (*SubstrExpr) Format ¶
func (node *SubstrExpr) Format(buf *TrackedBuffer)
Format formats the node.
type TLSOptionItem ¶
type TLSOptionItem struct {
TLSOptionItemType
ItemData string
}
TLSOptionItem represents one of the available TLS options.
type TLSOptionItemType ¶
type TLSOptionItemType byte
TLSOptionItemType defines the type that a TLSOptionItem represents.
const ( TLSOptionItemType_SSL TLSOptionItemType = iota TLSOptionItemType_X509 TLSOptionItemType_Cipher TLSOptionItemType_Issuer TLSOptionItemType_Subject )
type TLSOptions ¶
TLSOptions represents a new user's TLS options.
func NewTLSOptions ¶
func NewTLSOptions(items []TLSOptionItem) (*TLSOptions, error)
NewTLSOptions returns a new TLSOptions from the given items.
func (*TLSOptions) String ¶
func (tls *TLSOptions) String() string
String returns the TLSOptions as a formatted string.
type TableAndLockType ¶
TableAndLockType contains table and lock association
func (*TableAndLockType) Format ¶
func (node *TableAndLockType) Format(buf *TrackedBuffer)
type TableAndLockTypes ¶
type TableAndLockTypes []*TableAndLockType
type TableExpr ¶
type TableExpr interface {
SQLNode
// contains filtered or unexported methods
}
TableExpr represents a table expression.
type TableExprs ¶
type TableExprs []TableExpr
TableExprs represents a list of table expressions.
func (TableExprs) Format ¶
func (node TableExprs) Format(buf *TrackedBuffer)
Format formats the node.
type TableIdent ¶
type TableIdent struct {
// contains filtered or unexported fields
}
TableIdent is a case sensitive SQL identifier. It will be escaped with backquotes if necessary.
func NewTableIdent ¶
func NewTableIdent(str string) TableIdent
NewTableIdent creates a new TableIdent.
func (TableIdent) CompliantName ¶
func (node TableIdent) CompliantName() string
CompliantName returns a compliant id name that can be used for a bind var.
func (TableIdent) Format ¶
func (node TableIdent) Format(buf *TrackedBuffer)
Format formats the node.
func (TableIdent) IsEmpty ¶
func (node TableIdent) IsEmpty() bool
IsEmpty returns true if TabIdent is empty.
func (TableIdent) MarshalJSON ¶
func (node TableIdent) MarshalJSON() ([]byte, error)
MarshalJSON marshals into JSON.
func (TableIdent) String ¶
func (node TableIdent) String() string
String returns the unescaped table name. It must not be used for SQL generation. Use sqlparser.String instead. The Stringer conformance is for usage in templates.
func (*TableIdent) UnmarshalJSON ¶
func (node *TableIdent) UnmarshalJSON(b []byte) error
UnmarshalJSON unmarshals from JSON.
type TableName ¶
type TableName struct {
Name, Qualifier TableIdent
}
TableName represents a table name. Qualifier, if specified, represents a database or keyspace. TableName is a value struct whose fields are case sensitive. This means two TableName vars can be compared for equality and a TableName can also be used as key in a map.
func (TableName) ToViewName ¶
ToViewName returns a TableName acceptable for use as a VIEW. VIEW names are always lowercase, so ToViewName lowercasese the name. Databases are case-sensitive so Qualifier is left untouched.
type TableNames ¶
type TableNames []TableName
TableNames is a list of TableName.
func (TableNames) Format ¶
func (node TableNames) Format(buf *TrackedBuffer)
Format formats the node.
type TableSpec ¶
type TableSpec struct {
Columns []*ColumnDefinition
Indexes []*IndexDefinition
Constraints []*ConstraintDefinition
Options string
}
TableSpec describes the structure of a table from a CREATE TABLE statement
func (*TableSpec) AddColumn ¶
func (ts *TableSpec) AddColumn(cd *ColumnDefinition)
AddColumn appends the given column to the list in the spec
func (*TableSpec) AddConstraint ¶
func (ts *TableSpec) AddConstraint(cd *ConstraintDefinition)
AddConstraint appends the given index to the list in the spec
func (*TableSpec) AddIndex ¶
func (ts *TableSpec) AddIndex(id *IndexDefinition)
AddIndex appends the given index to the list in the spec
type TimestampFuncExpr ¶
TimestampFuncExpr represents the function and arguments for TIMESTAMP{ADD,DIFF} functions.
func (*TimestampFuncExpr) Format ¶
func (node *TimestampFuncExpr) Format(buf *TrackedBuffer)
Format formats the node.
type Tokenizer ¶
type Tokenizer struct {
InStream io.Reader
AllowComments bool
SkipSpecialComments bool
SkipToEnd bool
Position int
OldPosition int
LastError error
ParseTree Statement
// contains filtered or unexported fields
}
Tokenizer is the struct used to generate SQL tokens for the parser.
func NewStringTokenizer ¶
NewStringTokenizer creates a new Tokenizer for the sql string.
func NewTokenizer ¶
NewTokenizer creates a new Tokenizer reading a sql string from the io.Reader.
type TrackedBuffer ¶
TrackedBuffer is used to rebuild a query from the ast. bindLocations keeps track of locations in the buffer that use bind variables for efficient future substitutions. nodeFormatter is the formatting function the buffer will use to format a node. By default(nil), it's FormatNode. But you can supply a different formatting function if you want to generate a query that's different from the default.
func NewTrackedBuffer ¶
func NewTrackedBuffer(nodeFormatter NodeFormatter) *TrackedBuffer
NewTrackedBuffer creates a new TrackedBuffer.
func (*TrackedBuffer) HasBindVars ¶
func (buf *TrackedBuffer) HasBindVars() bool
HasBindVars returns true if the parsed query uses bind vars.
func (*TrackedBuffer) Myprintf ¶
func (buf *TrackedBuffer) Myprintf(format string, values ...interface{})
Myprintf mimics fmt.Fprintf(buf, ...), but limited to Node(%v), Node.Value(%s) and string(%s). It also allows a %a for a value argument, in which case it adds tracking info for future substitutions.
The name must be something other than the usual Printf() to avoid "go vet" warnings due to our custom format specifiers.
func (*TrackedBuffer) ParsedQuery ¶
func (buf *TrackedBuffer) ParsedQuery() *ParsedQuery
ParsedQuery returns a ParsedQuery that contains bind locations for easy substitution.
func (*TrackedBuffer) WriteArg ¶
func (buf *TrackedBuffer) WriteArg(arg string)
WriteArg writes a value argument into the buffer along with tracking information for future substitutions. arg must contain the ":" or "::" prefix.
func (*TrackedBuffer) WriteNode ¶
func (buf *TrackedBuffer) WriteNode(node SQLNode) *TrackedBuffer
WriteNode function, initiates the writing of a single SQLNode tree by passing through to Myprintf with a default format string
type TriggerOrder ¶
type TriggerSpec ¶
type TriggerSpec struct {
Name string
Time string // BeforeStr, AfterStr
Event string // UpdateStr, InsertStr, DeleteStr
Order *TriggerOrder
Body Statement
}
type TupleEqualityList ¶
TupleEqualityList is for generating equality constraints for tables that have composite primary keys.
func (*TupleEqualityList) EncodeSQL ¶
func (tpl *TupleEqualityList) EncodeSQL(buf *strings.Builder)
EncodeSQL generates the where clause constraints for the tuple equality.
type UnaryExpr ¶
UnaryExpr represents a unary value expression.
func (*UnaryExpr) Format ¶
func (node *UnaryExpr) Format(buf *TrackedBuffer)
Format formats the node.
type Union ¶
type Union struct {
Type string
Left, Right SelectStatement
OrderBy OrderBy
Limit *Limit
Lock string
}
Union represents a UNION statement.
func (*Union) SetOrderBy ¶
type UnlockTables ¶
type UnlockTables struct{}
UnlockTables represents the unlock statement
func (*UnlockTables) Format ¶
func (node *UnlockTables) Format(buf *TrackedBuffer)
type Update ¶
type Update struct {
Comments Comments
Ignore string
TableExprs TableExprs
Exprs AssignmentExprs
Where *Where
OrderBy OrderBy
Limit *Limit
}
Update represents an UPDATE statement. If you add fields here, consider adding them to calls to validateUnshardedRoute.
type ValuesFuncExpr ¶
type ValuesFuncExpr struct {
Name *ColName
}
ValuesFuncExpr represents a function call.
func (*ValuesFuncExpr) Format ¶
func (node *ValuesFuncExpr) Format(buf *TrackedBuffer)
Format formats the node.
type ValuesStatement ¶
ValuesStatement is a VALUES ROW('1', '2'), ROW(3, 4) expression, which can be a table factor or a stand-alone statement
func (*ValuesStatement) Format ¶
func (s *ValuesStatement) Format(buf *TrackedBuffer)
type Visit ¶
Visit defines the signature of a function that can be used to visit all nodes of a parse tree.
Source Files