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