README
¶
go-sql2struct
sqlparser
摘自 https://github.com/vitessio/vitess
Usage
import ( "github.com/Bill-cc/go-sql2struct" )
example
Documentation
¶
Index ¶
- Constants
- Variables
- func Append(buf *strings.Builder, node SQLNode)
- func CanNormalize(stmt Statement) bool
- func Convert(e Expr) (evalengine.Expr, error)
- func EncodeValue(buf *strings.Builder, value *querypb.BindVariable)
- func ExtractMysqlComment(sql string) (string, string)
- func FetchBindVar(name string, bindVariables map[string]*querypb.BindVariable) (val *querypb.BindVariable, isList bool, err error)
- func FormatImpossibleQuery(buf *TrackedBuffer, node SQLNode)
- func Fuzz(data []byte) int
- func GetBindvars(stmt Statement) map[string]struct{}
- func IgnoreMaxMaxMemoryRowsDirective(stmt Statement) bool
- func IgnoreMaxPayloadSizeDirective(stmt Statement) bool
- func IsColName(node Expr) bool
- func IsDML(sql string) bool
- func IsDMLStatement(stmt Statement) bool
- func IsLockingFunc(node Expr) bool
- func IsNull(node Expr) bool
- func IsSetStatement(stmt Statement) bool
- func IsSimpleTuple(node Expr) bool
- func IsValue(node Expr) bool
- func IsVschemaDDL(ddl DDLStatement) bool
- func KeywordString(id int) string
- func LikeToRegexp(likeExpr string) *regexp.Regexp
- func NewPlanValue(node Expr) (sqltypes.PlanValue, error)
- func Normalize(stmt Statement, bindVars map[string]*querypb.BindVariable, prefix string)
- func NormalizeAlphabetically(query string) (normalized string, err error)
- func ParseTable(input string) (keyspace, table string, err error)
- func ParseTokenizer(tokenizer *Tokenizer) int
- func QueryMatchesTemplates(query string, queryTemplates []string) (match bool, err error)
- 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 StripLeadingComments(sql string) string
- func TruncateForLog(query string) string
- func TruncateForUI(query string) string
- func Walk(visit Visit, nodes ...SQLNode) error
- type AccessMode
- type AliasedExpr
- type AliasedTableExpr
- type AndExpr
- type ApplyFunc
- type Argument
- type AtCount
- type AutoIncSpec
- type Begin
- type BinaryExpr
- type BinaryExprOperator
- type BindVarNeeds
- func (bvn *BindVarNeeds) AddFuncResult(name string)
- func (bvn *BindVarNeeds) AddSysVar(name string)
- func (bvn *BindVarNeeds) AddUserDefVar(name string)
- func (bvn *BindVarNeeds) HasRewrites() bool
- func (bvn *BindVarNeeds) MergeWith(other *BindVarNeeds)
- func (bvn *BindVarNeeds) NeedsFuncResult(name string) bool
- func (bvn *BindVarNeeds) NeedsSysVar(name string) bool
- func (bvn *BindVarNeeds) NoteRewrite()
- type BoolVal
- type CaseExpr
- type Characteristic
- type CheckConstraintDefinition
- type ColIdent
- func (node ColIdent) AtCount() AtCount
- 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 ColumnType
- type Columns
- type CommentDirectives
- type Comments
- type Commit
- type ComparisonExpr
- type ComparisonExprOperator
- type ConstraintDefinition
- type ConstraintInfo
- type ConvertExpr
- type ConvertType
- type ConvertTypeOperator
- type ConvertUsingExpr
- type CreateIndex
- func (node *CreateIndex) AffectedTables() TableNames
- func (node *CreateIndex) Format(buf *TrackedBuffer)
- func (node *CreateIndex) GetAction() DDLAction
- func (node *CreateIndex) GetTable() TableName
- func (node *CreateIndex) IsFullyParsed() bool
- func (node *CreateIndex) SetTable(qualifier string, name string)
- type CurTimeFuncExpr
- type Cursor
- type DBDDL
- type DBDDLAction
- type DDL
- type DDLAction
- type DDLStatement
- type Default
- type Delete
- type DerivedTable
- type Encodable
- type ExistsExpr
- type Explain
- type ExplainType
- type Expr
- type Exprs
- type ForeignKeyDefinition
- type FuncExpr
- type GroupBy
- type GroupConcatExpr
- type Ignore
- type IndexColumn
- type IndexDefinition
- type IndexHints
- type IndexHintsType
- type IndexInfo
- type IndexOption
- type Insert
- type InsertAction
- type InsertRows
- type InsertValues
- type IntervalExpr
- type IsExpr
- type IsExprOperator
- type IsolationLevel
- type JoinCondition
- type JoinTableExpr
- type JoinType
- type LengthScaleOption
- type Limit
- type ListArg
- type Literal
- type Load
- type Lock
- type MarginComments
- type MatchExpr
- type MatchExprOption
- type Nextval
- type NodeFormatter
- type NotExpr
- type NullVal
- type OnDup
- type OptLike
- type OrExpr
- type Order
- type OrderBy
- type OrderDirection
- type OtherAdmin
- type OtherRead
- type ParenSelect
- type ParenTableExpr
- type ParsedQuery
- type PartitionDefinition
- type PartitionSpec
- type PartitionSpecAction
- type Partitions
- type PositionedErr
- type Precendence
- type RangeCond
- type RangeCondOperator
- type ReferenceAction
- type Release
- type RewriteASTResult
- type Rollback
- type SQLNode
- type SRollback
- type Savepoint
- type Scope
- type Select
- type SelectExpr
- type SelectExprs
- type SelectInto
- type SelectIntoType
- type SelectStatement
- type Set
- type SetExpr
- type SetExprs
- type SetTransaction
- type Show
- type ShowColumns
- type ShowFilter
- type ShowInternal
- type ShowLegacy
- type ShowTableStatus
- type ShowTablesOpt
- type SimpleTableExpr
- type StarExpr
- type Statement
- type StatementType
- type Stream
- type Subquery
- type SubstrExpr
- type TableExpr
- type TableExprs
- type TableIdent
- type TableName
- type TableNames
- type TableSpec
- type TimestampFuncExpr
- type Tokenizer
- type TrackedBuffer
- type TupleEqualityList
- type UnaryExpr
- type UnaryExprOperator
- type Union
- type UnionSelect
- type Update
- type UpdateExpr
- type UpdateExprs
- type Use
- type VStream
- type ValTuple
- type ValType
- type Values
- type ValuesFuncExpr
- type VindexParam
- type VindexSpec
- type Visit
- type When
- type Where
- type WhereType
- type XorExpr
Constants ¶
const ( StrVal = ValType(iota) IntVal FloatVal HexNum HexVal 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 ( // 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" // DirectiveIgnoreMaxPayloadSize skips payload size validation when set. DirectiveIgnoreMaxPayloadSize = "IGNORE_MAX_PAYLOAD_SIZE" // DirectiveIgnoreMaxMemoryRows skips memory row validation when set. DirectiveIgnoreMaxMemoryRows = "IGNORE_MAX_MEMORY_ROWS" )
const ( // Select.Distinct DistinctStr = "distinct " StraightJoinHint = "straight_join " SQLCalcFoundRowsStr = "sql_calc_found_rows " // Select.Lock NoLockStr = "" ForUpdateStr = " for update" // Select.Cache SQLCacheStr = "sql_cache " SQLNoCacheStr = "sql_no_cache " // Union.Type UnionStr = "union" UnionAllStr = "union all" UnionDistinctStr = "union distinct" // DDL strings. InsertStr = "insert" ReplaceStr = "replace" // Set.Scope or Show.Scope SessionStr = "session" GlobalStr = "global" VitessMetadataStr = "vitess_metadata" VariableStr = "variable" LocalStr = "local" ImplicitStr = "" // DDL strings. CreateStr = "create" AlterStr = "alter" DropStr = "drop" RenameStr = "rename" TruncateStr = "truncate" FlushStr = "flush" CreateVindexStr = "create vindex" DropVindexStr = "drop vindex" AddVschemaTableStr = "add vschema table" DropVschemaTableStr = "drop vschema table" AddColVindexStr = "on table add vindex" DropColVindexStr = "on table drop vindex" AddSequenceStr = "add sequence" AddAutoIncStr = "add auto_increment" // Online DDL hint OnlineStr = "online" // Vindex DDL param to specify the owner of a vindex VindexOwnerStr = "owner" // Partition strings ReorganizeStr = "reorganize partition" // JoinTableExpr.Join JoinStr = "join" StraightJoinStr = "straight_join" LeftJoinStr = "left join" RightJoinStr = "right join" NaturalJoinStr = "natural join" NaturalLeftJoinStr = "natural left join" NaturalRightJoinStr = "natural right join" // Index hints. UseStr = "use " IgnoreStr = "ignore " ForceStr = "force " // Where.Type WhereStr = "where" HavingStr = "having" // ComparisonExpr.Operator EqualStr = "=" LessThanStr = "<" GreaterThanStr = ">" LessEqualStr = "<=" GreaterEqualStr = ">=" NotEqualStr = "!=" NullSafeEqualStr = "<=>" InStr = "in" NotInStr = "not in" LikeStr = "like" NotLikeStr = "not like" RegexpStr = "regexp" NotRegexpStr = "not regexp" // RangeCond.Operator BetweenStr = "between" NotBetweenStr = "not between" // IsExpr.Operator IsNullStr = "is null" IsNotNullStr = "is not null" IsTrueStr = "is true" IsNotTrueStr = "is not true" IsFalseStr = "is false" IsNotFalseStr = "is not false" // BinaryExpr.Operator BitAndStr = "&" BitOrStr = "|" BitXorStr = "^" PlusStr = "+" MinusStr = "-" MultStr = "*" DivStr = "/" IntDivStr = "div" ModStr = "%" ShiftLeftStr = "<<" ShiftRightStr = ">>" JSONExtractOpStr = "->" JSONUnquoteExtractOpStr = "->>" // UnaryExpr.Operator UPlusStr = "+" UMinusStr = "-" TildaStr = "~" BangStr = "!" BinaryStr = "binary " UBinaryStr = "_binary " Utf8mb4Str = "_utf8mb4 " Utf8Str = "_utf8 " Latin1Str = "_latin1 " // ConvertType.Operator CharacterSetStr = " character set" NoOperatorStr = "" CharsetStr = "charset" // MatchExpr.Option NoOptionStr = "" BooleanModeStr = " in boolean mode" NaturalLanguageModeStr = " in natural language mode" NaturalLanguageModeWithQueryExpansionStr = " in natural language mode with query expansion" QueryExpansionStr = " with query expansion" // INTO OUTFILE IntoOutfileStr = " into outfile " IntoOutfileS3Str = " into outfile s3 " IntoDumpfileStr = " into dumpfile " // Order.Direction AscScr = "asc" DescScr = "desc" // SetExpr.Expr, for SET TRANSACTION ... or START TRANSACTION // TransactionStr is the Name for a SET TRANSACTION statement TransactionStr = "transaction" // Transaction isolation levels ReadUncommittedStr = "read uncommitted" ReadCommittedStr = "read committed" RepeatableReadStr = "repeatable read" SerializableStr = "serializable" TxReadOnly = "read only" TxReadWrite = "read write" // Explain formats EmptyStr = "" TreeStr = "tree" JSONStr = "json" VitessStr = "vitess" TraditionalStr = "traditional" AnalyzeStr = "analyze" )
const ( //LastInsertIDName is a reserved bind var name for last_insert_id() LastInsertIDName = "__lastInsertId" //DBVarName is a reserved bind var name for database() DBVarName = "__vtdbname" //FoundRowsName is a reserved bind var name for found_rows() FoundRowsName = "__vtfrows" //RowCountName is a reserved bind var name for row_count() RowCountName = "__vtrcount" //UserDefinedVariableName is what we prepend bind var names for user defined variables UserDefinedVariableName = "__vtudv" )
const ACTION = 57493
const ACTIVE = 57656
const ADD = 57476
const ADMIN = 57657
const AGAINST = 57624
const ALGORITHM = 57418
const ALL = 57363
const ALTER = 57472
const ANALYZE = 57475
const AND = 57441
const APPROXNUM = 57572
const ARRAY = 57631
const AS = 57365
const ASC = 57367
const AT_AT_ID = 57424
const AT_ID = 57423
const AUTO_INCREMENT = 57571
const BEGIN = 57521
const BETWEEN = 57443
const BIGINT = 57535
const BINARY = 57463
const BIT = 57529
const BIT_LITERAL = 57434
const BLOB = 57556
const BOOL = 57548
const BOOLEAN = 57625
const BUCKETS = 57658
const BY = 57359
const CASCADE = 57494
const CASE = 57444
const CAST = 57616
const CHAR = 57546
const CHARACTER = 57549
const CHARSET = 57593
const CHECK = 57491
const CLONE = 57659
const COLLATE = 57462
const COLLATION = 57576
const COLUMN = 57487
const COLUMNS = 57583
const COMMENT = 57432
const COMMENT_KEYWORD = 57433
const COMMIT = 57524
const COMMITTED = 57602
const COMPONENT = 57660
const CONSTRAINT = 57495
const CONVERT = 57615
const COPY = 57417
const CREATE = 57471
const CROSS = 57410
const CSV = 57389
const CUME_DIST = 57632
const CURRENT_DATE = 57607
const CURRENT_TIME = 57608
const CURRENT_TIMESTAMP = 57605
const DATA = 57382
const DATABASE = 57606
const DATABASES = 57577
const DATE = 57503
const DATETIME = 57544
const DECIMAL = 57540
const DEFAULT = 57372
const DEFINITION = 57661
const DELETE = 57353
const DENSE_RANK = 57634
const DESC = 57368
const DESCRIBE = 57501
const DESCRIPTION = 57633
const DISTINCT = 57364
const DISTINCTROW = 57378
const DIV = 57459
const DO = 57377
const DOUBLE = 57538
const DROP = 57473
const DUMPFILE = 57388
const DUPLICATE = 57370
const ELSE = 57447
const EMPTY = 57635
const ENCLOSED = 57387
const END = 57448
const ENFORCED = 57662
const ENGINES = 57585
const ENUM = 57561
const ESCAPE = 57504
const ESCAPED = 57386
const EXCEPT = 57636
const EXCLUDE = 57663
const EXCLUSIVE = 57421
const EXISTS = 57366
const EXPANSION = 57629
const EXPLAIN = 57502
const EXTENDED = 57587
const FALSE = 57437
const FIELDS = 57584
const FIRST_VALUE = 57637
const FLOAT = 57428
const FLOAT_TYPE = 57539
const FLUSH = 57477
const FOLLOWING = 57664
const FOR = 57362
const FORCE = 57413
const FOREIGN = 57496
const FORMAT = 57712
const FROM = 57354
const FULL = 57581
const FULLTEXT = 57489
const GE = 57450
const GEOMCOLLECTION = 57665
const GEOMETRY = 57562
const GEOMETRYCOLLECTION = 57566
const GET_MASTER_PUBLIC_KEY = 57666
const GLOBAL = 57594
const GROUP = 57356
const GROUPING = 57638
const GROUPS = 57639
const GROUP_CONCAT = 57619
const HAVING = 57357
const HEADER = 57390
const HEX = 57425
const HEXNUM = 57429
const HISTOGRAM = 57667
const HISTORY = 57668
const ID = 57422
const IF = 57484
const IGNORE = 57483
const IN = 57456
const INACTIVE = 57669
const INDEX = 57480
const INDEXES = 57492
const INNER = 57408
const INPLACE = 57416
const INSERT = 57351
const INT = 57533
const INTEGER = 57534
const INTEGRAL = 57427
const INTERVAL = 57468
const INTNUM = 57536
const INTO = 57369
const INVISIBLE = 57670
const IS = 57453
const ISOLATION = 57596
const JOIN = 57404
const JSON = 57560
const JSON_EXTRACT_OP = 57469
const JSON_TABLE = 57640
const JSON_UNQUOTE_EXTRACT_OP = 57470
const KEY = 57371
const KEYS = 57376
const KEYSPACES = 57588
const KEY_BLOCK_SIZE = 57490
const LAG = 57641
const LANGUAGE = 57626
const LAST_INSERT_ID = 57396
const LAST_VALUE = 57642
const LATERAL = 57643
const LE = 57449
const LEAD = 57644
const LEFT = 57406
const LESS = 57511
const LEVEL = 57597
const LEX_ERROR = 57346
const LIKE = 57454
const LIMIT = 57360
const LINES = 57384
const LINESTRING = 57564
const LIST_ARG = 57431
const LOAD = 57383
const LOCALTIME = 57609
const LOCALTIMESTAMP = 57610
const LOCK = 57374
const LOCKED = 57671
const LONGBLOB = 57559
const LONGTEXT = 57555
const MANIFEST = 57391
const MASTER_COMPRESSION_ALGORITHMS = 57672
const MASTER_PUBLIC_KEY_PATH = 57673
const MASTER_TLS_CIPHERSUITES = 57674
const MASTER_ZSTD_COMPRESSION_LEVEL = 57675
const MATCH = 57623
const MAXVALUE = 57508
const MEDIUMBLOB = 57558
const MEDIUMINT = 57532
const MEDIUMTEXT = 57554
const MEMBER = 57645
const MOD = 57460
const MODE = 57400
const MULTILINESTRING = 57568
const MULTIPOINT = 57567
const MULTIPOLYGON = 57569
const NAMES = 57592
const NATURAL = 57411
const NCHAR = 57551
const NE = 57451
const NESTED = 57676
const NETWORK_NAMESPACE = 57677
const NEXT = 57397
const NO = 57497
const NONE = 57419
const NOT = 57442
const NOWAIT = 57678
const NTH_VALUE = 57646
const NTILE = 57647
const NULL = 57435
const NULLS = 57679
const NULLX = 57570
const NULL_SAFE_EQUAL = 57452
const NUMERIC = 57541
const OF = 57648
const OFF = 57438
const OFFSET = 57361
const OJ = 57680
const OLD = 57681
const ON = 57414
const ONLY = 57600
const OPTIMIZE = 57506
const OPTIONAL = 57682
const OPTIONALLY = 57394
const OR = 57439
const ORDER = 57358
const ORDINALITY = 57683
const ORGANIZATION = 57684
const OTHERS = 57685
const OUTER = 57409
const OUTFILE = 57380
const OVER = 57649
const OVERWRITE = 57392
const PARSER = 57379
const PARTITION = 57509
const PATH = 57686
const PERCENT_RANK = 57650
const PERSIST = 57687
const PERSIST_ONLY = 57688
const PLUGINS = 57586
const POINT = 57563
const POLYGON = 57565
const PRECEDING = 57689
const PRIMARY = 57486
const PRIVILEGE_CHECKS_USER = 57690
const PROCEDURE = 57513
const PROCESS = 57691
const PROCESSLIST = 57582
const QUERY = 57628
const RANDOM = 57692
const RANK = 57651
const READ = 57598
const REAL = 57537
const RECURSIVE = 57652
const REFERENCE = 57693
const REFERENCES = 57498
const REGEXP = 57455
const RELEASE = 57527
const RENAME = 57474
const REORGANIZE = 57510
const REPAIR = 57505
const REPEATABLE = 57601
const REPLACE = 57614
const REQUIRE_ROW_FORMAT = 57694
const RESOURCE = 57695
const RESPECT = 57696
const RESTART = 57697
const RESTRICT = 57499
const RETAIN = 57698
const REUSE = 57699
const RIGHT = 57407
const ROLE = 57700
const ROLLBACK = 57525
const ROW_NUMBER = 57653
const S3 = 57381
const SAVEPOINT = 57526
const SCHEMA = 57478
const SECONDARY = 57701
const SECONDARY_ENGINE = 57702
const SECONDARY_LOAD = 57703
const SECONDARY_UNLOAD = 57704
const SELECT = 57348
const SEPARATOR = 57620
const SEQUENCE = 57520
const SERIALIZABLE = 57604
const SESSION = 57595
const SET = 57373
const SHARE = 57399
const SHARED = 57420
const SHIFT_LEFT = 57457
const SHIFT_RIGHT = 57458
const SHOW = 57500
const SIGNED = 57573
const SKIP = 57705
const SMALLINT = 57531
const SPATIAL = 57488
const SQL_CACHE = 57402
const SQL_CALC_FOUND_ROWS = 57403
const SQL_NO_CACHE = 57401
const SRID = 57706
const START = 57522
const STARTING = 57393
const STATUS = 57517
const STRAIGHT_JOIN = 57405
const STREAM = 57349
const STRING = 57426
const SUBSTR = 57617
const SUBSTRING = 57618
const SYSTEM = 57654
const TABLE = 57479
const TABLES = 57578
const TERMINATED = 57385
const TEXT = 57552
const THAN = 57512
const THEN = 57446
const THREAD_PRIORITY = 57707
const TIES = 57708
const TIME = 57542
const TIMESTAMP = 57543
const TIMESTAMPADD = 57621
const TIMESTAMPDIFF = 57622
const TINYBLOB = 57557
const TINYINT = 57530
const TINYTEXT = 57553
const TO = 57482
const TRADITIONAL = 57715
const TRANSACTION = 57523
const TREE = 57713
const TRIGGER = 57514
const TRUE = 57436
const TRUNCATE = 57507
const UNARY = 57461
const UNBOUNDED = 57709
const UNCOMMITTED = 57603
const UNDERSCORE_BINARY = 57464
const UNDERSCORE_LATIN1 = 57467
const UNDERSCORE_UTF8 = 57466
const UNDERSCORE_UTF8MB4 = 57465
const UNION = 57347
const UNIQUE = 57485
const UNLOCK = 57375
const UNSIGNED = 57574
const UNUSED = 57630
const UPDATE = 57352
const USE = 57412
const USING = 57415
const UTC_DATE = 57611
const UTC_TIME = 57612
const UTC_TIMESTAMP = 57613
const VALUE = 57398
const VALUES = 57395
const VALUE_ARG = 57430
const VARBINARY = 57550
const VARCHAR = 57547
const VARIABLES = 57518
const VCPU = 57710
const VIEW = 57481
const VINDEX = 57515
const VINDEXES = 57516
const VISIBLE = 57711
const VITESS = 57714
const VITESS_KEYSPACES = 57589
const VITESS_METADATA = 57579
const VITESS_SHARDS = 57590
const VITESS_TABLETS = 57591
const VSCHEMA = 57580
const VSTREAM = 57350
const WARNINGS = 57519
const WHEN = 57445
const WHERE = 57355
const WINDOW = 57655
const WITH = 57627
const WORK = 57528
const WRITE = 57599
const XOR = 57440
const YEAR = 57545
const ZEROFILL = 57575
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, "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.
var ErrExprNotSupported = fmt.Errorf("Expr Not Supported")
ErrExprNotSupported signals that the expression cannot be handled by expression evaluation engine.
Functions ¶
func CanNormalize ¶
CanNormalize takes Statement and returns if the statement can be normalized.
func Convert ¶
func Convert(e Expr) (evalengine.Expr, error)
Convert converts between AST expressions and executable expressions
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 IgnoreMaxMaxMemoryRowsDirective ¶
IgnoreMaxMaxMemoryRowsDirective returns true if the max memory rows override directive is set to true.
func IgnoreMaxPayloadSizeDirective ¶
IgnoreMaxPayloadSizeDirective returns true if the max payload size override directive is set to true.
func IsDMLStatement ¶
IsDMLStatement returns true if the query is an INSERT, UPDATE or DELETE statement.
func IsLockingFunc ¶
IsLockingFunc returns true for all functions that are used to work with mysql advisory locks
func IsSetStatement ¶
IsSetStatement takes Statement and returns if the statement is set statement.
func IsSimpleTuple ¶
IsSimpleTuple returns true if the Expr is a ValTuple that contains simple values or if it's a list arg.
func IsValue ¶
IsValue returns true if the Expr is a string, integral or value arg. NULL is not considered to be a value.
func IsVschemaDDL ¶
func IsVschemaDDL(ddl DDLStatement) bool
IsVschemaDDL returns true if the query is an Vschema alter ddl.
func KeywordString ¶
KeywordString returns the string corresponding to the given keyword
func LikeToRegexp ¶
LikeToRegexp converts a like sql expression to regular expression
func NewPlanValue ¶
NewPlanValue builds a sqltypes.PlanValue from an Expr.
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 NormalizeAlphabetically ¶
NormalizeAlphabetically rewrites given query such that: - WHERE 'AND' expressions are reordered alphabetically
func ParseTable ¶
ParseTable parses the input as a qualified table name. It handles all valid literal escaping.
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 QueryMatchesTemplates ¶
QueryMatchesTemplates sees if the given query has the same fingerprint as one of the given templates (one is enough)
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 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
Types ¶
type AccessMode ¶
type AccessMode int8
AccessMode is enum for the mode - ReadOnly or ReadWrite
const ( ReadOnly AccessMode = iota ReadWrite )
Constants for Enum type - AccessMode
func (AccessMode) Format ¶
func (node AccessMode) Format(buf *TrackedBuffer)
Format formats the node.
type AliasedExpr ¶
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
}
AliasedTableExpr represents a table expression coupled with an optional alias or index hint. 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 ApplyFunc ¶
An ApplyFunc is invoked by Rewrite for each node n, even if n is nil, before and/or after the node's children, using a Cursor describing the current node and providing operations on it.
The return value of ApplyFunc controls the syntax tree traversal. See Rewrite for details.
type AutoIncSpec ¶
AutoIncSpec defines and autoincrement value for a ADD AUTO_INCREMENT statement
func (*AutoIncSpec) Format ¶
func (node *AutoIncSpec) Format(buf *TrackedBuffer)
Format formats the node.
type BinaryExpr ¶
type BinaryExpr struct {
Operator BinaryExprOperator
Left, Right Expr
}
BinaryExpr represents a binary value expression.
func (*BinaryExpr) Format ¶
func (node *BinaryExpr) Format(buf *TrackedBuffer)
Format formats the node.
type BinaryExprOperator ¶
type BinaryExprOperator int8
BinaryExprOperator is an enum for BinaryExpr.Operator
const ( BitAndOp BinaryExprOperator = iota BitOrOp BitXorOp PlusOp MinusOp MultOp DivOp IntDivOp ModOp ShiftLeftOp ShiftRightOp JSONExtractOp JSONUnquoteExtractOp )
Constant for Enum Type - BinaryExprOperator
func (BinaryExprOperator) ToString ¶
func (op BinaryExprOperator) ToString() string
ToString returns the operator as a string
type BindVarNeeds ¶
type BindVarNeeds struct {
NeedFunctionResult,
NeedSystemVariable,
NeedUserDefinedVariables []string
// contains filtered or unexported fields
}
BindVarNeeds represents the bind vars that need to be provided as the result of expression rewriting.
func (*BindVarNeeds) AddFuncResult ¶
func (bvn *BindVarNeeds) AddFuncResult(name string)
AddFuncResult adds a function bindvar need
func (*BindVarNeeds) AddSysVar ¶
func (bvn *BindVarNeeds) AddSysVar(name string)
AddSysVar adds a system variable bindvar need
func (*BindVarNeeds) AddUserDefVar ¶
func (bvn *BindVarNeeds) AddUserDefVar(name string)
AddUserDefVar adds a user defined variable bindvar need
func (*BindVarNeeds) HasRewrites ¶
func (bvn *BindVarNeeds) HasRewrites() bool
func (*BindVarNeeds) MergeWith ¶
func (bvn *BindVarNeeds) MergeWith(other *BindVarNeeds)
MergeWith adds bind vars needs coming from sub scopes
func (*BindVarNeeds) NeedsFuncResult ¶
func (bvn *BindVarNeeds) NeedsFuncResult(name string) bool
NeedsFuncResult says if a function result needs to be provided
func (*BindVarNeeds) NeedsSysVar ¶
func (bvn *BindVarNeeds) NeedsSysVar(name string) bool
NeedsSysVar says if a function result needs to be provided
func (*BindVarNeeds) NoteRewrite ¶
func (bvn *BindVarNeeds) NoteRewrite()
type Characteristic ¶
type Characteristic interface {
SQLNode
// contains filtered or unexported methods
}
Characteristic is a transaction related change
type CheckConstraintDefinition ¶
CheckConstraintDefinition describes a check constraint in a CREATE TABLE statement
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 NewColIdentWithAt ¶
NewColIdentWithAt makes a new ColIdent.
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.
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
// TODO: Should this not be a reference?
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 ColumnType ¶
type ColumnType struct {
// The base type string
Type string
// Generic field options.
NotNull bool
Autoincrement bool
Default Expr
OnUpdate Expr
Comment *Literal
// Numeric field options
Length *Literal
Unsigned bool
Zerofill bool
Scale *Literal
// Text field options
Charset string
Collate string
// Enum values
EnumValues []string
// Key specification
KeyOpt ColumnKeyOption
}
ColumnType represents a sql type in a CREATE 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
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 ComparisonExpr ¶
type ComparisonExpr struct {
Operator ComparisonExprOperator
Left, Right Expr
Escape Expr
}
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 ComparisonExprOperator ¶
type ComparisonExprOperator int8
ComparisonExprOperator is an enum for ComparisonExpr.Operator
const ( EqualOp ComparisonExprOperator = iota LessThanOp GreaterThanOp LessEqualOp GreaterEqualOp NotEqualOp NullSafeEqualOp InOp NotInOp LikeOp NotLikeOp RegexpOp NotRegexpOp )
Constants for Enum Type - ComparisonExprOperator
func (ComparisonExprOperator) ToString ¶
func (op ComparisonExprOperator) ToString() string
ToString returns the operator as a string
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 ¶
type ConvertType struct {
Type string
Length *Literal
Scale *Literal
Operator ConvertTypeOperator
Charset string
}
ConvertType represents the type in call to CONVERT(expr, type)
func (*ConvertType) Format ¶
func (node *ConvertType) Format(buf *TrackedBuffer)
Format formats the node.
type ConvertTypeOperator ¶
type ConvertTypeOperator int8
ConvertTypeOperator is an enum for ConvertType.Operator
const ( NoOperator ConvertTypeOperator = iota CharacterSetOp )
Constant for Enum Type - ConvertTypeOperator
func (ConvertTypeOperator) ToString ¶
func (op ConvertTypeOperator) ToString() string
ToString returns the operator as a string
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 CreateIndex ¶
type CreateIndex struct {
Constraint string
Name ColIdent
IndexType string
Table TableName
Columns []*IndexColumn
Options []*IndexOption
FullyParsed bool
}
CreateIndex represents a CREATE INDEX query
func (*CreateIndex) AffectedTables ¶
func (node *CreateIndex) AffectedTables() TableNames
AffectedTables implements DDLStatement.
func (*CreateIndex) Format ¶
func (node *CreateIndex) Format(buf *TrackedBuffer)
Format formats the node.
func (*CreateIndex) GetAction ¶
func (node *CreateIndex) GetAction() DDLAction
GetAction implements the DDLStatement interface
func (*CreateIndex) GetTable ¶
func (node *CreateIndex) GetTable() TableName
GetTable implements the DDLStatement interface
func (*CreateIndex) IsFullyParsed ¶
func (node *CreateIndex) IsFullyParsed() bool
IsFullyParsed implements the DDLStatement interface
func (*CreateIndex) SetTable ¶
func (node *CreateIndex) SetTable(qualifier string, name string)
SetTable implements DDLStatement.
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 Cursor ¶
type Cursor struct {
// contains filtered or unexported fields
}
A Cursor describes a node encountered during Apply. Information about the node and its parent is available from the Node and Parent methods.
type DBDDL ¶
type DBDDL struct {
Action DBDDLAction
DBName string
IfExists bool
IfNotExists bool
Collate string
Charset string
}
DBDDL represents a CREATE, DROP, or ALTER database statement.
type DBDDLAction ¶
type DBDDLAction int8
DBDDLAction is an enum for DBDDL Actions
const ( CreateDBDDLAction DBDDLAction = iota AlterDBDDLAction DropDBDDLAction )
Constants for Enum Type - DBDDL.Action
type DDL ¶
type DDL struct {
Action DDLAction
// FromTables is set if Action is RenameDDLAction or DropDDLAction.
FromTables TableNames
// ToTables is set if Action is RenameDDLAction.
ToTables TableNames
// Table is set if Action is other than RenameDDLAction or DropDDLAction.
Table TableName
// The following fields are set if a DDL was fully analyzed.
IfExists bool
TableSpec *TableSpec
OptLike *OptLike
PartitionSpec *PartitionSpec
// VindexSpec is set for CreateVindexDDLAction, DropVindexDDLAction, AddColVindexDDLAction, DropColVindexDDLAction.
VindexSpec *VindexSpec
// VindexCols is set for AddColVindexDDLAction.
VindexCols []ColIdent
// AutoIncSpec is set for AddAutoIncDDLAction.
AutoIncSpec *AutoIncSpec
}
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 DDLStatement.
func (*DDL) IsFullyParsed ¶
IsFullyParsed implements the DDLStatement interface
type DDLAction ¶
type DDLAction int8
DDLAction is an enum for DDL.Action
const ( CreateDDLAction DDLAction = iota AlterDDLAction DropDDLAction RenameDDLAction TruncateDDLAction FlushDDLAction CreateVindexDDLAction DropVindexDDLAction AddVschemaTableDDLAction DropVschemaTableDDLAction AddColVindexDDLAction DropColVindexDDLAction AddSequenceDDLAction AddAutoIncDDLAction )
Constants for Enum Type - DDL.Action
type DDLStatement ¶
type DDLStatement interface {
IsFullyParsed() bool
GetTable() TableName
GetAction() DDLAction
AffectedTables() TableNames
SetTable(qualifier string, name string)
Statement
// contains filtered or unexported methods
}
DDLStatement represents any DDL Statement
type Delete ¶
type Delete struct {
Ignore Ignore
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 DerivedTable ¶
type DerivedTable struct {
Select SelectStatement
}
DerivedTable represents a subquery used as a table expression.
func (*DerivedTable) Format ¶
func (node *DerivedTable) Format(buf *TrackedBuffer)
Format formats the node.
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 Explain ¶
type Explain struct {
Type ExplainType
Statement Statement
}
Explain represents an EXPLAIN statement
type ExplainType ¶
type ExplainType int8
ExplainType is an enum for Explain.Type
const ( EmptyType ExplainType = iota TreeType JSONType VitessType TraditionalType AnalyzeType )
Constant for Enum Type - ExplainType
func (ExplainType) ToString ¶
func (ty ExplainType) ToString() string
ToString returns the type as a string
type Expr ¶
type Expr interface {
SQLNode
// contains filtered or unexported methods
}
Expr represents an expression.
func ReplaceExpr ¶
ReplaceExpr finds the from expression from root and replaces it with to. If from matches root, then to is returned.
func SplitAndExpression ¶
SplitAndExpression breaks up the Expr into AND-separated conditions and appends them to filters. Outer parenthesis are removed. Precedence should be taken into account if expressions are recombined.
type Exprs ¶
type Exprs []Expr
Exprs represents a list of value expressions. It's not a valid expression because it's not parenthesized.
type ForeignKeyDefinition ¶
type ForeignKeyDefinition struct {
Source Columns
ReferencedTable TableName
ReferencedColumns Columns
OnDelete ReferenceAction
OnUpdate ReferenceAction
}
ForeignKeyDefinition describes a foreign key in a CREATE TABLE statement
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
}
FuncExpr represents a function call.
func (*FuncExpr) IsAggregate ¶
IsAggregate returns true if the function is an aggregate.
type GroupConcatExpr ¶
type GroupConcatExpr struct {
Distinct bool
Exprs SelectExprs
OrderBy OrderBy
Separator string
Limit *Limit
}
GroupConcatExpr represents a call to GROUP_CONCAT
func (*GroupConcatExpr) Format ¶
func (node *GroupConcatExpr) Format(buf *TrackedBuffer)
Format formats the node
type IndexColumn ¶
type IndexColumn struct {
Column ColIdent
Length *Literal
Direction OrderDirection
}
IndexColumn describes a column in an index definition with optional length
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 ¶
type IndexHints struct {
Type IndexHintsType
Indexes []ColIdent
}
IndexHints represents a list of index hints.
func (*IndexHints) Format ¶
func (node *IndexHints) Format(buf *TrackedBuffer)
Format formats the node.
type IndexHintsType ¶
type IndexHintsType int8
IndexHintsType is an enum for IndexHints.Type
const ( UseOp IndexHintsType = iota IgnoreOp ForceOp )
Constant for Enum Type - IndexHintsType
func (IndexHintsType) ToString ¶
func (ty IndexHintsType) ToString() string
ToString returns the type as a string
type IndexInfo ¶
type IndexInfo struct {
Type string
Name ColIdent
Primary bool
Spatial bool
Fulltext bool
Unique bool
}
IndexInfo describes the name and type of an index in a CREATE TABLE statement
type IndexOption ¶
IndexOption is used for trailing options for indexes: COMMENT, KEY_BLOCK_SIZE, USING, WITH PARSER
type Insert ¶
type Insert struct {
Action InsertAction
Comments Comments
Ignore Ignore
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. Replaces are currently disallowed in sharded schemas because of the implications the deletion part may have on vindexes. If you add fields here, consider adding them to calls to validateUnshardedRoute.
type InsertAction ¶
type InsertAction int8
InsertAction is the action for insert.
const ( InsertAct InsertAction = iota ReplaceAct )
Constants for Enum Type - Insert.Action
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 IsExpr ¶
type IsExpr struct {
Operator IsExprOperator
Expr Expr
}
IsExpr represents an IS ... or an IS NOT ... expression.
type IsExprOperator ¶
type IsExprOperator int8
IsExprOperator is an enum for IsExpr.Operator
const ( IsNullOp IsExprOperator = iota IsNotNullOp IsTrueOp IsNotTrueOp IsFalseOp IsNotFalseOp )
Constant for Enum Type - IsExprOperator
func (IsExprOperator) ToString ¶
func (op IsExprOperator) ToString() string
ToString returns the operator as a string
type IsolationLevel ¶
type IsolationLevel int8
IsolationLevel is an enum for isolation levels
const ( ReadUncommitted IsolationLevel = iota ReadCommitted RepeatableRead Serializable )
Constants for Enum type - IsolationLevel
func (IsolationLevel) Format ¶
func (node IsolationLevel) 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 JoinType
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 JoinType ¶
type JoinType int8
JoinType represents the type of Join for JoinTableExpr
type LengthScaleOption ¶
LengthScaleOption is used for types that have an optional length and scale
type Literal ¶
Literal represents a fixed value.
func NewBitLiteral ¶
NewBitLiteral builds a new BitVal containing a bit literal.
func NewFloatLiteral ¶
NewFloatLiteral builds a new FloatVal.
func NewHexNumLiteral ¶
NewHexNumLiteral builds a new HexNum.
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 MatchExprOption
}
MatchExpr represents a call to the MATCH function
func (*MatchExpr) Format ¶
func (node *MatchExpr) Format(buf *TrackedBuffer)
Format formats the node
type MatchExprOption ¶
type MatchExprOption int8
MatchExprOption is an enum for MatchExpr.Option
const ( NoOption MatchExprOption = iota BooleanModeOpt NaturalLanguageModeOpt NaturalLanguageModeWithQueryExpansionOpt QueryExpansionOpt )
Constant for Enum Type - MatchExprOption
func (MatchExprOption) ToString ¶
func (option MatchExprOption) ToString() string
ToString returns the option as a string
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 Order ¶
type Order struct {
Expr Expr
Direction OrderDirection
}
Order represents an ordering expression.
type OrderDirection ¶
type OrderDirection int8
OrderDirection is an enum for the direction in which to order - asc or desc.
const ( AscOrder OrderDirection = iota DescOrder )
Constant for Enum Type - OrderDirection
func (OrderDirection) ToString ¶
func (dir OrderDirection) ToString() string
ToString returns the direction as a string
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 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) MakeDistinct ¶
func (node *ParenSelect) MakeDistinct()
MakeDistinct implements the SelectStatement interface
func (*ParenSelect) SetLimit ¶
func (node *ParenSelect) SetLimit(limit *Limit)
SetLimit sets the limit clause
func (*ParenSelect) SetLock ¶
func (node *ParenSelect) SetLock(lock Lock)
SetLock sets the lock clause
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 PartitionSpecAction
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 PartitionSpecAction ¶
type PartitionSpecAction int8
PartitionSpecAction is an enum for PartitionSpec.Action
const (
ReorganizeAction PartitionSpecAction = iota
)
Constant for Enum Type - PartitionSpecAction
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 PositionedErr ¶
PositionedErr holds context related to parser errors
func (PositionedErr) Error ¶
func (p PositionedErr) Error() string
type Precendence ¶
type Precendence int
Precendence is used to know the precedence between operators, so we can introduce parens when needed in the String representation of the AST
const ( Syntactic Precendence = iota P1 P2 P3 P4 P5 P6 P7 P8 P9 P10 P11 P12 P13 P14 P15 P16 P17 )
type RangeCond ¶
type RangeCond struct {
Operator RangeCondOperator
Left Expr
From, To Expr
}
RangeCond represents a BETWEEN or a NOT BETWEEN expression.
func (*RangeCond) Format ¶
func (node *RangeCond) Format(buf *TrackedBuffer)
Format formats the node.
type RangeCondOperator ¶
type RangeCondOperator int8
RangeCondOperator is an enum for RangeCond.Operator
const ( BetweenOp RangeCondOperator = iota NotBetweenOp )
Constant for Enum Type - RangeCondOperator
func (RangeCondOperator) ToString ¶
func (op RangeCondOperator) ToString() string
ToString returns the operator as a string
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 Release ¶
type Release struct {
Name ColIdent
}
Release represents a release savepoint statement.
type RewriteASTResult ¶
type RewriteASTResult struct {
*BindVarNeeds
AST Statement // The rewritten AST
}
RewriteASTResult contains the rewritten ast and meta information about it
func PrepareAST ¶
func PrepareAST(in Statement, bindVars map[string]*querypb.BindVariable, prefix string, parameterize bool) (*RewriteASTResult, error)
PrepareAST will normalize the query
func RewriteAST ¶
func RewriteAST(in Statement) (*RewriteASTResult, error)
RewriteAST rewrites the whole AST, replacing function calls and adding column aliases to queries
type SQLNode ¶
type SQLNode interface {
Format(buf *TrackedBuffer)
}
SQLNode defines the interface for all nodes generated by the parser.
func Rewrite ¶
Rewrite traverses a syntax tree recursively, starting with root, and calling pre and post for each node as described below. Rewrite returns the syntax tree, possibly modified.
If pre is not nil, it is called for each node before the node's children are traversed (pre-order). If pre returns false, no children are traversed, and post is not called for that node.
If post is not nil, and a prior call of pre didn't return false, post is called for each node after its children are traversed (post-order). If post returns false, traversal is terminated and Apply returns immediately.
Only fields that refer to AST nodes are considered children; i.e., fields of basic types (strings, []byte, etc.) are ignored.
type SRollback ¶
type SRollback struct {
Name ColIdent
}
SRollback represents a rollback to savepoint statement.
func (*SRollback) Format ¶
func (node *SRollback) Format(buf *TrackedBuffer)
Format formats the node.
type Savepoint ¶
type Savepoint struct {
Name ColIdent
}
Savepoint represents a savepoint statement.
func (*Savepoint) Format ¶
func (node *Savepoint) Format(buf *TrackedBuffer)
Format formats the node.
type Scope ¶
type Scope int8
Scope is an enum for scope of query
type Select ¶
type Select struct {
Cache *bool // a reference here so it can be nil
Distinct bool
StraightJoinHint bool
SQLCalcFoundRows bool
Comments Comments
SelectExprs SelectExprs
From TableExprs
Where *Where
GroupBy GroupBy
Having *Where
OrderBy OrderBy
Limit *Limit
Lock Lock
Into *SelectInto
}
Select represents a SELECT statement.
func NewSelect ¶
func NewSelect(comments Comments, exprs SelectExprs, selectOptions []string, from TableExprs, where *Where, groupBy GroupBy, having *Where) *Select
NewSelect is used to create a select statement
func (*Select) AddHaving ¶
AddHaving adds the boolean expression to the HAVING clause as an AND condition.
func (*Select) AddWhere ¶
AddWhere adds the boolean expression to the WHERE clause as an AND condition.
func (*Select) MakeDistinct ¶
func (node *Select) MakeDistinct()
MakeDistinct makes the statement distinct
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 SelectInto ¶
type SelectInto struct {
Type SelectIntoType
FileName string
Charset string
FormatOption string
ExportOption string
Manifest string
Overwrite string
}
SelectInto is a struct that represent the INTO part of a select query
func (*SelectInto) Format ¶
func (node *SelectInto) Format(buf *TrackedBuffer)
Format formats the node.
type SelectIntoType ¶
type SelectIntoType int8
SelectIntoType is an enum for SelectInto.Type
const ( IntoOutfile SelectIntoType = iota IntoOutfileS3 IntoDumpfile )
Constant for Enum Type - SelectIntoType
func (SelectIntoType) ToString ¶
func (sel SelectIntoType) ToString() string
ToString returns the type as a string
type SelectStatement ¶
type SelectStatement interface {
AddOrder(*Order)
SetLimit(*Limit)
SetLock(lock Lock)
MakeDistinct()
SQLNode
// contains filtered or unexported methods
}
SelectStatement any SELECT statement.
type SetTransaction ¶
type SetTransaction struct {
SQLNode
Comments Comments
Scope Scope
Characteristics []Characteristic
}
SetTransaction represents a SET TRANSACTION statement.
func (*SetTransaction) Format ¶
func (node *SetTransaction) Format(buf *TrackedBuffer)
Format formats the node.
type ShowColumns ¶
type ShowColumns struct {
Full string
Table TableName
DbName string
Filter *ShowFilter
}
ShowColumns is of ShowInternal type, holds the show columns statement.
func (*ShowColumns) Format ¶
func (node *ShowColumns) Format(buf *TrackedBuffer)
Format formats the node.
type ShowFilter ¶
ShowFilter is show tables filter
func (*ShowFilter) Format ¶
func (node *ShowFilter) Format(buf *TrackedBuffer)
Format formats the node.
type ShowInternal ¶
type ShowInternal interface {
SQLNode
// contains filtered or unexported methods
}
ShowInternal will represent all the show statement types.
type ShowLegacy ¶
type ShowLegacy struct {
Extended string
Type string
OnTable TableName
Table TableName
ShowTablesOpt *ShowTablesOpt
Scope Scope
ShowCollationFilterOpt Expr
}
ShowLegacy is of ShowInternal type, holds the legacy show ast struct.
func (*ShowLegacy) Format ¶
func (node *ShowLegacy) Format(buf *TrackedBuffer)
Format formats the node.
func (*ShowLegacy) HasOnTable ¶
func (node *ShowLegacy) HasOnTable() bool
HasOnTable returns true if the show statement has an "on" clause
func (*ShowLegacy) HasTable ¶
func (node *ShowLegacy) HasTable() bool
HasTable returns true if the show statement has a parsed table name. Not all show statements parse table names.
type ShowTableStatus ¶
type ShowTableStatus struct {
DatabaseName string
Filter *ShowFilter
}
ShowTableStatus is of ShowInternal type, holds SHOW TABLE STATUS queries.
func (*ShowTableStatus) Format ¶
func (node *ShowTableStatus) Format(buf *TrackedBuffer)
Format formats the node.
type ShowTablesOpt ¶
type ShowTablesOpt struct {
Full string
DbName string
Filter *ShowFilter
}
ShowTablesOpt is show tables option
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 StatementType ¶
type StatementType int
StatementType encodes the type of a SQL statement
const ( StmtSelect StatementType = iota StmtStream StmtInsert StmtReplace StmtUpdate StmtDelete StmtDDL StmtBegin StmtCommit StmtRollback StmtSet StmtShow StmtUse StmtOther StmtUnknown StmtComment StmtPriv StmtExplain StmtSavepoint StmtSRollback StmtRelease StmtVStream )
These constants are used to identify the SQL statement type. Changing this list will require reviewing all calls to Preview.
func ASTToStatementType ¶
func ASTToStatementType(stmt Statement) StatementType
ASTToStatementType returns a StatementType from an AST stmt
func Preview ¶
func Preview(sql string) StatementType
Preview analyzes the beginning of the query using a simpler and faster textual comparison to identify the statement type.
func (StatementType) String ¶
func (s StatementType) String() string
type Stream ¶
type Stream struct {
Comments Comments
SelectExpr SelectExpr
Table TableName
}
Stream represents a SELECT statement.
type Subquery ¶
type Subquery struct {
Select SelectStatement
}
Subquery represents a subquery used as an value expression.
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 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 GetTableName ¶
func GetTableName(node SimpleTableExpr) TableIdent
GetTableName returns the table name from the SimpleTableExpr only if it's a simple expression. Otherwise, it returns "".
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 TableFromStatement ¶
TableFromStatement returns the qualified table name for the query. This works only for select statements.
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
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. It adds parens as needed to follow precedence rules when printing expressions. To handle parens correctly for left associative binary operators, use %l and %r to tell the TrackedBuffer which value is on the LHS and RHS
The name must be something other than the usual Printf() to avoid "go vet" warnings due to our custom format specifiers. *** THIS METHOD SHOULD NOT BE USED FROM ast.go. USE astPrintf INSTEAD ***
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 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 ¶
type UnaryExpr struct {
Operator UnaryExprOperator
Expr Expr
}
UnaryExpr represents a unary value expression.
func (*UnaryExpr) Format ¶
func (node *UnaryExpr) Format(buf *TrackedBuffer)
Format formats the node.
type UnaryExprOperator ¶
type UnaryExprOperator int8
UnaryExprOperator is an enum for UnaryExpr.Operator
const ( UPlusOp UnaryExprOperator = iota UMinusOp TildaOp BangOp BinaryOp UBinaryOp Utf8mb4Op Utf8Op Latin1Op )
Constant for Enum Type - UnaryExprOperator
func (UnaryExprOperator) ToString ¶
func (op UnaryExprOperator) ToString() string
ToString returns the operator as a string
type Union ¶
type Union struct {
FirstStatement SelectStatement
UnionSelects []*UnionSelect
OrderBy OrderBy
Limit *Limit
Lock Lock
}
Union represents a UNION statement.
func (*Union) MakeDistinct ¶
func (node *Union) MakeDistinct()
MakeDistinct implements the SelectStatement interface
type UnionSelect ¶
type UnionSelect struct {
Distinct bool
Statement SelectStatement
}
UnionSelect represents union type and select statement after first select statement.
func (*UnionSelect) Format ¶
func (node *UnionSelect) Format(buf *TrackedBuffer)
Format formats the node.
type Update ¶
type Update struct {
Comments Comments
Ignore Ignore
TableExprs TableExprs
Exprs UpdateExprs
Where *Where
OrderBy OrderBy
Limit *Limit
}
Update represents an UPDATE statement. If you add fields here, consider adding them to calls to validateUnshardedRoute.
type UpdateExpr ¶
UpdateExpr represents an update expression.
func (*UpdateExpr) Format ¶
func (node *UpdateExpr) Format(buf *TrackedBuffer)
Format formats the node.
type UpdateExprs ¶
type UpdateExprs []*UpdateExpr
UpdateExprs represents a list of update expressions.
func (UpdateExprs) Format ¶
func (node UpdateExprs) Format(buf *TrackedBuffer)
Format formats the node.
type VStream ¶
type VStream struct {
Comments Comments
SelectExpr SelectExpr
Table TableName
Where *Where
Limit *Limit
}
VStream represents a VSTREAM statement.
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 VindexParam ¶
VindexParam defines a key/value parameter for a CREATE VINDEX statement
func (VindexParam) Format ¶
func (node VindexParam) Format(buf *TrackedBuffer)
Format formats the node.
type VindexSpec ¶
type VindexSpec struct {
Name ColIdent
Type ColIdent
Params []VindexParam
}
VindexSpec defines a vindex for a CREATE VINDEX or DROP VINDEX statement
func (*VindexSpec) Format ¶
func (node *VindexSpec) Format(buf *TrackedBuffer)
Format formats the node. The "CREATE VINDEX" preamble was formatted in the containing DDL node Format, so this just prints the type, any parameters, and optionally the owner
func (*VindexSpec) ParseParams ¶
func (node *VindexSpec) ParseParams() (string, map[string]string)
ParseParams parses the vindex parameter list, pulling out the special-case "owner" parameter
type Visit ¶
Visit defines the signature of a function that can be used to visit all nodes of a parse tree.
type Where ¶
Where represents a WHERE or HAVING clause.
Source Files
¶
- analyzer.go
- ast.go
- ast_funcs.go
- ast_rewriting.go
- bind_var_needs.go
- comments.go
- constants.go
- encodable.go
- expression_converter.go
- expression_rewriting.go
- fuzz.go
- impossible_query.go
- like_filter.go
- normalizer.go
- parse_table.go
- parsed_query.go
- parser.go
- precedence.go
- random_expr.go
- redact_query.go
- rewriter.go
- rewriter_api.go
- set_normalizer.go
- sql.y
- token.go
- tracked_buffer.go
- truncate_query.go
- utils.go
Directories
¶
| Path | Synopsis |
|---|---|
|
Package hack gives you some efficient functionality at the cost of breaking some Go rules.
|
Package hack gives you some efficient functionality at the cost of breaking some Go rules. |
|
proto
|
|
|
Package sqltypes implements interfaces and types that represent SQL values.
|
Package sqltypes implements interfaces and types that represent SQL values. |
|
test
|
|
|
Package visitorgen is responsible for taking the ast.go of Vitess and and producing visitor infrastructure for it.
|
Package visitorgen is responsible for taking the ast.go of Vitess and and producing visitor infrastructure for it. |
|
exit
Package exit provides an alternative to os.Exit(int).
|
Package exit provides an alternative to os.Exit(int). |
|
tb
Package tb exposes some handy traceback functionality buried in the runtime.
|
Package tb exposes some handy traceback functionality buried in the runtime. |
|
Package vterrors provides simple error handling primitives for Vitess In all Vitess code, errors should be propagated using vterrors.Wrapf() and not fmt.Errorf().
|
Package vterrors provides simple error handling primitives for Vitess In all Vitess code, errors should be propagated using vterrors.Wrapf() and not fmt.Errorf(). |