Documentation ¶
Index ¶
- Constants
- Variables
- func Append(buf *strings.Builder, node SQLNode)
- func Backtick(in string) string
- func CheckIndexAlgorithm(algorithm string) bool
- func CheckIndexLock(lock string) bool
- 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 IsColName(node Expr) bool
- func IsDML(sql string) bool
- func IsNull(node Expr) bool
- func IsSimpleTuple(node Expr) bool
- func IsValue(node Expr) bool
- func NewPlanValue(node Expr) (sqltypes.PlanValue, error)
- func Normalize(stmt Statement, bindVars map[string]*querypb.BindVariable, prefix string)
- func Preview(sql string) int
- func SkipQueryPlanCacheDirective(stmt Statement) bool
- func StrToLower(str string) string
- func String(node SQLNode) string
- func StringIn(str string, values ...string) bool
- func StripComments(sql string) string
- func StripLeadingComments(sql string) string
- func Walk(visit Visit, nodes ...SQLNode) error
- type AliasedExpr
- type AliasedTableExpr
- type AndExpr
- type ApplyFunc
- type BinaryExpr
- type BoolVal
- type CaseExpr
- type Checksum
- 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 ColumnOpt
- type ColumnOption
- type ColumnOptionListOpt
- type ColumnPrimaryKeyOption
- type ColumnType
- type ColumnUniqueKeyOption
- type Columns
- type CommentDirectives
- type Comments
- type ComparisonExpr
- type ConvertExpr
- type ConvertType
- type ConvertUsingExpr
- type Cursor
- type DDL
- type DatabaseOption
- type DatabaseOptionListOpt
- type Default
- type Delete
- type Encodable
- type ExistsExpr
- type Explain
- type Expr
- type Exprs
- type FuncExpr
- type GroupBy
- type GroupConcatExpr
- type IndexColumn
- type IndexDefinition
- type IndexHints
- type IndexOption
- type IndexOptionType
- type IndexOptions
- type Insert
- type InsertRows
- type InsertValues
- type IntervalExpr
- type IsExpr
- type JoinTableExpr
- type Kill
- type LengthScaleOption
- type Limit
- type ListArg
- type Load
- type MarginComments
- type MatchExpr
- type Nextval
- type NodeFormatter
- type NotExpr
- type NullVal
- type NumVal
- type OnDup
- type OptVal
- type OrExpr
- type Order
- type OrderBy
- type OtherAdmin
- type OtherRead
- type OutFile
- type ParenExpr
- type ParenSelect
- type ParenTableExpr
- type ParsedQuery
- type PartOptGlobal
- type PartOptHash
- type PartOptHash2
- type PartOptList
- type PartOptNormal
- type PartOptSingle
- type PartitionDefinition
- type PartitionDefinitions
- type PartitionOption
- type Radon
- type RangeCond
- type SQLNode
- type SQLVal
- type Select
- type SelectExpr
- type SelectExprs
- type SelectStatement
- type Set
- type SetExpr
- type SetExprs
- type SetVal
- type Show
- type ShowFilter
- type SimpleTableExpr
- type StarExpr
- type Statement
- type Subquery
- type TableExpr
- type TableExprs
- type TableIdent
- type TableName
- type TableNames
- type TableOption
- type TableOptionListOpt
- type TableOptionType
- type TableOptions
- type TableSpec
- type Tokenizer
- type TrackedBuffer
- type Transaction
- type TupleEqualityList
- type TxnVal
- type UnaryExpr
- type Union
- type Update
- type UpdateExpr
- type UpdateExprs
- type Use
- type ValTuple
- type ValType
- type Values
- type ValuesFuncExpr
- type Visit
- type When
- type Where
- type Xa
Constants ¶
const ( StmtSelect = iota StmtInsert StmtReplace StmtUpdate StmtDelete StmtDDL StmtBegin StmtCommit StmtRollback StmtSet StmtShow StmtUse StmtOther StmtUnknown )
These constants are used to identify the SQL statement type.
const ( StrVal = ValType(iota) IntVal FloatVal HexNum HexVal ValArg StrValWithoutQuote )
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" )
const ( // Select.Distinct DistinctStr = "distinct " StraightJoinHint = "straight_join " // Select.Lock ForUpdateStr = " for update" // Select.Cache SQLCacheStr = "sql_cache " SQLNoCacheStr = "sql_no_cache " // Union.Type UnionStr = "union" UnionAllStr = "union all" UnionDistinctStr = "union distinct" // InsertStr represents insert action. InsertStr = "insert" // ReplaceStr represents replace action. ReplaceStr = "replace" // Set.Scope or Show.Scope. SessionStr = "session" GlobalStr = "global" // DDL strings. CreateDBStr = "create database" CreateTableStr = "create table" CreatePartitionTableStr = "create partition table" CreateIndexStr = "create index" DropDBStr = "drop database" DropTableStr = "drop table" DropTempTableStr = "drop temporary table" DropIndexStr = "drop index" AlterStr = "alter" AlterEngineStr = "alter table" AlterCharsetStr = "alter table charset" AlterAddColumnStr = "alter table add column" AlterDropColumnStr = "alter table drop column" AlterModifyColumnStr = "alter table modify column" RenameStr = "rename table" TruncateTableStr = "truncate table" SingleTableType = "singletable" GlobalTableType = "globaltable" PartitionTableHash = "partitiontablehash" PartitionTableHash2 = "partitiontablehash2" NormalTableType = "normaltable" PartitionTableList = "partitiontablelist" // Index key type strings. IndexStr = "index " FullTextStr = "fulltext index " SpatialStr = "spatial index " UniqueStr = "unique index " // The following constants represent SHOW statements. ShowDatabasesStr = "databases" ShowCreateDatabaseStr = "create database" ShowTableStatusStr = "table status" ShowTablesStr = "tables" ShowColumnsStr = "columns" ShowIndexStr = "index" ShowCreateTableStr = "create table" ShowEnginesStr = "engines" ShowStatusStr = "status" ShowVersionsStr = "versions" ShowProcesslistStr = "processlist" ShowQueryzStr = "queryz" ShowTxnzStr = "txnz" ShowWarningsStr = "warnings" ShowVariablesStr = "variables" ShowBinlogEventsStr = "binlog events" ShowCharsetStr = "charset" ShowCollationStr = "collation" ShowUnsupportedStr = "unsupported" // 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" JSONExtractOp = "->" JSONUnquoteExtractOp = "->>" // 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 = ">>" // UnaryExpr.Operator. UPlusStr = "+" UMinusStr = "-" TildaStr = "~" BangStr = "!" BinaryStr = "binary " // this string is "character set" and this comment is required. CharacterSetStr = " character set" // MatchExpr.Option. BooleanModeStr = " in boolean mode" NaturalLanguageModeStr = " in natural language mode" NaturalLanguageModeWithQueryExpansionStr = " in natural language mode with query expansion" QueryExpansionStr = " with query expansion" // Order.Direction. AscScr = "asc" DescScr = "desc" AttachStr = "attach" DetachStr = "detach" AttachListStr = "attachlist" ReshardStr = "reshard" CleanupStr = "cleanup" RebalanceStr = "rebalance" XARecoverStr = "xa recover" XACommitStr = "xa commit" XARollbackStr = "xa rollback" // Transaction isolation levels. ReadUncommitted = "read uncommitted" ReadCommitted = "read committed" RepeatableRead = "repeatable read" Serializable = "serializable" // Transaction access mode. TxReadOnly = "read only" TxReadWrite = "read write" // StartTxnStr represents the txn start transaction. StartTxnStr = "start transaction" // BeginTxnStr represents the txn begin. BeginTxnStr = "begin" // RollbackTxnStr represents the txn rollback. RollbackTxnStr = "rollback" // CommitTxnStr represents the txn commit. CommitTxnStr = "commit" )
const ADD = 57459
const AGAINST = 57587
const ALGORITHM = 57363
const ALL = 57381
const ALTER = 57455
const ANALYZE = 57458
const AND = 57428
const APPROXNUM = 57522
const AS = 57383
const ASC = 57385
const ATTACH = 57626
const ATTACHLIST = 57627
const AUTO_INCREMENT = 57521
const AVG_ROW_LENGTH = 57532
const BEGIN = 57607
const BETWEEN = 57430
const BIGINT = 57484
const BINARY = 57450
const BINLOG = 57566
const BIT = 57478
const BLOB = 57506
const BOOL = 57497
const BOOLEAN = 57588
const BTREE = 57364
const BY = 57357
const CASCADE = 57365
const CASE = 57431
const CAST = 57583
const CHAR = 57495
const CHARACTER = 57498
const CHARSET = 57501
const CHECKSUM = 57393
const CLEANUP = 57630
const COLLATE = 57449
const COLLATION = 57560
const COLUMN = 57469
const COLUMNS = 57569
const COLUMN_FORMAT = 57531
const COMMENT = 57421
const COMMENT_KEYWORD = 57422
const COMMIT = 57610
const COMMITTED = 57622
const COMPACT = 57551
const COMPRESSED = 57549
const COMPRESSION = 57533
const CONNECTION = 57534
const CONSTRAINT = 57366
const CONVERT = 57582
const CREATE = 57454
const CROSS = 57408
const CURRENT_DATE = 57572
const CURRENT_TIME = 57575
const CURRENT_TIMESTAMP = 57571
const DATA = 57535
const DATABASE = 57573
const DATABASES = 57561
const DATE = 57473
const DATETIME = 57493
const DECIMAL = 57489
const DEFAULT = 57389
const DELAY_KEY_WRITE = 57537
const DELETE = 57351
const DESC = 57386
const DESCRIBE = 57471
const DETACH = 57628
const DIRECTORY = 57536
const DISK = 57529
const DISTINCT = 57382
const DISTRIBUTED = 57598
const DIV = 57446
const DOUBLE = 57487
const DROP = 57456
const DUPLICATE = 57388
const DYNAMIC = 57527
const ELSE = 57434
const ENCLOSED = 57634
const ENCRYPTION = 57538
const END = 57435
const ENGINE = 57605
const ENGINES = 57599
const ENUM = 57511
const ESCAPE = 57474
const ESCAPED = 57636
const EVENTS = 57565
const EXISTS = 57384
const EXPANSION = 57592
const EXPLAIN = 57472
const FALSE = 57425
const FIELDS = 57570
const FIXED = 57526
const FLOAT = 57417
const FLOAT_TYPE = 57488
const FOR = 57360
const FORCE = 57411
const FROM = 57352
const FULL = 57392
const FULLTEXT = 57367
const GE = 57437
const GEOMETRY = 57512
const GEOMETRYCOLLECTION = 57516
const GLOBAL = 57612
const GROUP = 57354
const GROUP_CONCAT = 57584
const GTID = 57567
const HASH = 57368
const HASH2 = 57369
const HAVING = 57355
const HEX = 57414
const HEXNUM = 57418
const ID = 57413
const IF = 57466
const IGNORE = 57465
const IN = 57443
const INDEX = 57462
const INDEXES = 57370
const INFILE = 57362
const INNER = 57406
const INSERT = 57349
const INSERT_METHOD = 57539
const INT = 57482
const INTEGER = 57483
const INTEGRAL = 57416
const INTERVAL = 57451
const INTNUM = 57485
const INTO = 57387
const IS = 57440
const ISOLATION = 57616
const JOIN = 57402
const JSON = 57510
const JSON_EXTRACT_OP = 57452
const JSON_UNQUOTE_EXTRACT_OP = 57453
const KEY = 57380
const KEYS = 57372
const KEY_BLOCK_SIZE = 57371
const KILL = 57604
const LANGUAGE = 57589
const LAST_INSERT_ID = 57395
const LE = 57436
const LEFT = 57404
const LEVEL = 57617
const LEX_ERROR = 57346
const LIKE = 57441
const LIMIT = 57358
const LINES = 57633
const LINESTRING = 57514
const LIST = 57596
const LIST_ARG = 57420
const LOAD = 57361
const LOCAL = 57613
const LOCALTIME = 57576
const LOCALTIMESTAMP = 57577
const LOCK = 57391
const LONGBLOB = 57509
const LONGTEXT = 57505
const MATCH = 57586
const MAX_ROWS = 57540
const MEDIUMBLOB = 57508
const MEDIUMINT = 57481
const MEDIUMTEXT = 57504
const MEMORY = 57530
const MIN_ROWS = 57541
const MOD = 57447
const MODE = 57399
const MODIFY = 57460
const MULTILINESTRING = 57518
const MULTIPOINT = 57517
const MULTIPOLYGON = 57519
const NAMES = 57615
const NATURAL = 57409
const NCHAR = 57500
const NE = 57438
const NEXT = 57396
const NOT = 57429
const NULL = 57423
const NULLX = 57520
const NULL_SAFE_EQUAL = 57439
const NUMERIC = 57490
const OFF = 57426
const OFFSET = 57359
const ON = 57412
const ONLY = 57620
const OPTIMIZE = 57476
const OR = 57427
const ORDER = 57356
const OUTER = 57407
const OUTFILE = 57637
const PACK_KEYS = 57542
const PARSER = 57373
const PARTITION = 57594
const PARTITIONS = 57595
const PASSWORD = 57543
const POINT = 57513
const POLYGON = 57515
const PRIMARY = 57468
const PROCESSLIST = 57601
const QUERY = 57591
const QUERYZ = 57602
const RADON = 57625
const READ = 57618
const REAL = 57486
const REBALANCE = 57632
const RECOVER = 57631
const REDUNDANT = 57550
const REGEXP = 57442
const RENAME = 57457
const REPAIR = 57475
const REPEATABLE = 57621
const REPLACE = 57581
const RESHARD = 57629
const RESTRICT = 57374
const RIGHT = 57405
const ROLLBACK = 57611
const ROW_FORMAT = 57544
const RTREE = 57375
const SCHEMA = 57574
const SELECT = 57348
const SEPARATOR = 57585
const SERIALIZABLE = 57624
const SESSION = 57614
const SET = 57390
const SHARE = 57398
const SHIFT_LEFT = 57444
const SHIFT_RIGHT = 57445
const SHOW = 57470
const SIGNED = 57523
const SINGLE = 57606
const SMALLINT = 57480
const SPATIAL = 57376
const SQL_CACHE = 57401
const SQL_NO_CACHE = 57400
const START = 57608
const STATS_AUTO_RECALC = 57545
const STATS_PERSISTENT = 57546
const STATS_SAMPLE_PAGES = 57547
const STATUS = 57568
const STORAGE = 57528
const STRAIGHT_JOIN = 57403
const STRING = 57415
const SYMBOL = 57377
const TABLE = 57461
const TABLES = 57562
const TABLESPACE = 57548
const TEMPORARY = 57378
const TERMINATED = 57635
const TEXT = 57502
const THEN = 57433
const TIME = 57491
const TIMESTAMP = 57492
const TINYBLOB = 57507
const TINYINT = 57479
const TINYTEXT = 57503
const TO = 57464
const TOKUDB_DEFAULT = 57552
const TOKUDB_FAST = 57553
const TOKUDB_LZMA = 57557
const TOKUDB_QUICKLZ = 57556
const TOKUDB_SMALL = 57554
const TOKUDB_SNAPPY = 57558
const TOKUDB_UNCOMPRESSED = 57559
const TOKUDB_ZLIB = 57555
const TRANSACTION = 57609
const TRUE = 57424
const TRUNCATE = 57477
const TXNZ = 57603
const UNARY = 57448
const UNCOMMITTED = 57623
const UNION = 57347
const UNIQUE = 57379
const UNSIGNED = 57524
const UNUSED = 57593
const UPDATE = 57350
const USE = 57410
const USING = 57467
const UTC_DATE = 57578
const UTC_TIME = 57579
const UTC_TIMESTAMP = 57580
const VALUE = 57397
const VALUES = 57394
const VALUE_ARG = 57419
const VARBINARY = 57499
const VARCHAR = 57496
const VARIABLES = 57564
const VERSIONS = 57600
const VIEW = 57463
const WARNINGS = 57563
const WHEN = 57432
const WHERE = 57353
const WITH = 57590
const WRITE = 57619
const XA = 57597
const YEAR = 57494
const ZEROFILL = 57525
Variables ¶
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.
Functions ¶
func CheckIndexAlgorithm ¶
CheckIndexAlgorithm use to check if the string value matches a supported value. Supported values: inplace, copy, default.
func CheckIndexLock ¶
CheckIndexLock use to check if the string value matches a supported value. Supported values: default, exclusive, none, shared.
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 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 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.
func Preview ¶
Preview analyzes the beginning of the query using a simpler and faster textual comparison to identify the statement type.
func SkipQueryPlanCacheDirective ¶
SkipQueryPlanCacheDirective returns true if skip query plan cache directive is set to true in query.
func StringIn ¶
StringIn is a convenience function that returns true if str matches any of the values.
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
Types ¶
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 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.
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 BinaryExpr ¶
BinaryExpr represents a binary value expression.
func (*BinaryExpr) Format ¶
func (node *BinaryExpr) 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.
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 ColumnOpt ¶
type ColumnOpt int
const ( ColumnOptionNone ColumnOpt = iota // NotNull enum. ColumnOptionNotNull // Autoincrement enum. ColumnOptionAutoincrement // Default enum. ColumnOptionDefault // Comment enum. ColumnOptionComment // OnUpdate enum ColumnOptionOnUpdate // PrimarykeyOption enum. ColumnOptionKeyPrimaryOpt // UniquekeyOption enum. ColumnOptionKeyUniqueOpt // CollateOption enum ColumnOptionCollate // ColumnFormatOption enum ColumnOptionFormat // ColumnStorageOption enum ColumnOptionStorage )
type ColumnOption ¶
type ColumnOption struct { // Generic field options. NotNull BoolVal Autoincrement BoolVal Default *SQLVal Comment *SQLVal OnUpdate string Collate *SQLVal ColumnFormat string Storage string // Key specification PrimaryKeyOpt ColumnPrimaryKeyOption UniqueKeyOpt ColumnUniqueKeyOption // contains filtered or unexported fields }
func (ColumnOption) GetOptType ¶
func (col ColumnOption) GetOptType() ColumnOpt
type ColumnOptionListOpt ¶
type ColumnOptionListOpt struct {
ColOptList []*ColumnOption
}
func (*ColumnOptionListOpt) GetColumnOption ¶
func (co *ColumnOptionListOpt) GetColumnOption(opt ColumnOpt) *ColumnOption
type ColumnPrimaryKeyOption ¶
type ColumnPrimaryKeyOption int
ColumnPrimaryKeyOption indicates whether or not the given column is defined as an index element and contains the type of the option
const ( // ColKeyPrimaryNone enum. ColKeyPrimaryNone ColumnPrimaryKeyOption = iota // ColKeyPrimary enum. ColKeyPrimary )
type ColumnType ¶
type ColumnType struct { // The base type string Type string // Generic field options. NotNull BoolVal Autoincrement BoolVal Default *SQLVal OnUpdate string Comment *SQLVal Collate *SQLVal ColumnFormat string Storage string // Numeric field options Length *SQLVal Unsigned BoolVal Zerofill BoolVal Scale *SQLVal // Text field options Charset string // Enum values EnumValues []string // Key specification PrimaryKeyOpt ColumnPrimaryKeyOption UniqueKeyOpt ColumnUniqueKeyOption }
ColumnType represents a sql type in a CREATE TABLE statement All optional fields are nil if not specified
func (*ColumnType) Format ¶
func (ct *ColumnType) Format(buf *TrackedBuffer)
Format returns a canonical string representation of the type and all relevant options
type ColumnUniqueKeyOption ¶
type ColumnUniqueKeyOption int
ColumnUniqueKeyOption indicates whether or not the given column is defined as an index element and contains the type of the option
const ( // ColKeyUniqueNone enum. ColKeyUniqueNone ColumnUniqueKeyOption = iota // ColKeyUniqueKey enum. ColKeyUniqueKey )
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 ¶
ComparisonExpr represents a two-value comparison expression.
func (*ComparisonExpr) Format ¶
func (node *ComparisonExpr) Format(buf *TrackedBuffer)
Format formats the node.
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 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 DDL ¶
type DDL struct { Action string Engine string Charset string IndexName string IfExists bool IfNotExists bool Table TableName NewName TableName Database TableIdent DatabaseOptions DatabaseOptionListOpt TableSpec *TableSpec PartitionOption PartitionOption // [UNIQUE | FULLTEXT | SPATIAL] index. IndexType string IndexOpts *IndexOptions // Tables is set if Action is DropStr. Tables TableNames // table column operation DropColumnName string ModifyColumnDef *ColumnDefinition }
DDL represents a CREATE, ALTER, DROP or RENAME statement. Table is set for AlterStr, DropStr, RenameStr. NewName is set for AlterStr, CreateStr, RenameStr.
type DatabaseOption ¶
DatabaseOption represents database option. See: https://dev.mysql.com/doc/refman/5.7/en/create-database.html
type DatabaseOptionListOpt ¶
type DatabaseOptionListOpt struct {
DBOptList []*DatabaseOption
}
func (DatabaseOptionListOpt) Format ¶
func (optList DatabaseOptionListOpt) 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 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.
type Exprs ¶
type Exprs []Expr
Exprs represents a list of value expressions. It's not a valid expression because it's not parenthesized.
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 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 IndexColumn ¶
IndexColumn describes a column in an index definition with optional length
type IndexDefinition ¶
type IndexDefinition struct { Type string // TODO() in the future will refactor type ColIdent to string to make format code more clear Name ColIdent Opts *IndexOptions Primary bool Unique bool }
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 ¶
type IndexOption struct { Type IndexOptionType Val *SQLVal }
IndexOption represents the index options. See https://dev.mysql.com/doc/refman/5.7/en/create-index.html.
type IndexOptionType ¶
type IndexOptionType int
IndexOptionType is the type for IndexOption.
const ( // IndexOptionNone enum. IndexOptionNone IndexOptionType = iota // IndexOptionComment is 'comment' enum. IndexOptionComment // IndexOptionUsing is 'using' enum. IndexOptionUsing // IndexOptionBlockSize is 'key_block_size' enum. IndexOptionBlockSize // IndexOptionParser is 'with parser' enum. IndexOptionParser // IndexOptionAlgorithm is 'algorithm' enum. IndexOptionAlgorithm // IndexOptionLock is 'lock' enum. IndexOptionLock )
type IndexOptions ¶
type IndexOptions struct { Columns []*IndexColumn Using string Comment string BlockSize *SQLVal Parser string Algorithm string Lock string }
IndexOptions is used by IndexOpts.
func NewIndexOptions ¶
func NewIndexOptions(columns []*IndexColumn, idxOptList []*IndexOption) *IndexOptions
NewIndexOptions use to create IndexOptions.
func (*IndexOptions) Format ¶
func (opts *IndexOptions) Format(buf *TrackedBuffer)
Format formats the node.
type Insert ¶
type Insert struct { Action string Comments Comments Ignore string Table TableName 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.
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 JoinTableExpr ¶
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 ¶ added in v0.0.9
type Load struct { Table TableName OutFile *OutFile IgnoreOrReplace byte // 0 - 正常 1 - ingore 2 - update }
Statements.
func (*Load) Format ¶ added in v0.0.9
func (node *Load) 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 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 NumVal ¶
type NumVal struct {
// contains filtered or unexported fields
}
NumVal represents numval tuple.
type OptVal ¶
type OptVal struct {
Value Expr
}
OptVal represents the set variable value. See https://dev.mysql.com/doc/refman/5.7/en/set-variable.html
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 OutFile ¶ added in v0.0.6
type OutFile struct { OutString string FieldEscape byte FieldTerminate byte FieldEnclosed byte LineTerminate byte IsLocal bool }
Statements.
func (*OutFile) Format ¶ added in v0.0.6
func (node *OutFile) Format(buf *TrackedBuffer)
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
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) 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 PartOptGlobal ¶
type PartOptGlobal struct{}
PartOptGlobal global table.
func (*PartOptGlobal) PartitionType ¶
func (*PartOptGlobal) PartitionType() string
PartitionType return the partition type.
type PartOptHash ¶
PartOptHash hash table.
func (*PartOptHash) PartitionType ¶
func (*PartOptHash) PartitionType() string
PartitionType return the partition type.
type PartOptHash2 ¶
func (*PartOptHash2) PartitionType ¶
func (*PartOptHash2) PartitionType() string
type PartOptList ¶
type PartOptList struct { Name string PartDefs PartitionDefinitions }
PartOptList list table.
func (*PartOptList) PartitionType ¶
func (*PartOptList) PartitionType() string
PartitionType return the partition type.
type PartOptNormal ¶
type PartOptNormal struct{}
PartOptNormal normal table.
func (*PartOptNormal) PartitionType ¶
func (*PartOptNormal) PartitionType() string
PartitionType return the partition type.
type PartOptSingle ¶
type PartOptSingle struct {
BackendName string
}
PartOptSingle single table.
func (*PartOptSingle) PartitionType ¶
func (*PartOptSingle) PartitionType() string
PartitionType return the partition type.
type PartitionDefinition ¶
PartitionDefinition defines a single partition.
type PartitionDefinitions ¶
type PartitionDefinitions []*PartitionDefinition
PartitionDefinitions specifies the partition options.
type PartitionOption ¶
type PartitionOption interface {
PartitionType() string
}
PartitionOption interface。
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 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 SQLVal ¶
SQLVal represents a single value.
func NewStrValWithoutQuote ¶
NewStrValWithoutQuote builds a new string that will be output without quote later in Format.
type Select ¶
type Select struct { Cache string Comments Comments Distinct string Hints string SelectExprs SelectExprs OutFile *OutFile From TableExprs Where *Where GroupBy GroupBy Having *Where OrderBy OrderBy Limit *Limit Lock string ForBackup 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.
type SelectExpr ¶
type SelectExpr interface { SQLNode // contains filtered or unexported methods }
SelectExpr represents a SELECT expression.
func CloneSelectExpr ¶
func CloneSelectExpr(node SelectExpr) SelectExpr
CloneSelectExpr used to copy a new SelectExpr.
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) SQLNode // contains filtered or unexported methods }
SelectStatement any SELECT statement.
type SetVal ¶
type SetVal interface { SQLNode // contains filtered or unexported methods }
SetVal represents a set variable value.
type Show ¶
type Show struct { Type string Full string Table TableName Database string From string Limit *Limit Filter *ShowFilter }
Show represents a show statement.
type ShowFilter ¶
ShowFilter is show tables filter
func (*ShowFilter) Format ¶
func (node *ShowFilter) Format(buf *TrackedBuffer)
Format formats the node.
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 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 ParseStrictDDL ¶
ParseStrictDDL is the same as Parse except it errors on partially parsed DDL statements.
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.
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 TableOption ¶
type TableOption struct { Type TableOptionType Val *SQLVal }
TableOption represents the table options. See https://dev.mysql.com/doc/refman/5.7/en/create-table.html
type TableOptionListOpt ¶
type TableOptionListOpt struct {
TblOptList []*TableOption
}
func (*TableOptionListOpt) CheckIfTableOptDuplicate ¶
func (tblOptList *TableOptionListOpt) CheckIfTableOptDuplicate() string
Although each option can be appeared many times in MySQL, we make a constraint that each option should only be appeared just one time in RadonDB.
func (*TableOptionListOpt) GetTableOptValByType ¶
func (tblOptList *TableOptionListOpt) GetTableOptValByType(optType TableOptionType) *SQLVal
type TableOptionType ¶
type TableOptionType int
TableOptionType is the type for table_options
const ( TableOptionNone TableOptionType = iota TableOptionComment TableOptionEngine TableOptionCharset TableOptionAutoInc TableOptionAvgRowLength TableOptionChecksum TableOptionCollate TableOptionCompression TableOptionConnection TableOptionDataDirectory TableOptionIndexDirectory TableOptionDelayKeyWrite TableOptionEncryption TableOptionInsertMethod TableOptionKeyBlockSize TableOptionMaxRows TableOptionMinRows TableOptionPackKeys TableOptionPassword TableOptionRowFormat TableOptionStatsAutoRecalc TableOptionStatsPersistent TableOptionStatsSamplePages TableOptionTableSpace )
type TableOptions ¶
type TableOptions struct { Comment string Engine string Charset string AvgRowLength string Checksum string Collate string Compression string Connection string DataDirectory string IndexDirectory string DelayKeyWrite string Encryption string InsertMethod string KeyBlockSize string MaxRows string MinRows string PackKeys string Password string RowFormat string StatsAutoRecalc string StatsPersistent string StatsSamplePages string TableSpace string }
TableOptions is used by TableSpec
func (TableOptions) Format ¶
func (opts TableOptions) Format(buf *TrackedBuffer)
Format formats the node.
type TableSpec ¶
type TableSpec struct { Columns []*ColumnDefinition Indexes []*IndexDefinition Options TableOptions }
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) AddIndex ¶
func (ts *TableSpec) AddIndex(id *IndexDefinition)
AddIndex appends the given index to the list in the spec
type Tokenizer ¶
type Tokenizer struct { InStream *strings.Reader AllowComments bool ForceEOF bool Position int LastError string 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.
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 Transaction ¶
type Transaction struct {
Action string
}
Transaction represents the transaction tuple.
func (*Transaction) Format ¶
func (node *Transaction) Format(buf *TrackedBuffer)
Format formats the node.
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 TxnVal ¶
TxnVal represents the set-transaction characteristic. See https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html
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.
type Update ¶
type Update struct { Comments Comments Table TableName Exprs UpdateExprs Where *Where OrderBy OrderBy Limit *Limit }
Update represents an UPDATE statement.
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 ValuesFuncExpr ¶
ValuesFuncExpr represents a function call.
func (*ValuesFuncExpr) Format ¶
func (node *ValuesFuncExpr) Format(buf *TrackedBuffer)
Format formats the node.
type Visit ¶
Visit defines the signature of a function that can be used to visit all nodes of a parse tree.
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
depends
|
|
query
Package query is a generated protocol buffer package.
|
Package query is a generated protocol buffer package. |
sqltypes
Package sqltypes implements interfaces and types that represent SQL values.
|
Package sqltypes implements interfaces and types that represent SQL values. |
Package visitorgen is responsible for taking the ast.go of Vitess and producing visitor infrastructure for it.
|
Package visitorgen is responsible for taking the ast.go of Vitess and producing visitor infrastructure for it. |