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 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 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 = 57457
const AGAINST = 57585
const ALGORITHM = 57361
const ALL = 57379
const ALTER = 57453
const ANALYZE = 57456
const AND = 57426
const APPROXNUM = 57520
const AS = 57381
const ASC = 57383
const ATTACH = 57624
const ATTACHLIST = 57625
const AUTO_INCREMENT = 57519
const AVG_ROW_LENGTH = 57530
const BEGIN = 57605
const BETWEEN = 57428
const BIGINT = 57482
const BINARY = 57448
const BINLOG = 57564
const BIT = 57476
const BLOB = 57504
const BOOL = 57495
const BOOLEAN = 57586
const BTREE = 57362
const BY = 57357
const CASCADE = 57363
const CASE = 57429
const CAST = 57581
const CHAR = 57493
const CHARACTER = 57496
const CHARSET = 57499
const CHECKSUM = 57391
const CLEANUP = 57628
const COLLATE = 57447
const COLLATION = 57558
const COLUMN = 57467
const COLUMNS = 57567
const COLUMN_FORMAT = 57529
const COMMENT = 57419
const COMMENT_KEYWORD = 57420
const COMMIT = 57608
const COMMITTED = 57620
const COMPACT = 57549
const COMPRESSED = 57547
const COMPRESSION = 57531
const CONNECTION = 57532
const CONSTRAINT = 57364
const CONVERT = 57580
const CREATE = 57452
const CROSS = 57406
const CURRENT_DATE = 57570
const CURRENT_TIME = 57573
const CURRENT_TIMESTAMP = 57569
const DATA = 57533
const DATABASE = 57571
const DATABASES = 57559
const DATE = 57471
const DATETIME = 57491
const DECIMAL = 57487
const DEFAULT = 57387
const DELAY_KEY_WRITE = 57535
const DELETE = 57351
const DESC = 57384
const DESCRIBE = 57469
const DETACH = 57626
const DIRECTORY = 57534
const DISK = 57527
const DISTINCT = 57380
const DISTRIBUTED = 57596
const DIV = 57444
const DOUBLE = 57485
const DROP = 57454
const DUPLICATE = 57386
const DYNAMIC = 57525
const ELSE = 57432
const ENCRYPTION = 57536
const END = 57433
const ENGINE = 57603
const ENGINES = 57597
const ENUM = 57509
const ESCAPE = 57472
const EVENTS = 57563
const EXISTS = 57382
const EXPANSION = 57590
const EXPLAIN = 57470
const FALSE = 57423
const FIELDS = 57568
const FIXED = 57524
const FLOAT = 57415
const FLOAT_TYPE = 57486
const FOR = 57360
const FORCE = 57409
const FROM = 57352
const FULL = 57390
const FULLTEXT = 57365
const GE = 57435
const GEOMETRY = 57510
const GEOMETRYCOLLECTION = 57514
const GLOBAL = 57610
const GROUP = 57354
const GROUP_CONCAT = 57582
const GTID = 57565
const HASH = 57366
const HASH2 = 57367
const HAVING = 57355
const HEX = 57412
const HEXNUM = 57416
const ID = 57411
const IF = 57464
const IGNORE = 57463
const IN = 57441
const INDEX = 57460
const INDEXES = 57368
const INNER = 57404
const INSERT = 57349
const INSERT_METHOD = 57537
const INT = 57480
const INTEGER = 57481
const INTEGRAL = 57414
const INTERVAL = 57449
const INTNUM = 57483
const INTO = 57385
const IS = 57438
const ISOLATION = 57614
const JOIN = 57400
const JSON = 57508
const JSON_EXTRACT_OP = 57450
const JSON_UNQUOTE_EXTRACT_OP = 57451
const KEY = 57378
const KEYS = 57370
const KEY_BLOCK_SIZE = 57369
const KILL = 57602
const LANGUAGE = 57587
const LAST_INSERT_ID = 57393
const LE = 57434
const LEFT = 57402
const LEVEL = 57615
const LEX_ERROR = 57346
const LIKE = 57439
const LIMIT = 57358
const LINESTRING = 57512
const LIST = 57594
const LIST_ARG = 57418
const LOCAL = 57611
const LOCALTIME = 57574
const LOCALTIMESTAMP = 57575
const LOCK = 57389
const LONGBLOB = 57507
const LONGTEXT = 57503
const MATCH = 57584
const MAX_ROWS = 57538
const MEDIUMBLOB = 57506
const MEDIUMINT = 57479
const MEDIUMTEXT = 57502
const MEMORY = 57528
const MIN_ROWS = 57539
const MOD = 57445
const MODE = 57397
const MODIFY = 57458
const MULTILINESTRING = 57516
const MULTIPOINT = 57515
const MULTIPOLYGON = 57517
const NAMES = 57613
const NATURAL = 57407
const NCHAR = 57498
const NE = 57436
const NEXT = 57394
const NOT = 57427
const NULL = 57421
const NULLX = 57518
const NULL_SAFE_EQUAL = 57437
const NUMERIC = 57488
const OFF = 57424
const OFFSET = 57359
const ON = 57410
const ONLY = 57618
const OPTIMIZE = 57474
const OR = 57425
const ORDER = 57356
const OUTER = 57405
const PACK_KEYS = 57540
const PARSER = 57371
const PARTITION = 57592
const PARTITIONS = 57593
const PASSWORD = 57541
const POINT = 57511
const POLYGON = 57513
const PRIMARY = 57466
const PROCESSLIST = 57599
const QUERY = 57589
const QUERYZ = 57600
const RADON = 57623
const READ = 57616
const REAL = 57484
const REBALANCE = 57630
const RECOVER = 57629
const REDUNDANT = 57548
const REGEXP = 57440
const RENAME = 57455
const REPAIR = 57473
const REPEATABLE = 57619
const REPLACE = 57579
const RESHARD = 57627
const RESTRICT = 57372
const RIGHT = 57403
const ROLLBACK = 57609
const ROW_FORMAT = 57542
const RTREE = 57373
const SCHEMA = 57572
const SELECT = 57348
const SEPARATOR = 57583
const SERIALIZABLE = 57622
const SESSION = 57612
const SET = 57388
const SHARE = 57396
const SHIFT_LEFT = 57442
const SHIFT_RIGHT = 57443
const SHOW = 57468
const SIGNED = 57521
const SINGLE = 57604
const SMALLINT = 57478
const SPATIAL = 57374
const SQL_CACHE = 57399
const SQL_NO_CACHE = 57398
const START = 57606
const STATS_AUTO_RECALC = 57543
const STATS_PERSISTENT = 57544
const STATS_SAMPLE_PAGES = 57545
const STATUS = 57566
const STORAGE = 57526
const STRAIGHT_JOIN = 57401
const STRING = 57413
const SYMBOL = 57375
const TABLE = 57459
const TABLES = 57560
const TABLESPACE = 57546
const TEMPORARY = 57376
const TEXT = 57500
const THEN = 57431
const TIME = 57489
const TIMESTAMP = 57490
const TINYBLOB = 57505
const TINYINT = 57477
const TINYTEXT = 57501
const TO = 57462
const TOKUDB_DEFAULT = 57550
const TOKUDB_FAST = 57551
const TOKUDB_LZMA = 57555
const TOKUDB_QUICKLZ = 57554
const TOKUDB_SMALL = 57552
const TOKUDB_SNAPPY = 57556
const TOKUDB_UNCOMPRESSED = 57557
const TOKUDB_ZLIB = 57553
const TRANSACTION = 57607
const TRUE = 57422
const TRUNCATE = 57475
const TXNZ = 57601
const UNARY = 57446
const UNCOMMITTED = 57621
const UNION = 57347
const UNIQUE = 57377
const UNSIGNED = 57522
const UNUSED = 57591
const UPDATE = 57350
const USE = 57408
const USING = 57465
const UTC_DATE = 57576
const UTC_TIME = 57577
const UTC_TIMESTAMP = 57578
const VALUE = 57395
const VALUES = 57392
const VALUE_ARG = 57417
const VARBINARY = 57497
const VARCHAR = 57494
const VARIABLES = 57562
const VERSIONS = 57598
const VIEW = 57461
const WARNINGS = 57561
const WHEN = 57430
const WHERE = 57353
const WITH = 57588
const WRITE = 57617
const XA = 57595
const YEAR = 57492
const ZEROFILL = 57523
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 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 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
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. |