Documentation ¶
Index ¶
- Constants
- Variables
- func Append(buf *strings.Builder, node SQLNode)
- func Backtick(in string) string
- 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 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 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
- func (node ColIdent) WalkSubtree(visit Visit) error
- type ColName
- type ColTuple
- type CollateExpr
- type ColumnDefinition
- type ColumnOpt
- type ColumnOption
- type ColumnOptionList
- type ColumnOptionListOpt
- type ColumnPrimaryKeyOption
- type ColumnType
- type ColumnUniqueKeyOption
- type Columns
- type CommentDirectives
- type Comments
- type ComparisonExpr
- type ConvertExpr
- type ConvertType
- type ConvertUsingExpr
- type DDL
- type DatabaseOption
- type DatabaseOptionList
- 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 IndexInfo
- 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 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 Show
- type ShowFilter
- type SimpleTableExpr
- type StarExpr
- type Statement
- type Subquery
- type TableExpr
- type TableExprs
- type TableIdent
- func (node TableIdent) CompliantName() string
- func (node TableIdent) Format(buf *TrackedBuffer)
- func (node TableIdent) IsEmpty() bool
- func (node TableIdent) MarshalJSON() ([]byte, error)
- func (node TableIdent) String() string
- func (node *TableIdent) UnmarshalJSON(b []byte) error
- func (node TableIdent) WalkSubtree(visit Visit) error
- type TableName
- type TableNames
- type TableOption
- type TableOptionList
- type TableOptionListOpt
- type TableOptionType
- type TableOptions
- type TableSpec
- type Tokenizer
- type TrackedBuffer
- type Transaction
- type TupleEqualityList
- 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 ( DistinctStr = "distinct " StraightJoinHint = "straight_join " )
Select.Distinct
const ( ForUpdateStr = " for update" )
Select.Lock
const ( SQLCacheStr = "sql_cache " SQLNoCacheStr = "sql_no_cache " )
Select.Cache
const ( UnionStr = "union" UnionAllStr = "union all" UnionDistinctStr = "union distinct" )
Union.Type
const ( // InsertStr represents insert action. InsertStr = "insert" // ReplaceStr represents replace action. ReplaceStr = "replace" )
const ( SessionStr = "session" GlobalStr = "global" )
Set.Scope or Show.Scope
const ( 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" )
DDL strings.
const ( 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" )
The following constants represent SHOW statements.
const ( JoinStr = "join" StraightJoinStr = "straight_join" LeftJoinStr = "left join" RightJoinStr = "right join" NaturalJoinStr = "natural join" NaturalLeftJoinStr = "natural left join" NaturalRightJoinStr = "natural right join" )
JoinTableExpr.Join
const ( UseStr = "use " IgnoreStr = "ignore " ForceStr = "force " )
Index hints.
const ( WhereStr = "where" HavingStr = "having" )
Where.Type
const ( EqualStr = "=" LessThanStr = "<" GreaterThanStr = ">" LessEqualStr = "<=" GreaterEqualStr = ">=" NotEqualStr = "!=" NullSafeEqualStr = "<=>" InStr = "in" NotInStr = "not in" LikeStr = "like" NotLikeStr = "not like" RegexpStr = "regexp" NotRegexpStr = "not regexp" JSONExtractOp = "->" JSONUnquoteExtractOp = "->>" )
ComparisonExpr.Operator
const ( BetweenStr = "between" NotBetweenStr = "not between" )
RangeCond.Operator
const ( IsNullStr = "is null" IsNotNullStr = "is not null" IsTrueStr = "is true" IsNotTrueStr = "is not true" IsFalseStr = "is false" IsNotFalseStr = "is not false" )
IsExpr.Operator
const ( StrVal = ValType(iota) IntVal FloatVal HexNum HexVal ValArg 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 ( BitAndStr = "&" BitOrStr = "|" BitXorStr = "^" PlusStr = "+" MinusStr = "-" MultStr = "*" DivStr = "/" IntDivStr = "div" ModStr = "%" ShiftLeftStr = "<<" ShiftRightStr = ">>" )
BinaryExpr.Operator
const ( UPlusStr = "+" UMinusStr = "-" TildaStr = "~" BangStr = "!" BinaryStr = "binary " )
UnaryExpr.Operator
const ( BooleanModeStr = " in boolean mode" NaturalLanguageModeStr = " in natural language mode" NaturalLanguageModeWithQueryExpansionStr = " in natural language mode with query expansion" QueryExpansionStr = " with query expansion" )
MatchExpr.Option
const ( AscScr = "asc" DescScr = "desc" )
Order.Direction
const ( AttachStr = "attach" DetachStr = "detach" AttachListStr = "attachlist" ReshardStr = "reshard" CleanupStr = "cleanup" )
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 ( // 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 = 57444
const AGAINST = 57528
const ALL = 57366
const ALTER = 57440
const ANALYZE = 57443
const AND = 57413
const APPROXNUM = 57499
const AS = 57368
const ASC = 57370
const ATTACH = 57558
const ATTACHLIST = 57559
const AUTO_INCREMENT = 57498
const BEGIN = 57549
const BETWEEN = 57415
const BIGINT = 57469
const BINARY = 57435
const BINLOG = 57508
const BIT = 57463
const BLOB = 57491
const BOOL = 57482
const BOOLEAN = 57529
const BY = 57357
const CASE = 57416
const CAST = 57524
const CHAR = 57480
const CHARACTER = 57483
const CHARSET = 57486
const CHECKSUM = 57378
const CLEANUP = 57562
const COLLATE = 57434
const COLUMN = 57454
const COLUMNS = 57511
const COMMENT = 57406
const COMMENT_KEYWORD = 57407
const COMMIT = 57552
const CONVERT = 57523
const CREATE = 57439
const CROSS = 57393
const CURRENT_DATE = 57515
const CURRENT_TIME = 57516
const CURRENT_TIMESTAMP = 57513
const (
CharacterSetStr = " character set"
)
this string is "character set" and this comment is required
const DATABASE = 57514
const DATABASES = 57503
const DATE = 57458
const DATETIME = 57478
const DECIMAL = 57474
const DEFAULT = 57374
const DELETE = 57351
const DESC = 57371
const DESCRIBE = 57456
const DETACH = 57560
const DISTINCT = 57367
const DISTRIBUTED = 57540
const DIV = 57431
const DOUBLE = 57472
const DROP = 57441
const DUPLICATE = 57373
const ELSE = 57419
const END = 57420
const ENGINE = 57547
const ENGINES = 57541
const ENUM = 57496
const ESCAPE = 57459
const EVENTS = 57507
const EXISTS = 57369
const EXPANSION = 57533
const EXPLAIN = 57457
const FALSE = 57410
const FIELDS = 57512
const FLOAT = 57402
const FLOAT_TYPE = 57473
const FOR = 57360
const FORCE = 57396
const FROM = 57352
const FULL = 57377
const FULLTEXT = 57361
const GE = 57422
const GLOBAL = 57554
const GROUP = 57354
const GROUP_CONCAT = 57525
const GTID = 57509
const HASH = 57537
const HAVING = 57355
const HEX = 57399
const HEXNUM = 57403
const ID = 57398
const IF = 57451
const IGNORE = 57450
const IN = 57428
const INDEX = 57447
const INNER = 57391
const INSERT = 57349
const INT = 57467
const INTEGER = 57468
const INTEGRAL = 57401
const INTERVAL = 57436
const INTNUM = 57470
const INTO = 57372
const IS = 57425
const JOIN = 57387
const JSON = 57495
const JSON_EXTRACT_OP = 57437
const JSON_UNQUOTE_EXTRACT_OP = 57438
const KEY = 57365
const KILL = 57546
const LANGUAGE = 57530
const LAST_INSERT_ID = 57380
const LE = 57421
const LEFT = 57389
const LEX_ERROR = 57346
const LIKE = 57426
const LIMIT = 57358
const LIST = 57538
const LIST_ARG = 57405
const LOCALTIME = 57517
const LOCALTIMESTAMP = 57518
const LOCK = 57376
const LONGBLOB = 57494
const LONGTEXT = 57490
const MATCH = 57527
const MEDIUMBLOB = 57493
const MEDIUMINT = 57466
const MEDIUMTEXT = 57489
const MOD = 57432
const MODE = 57384
const MODIFY = 57445
const NAMES = 57556
const NATURAL = 57394
const NCHAR = 57485
const NE = 57423
const NEXT = 57381
const NGRAM = 57363
const NOT = 57414
const NULL = 57408
const NULLX = 57497
const NULL_SAFE_EQUAL = 57424
const NUMERIC = 57475
const OFF = 57411
const OFFSET = 57359
const ON = 57397
const OPTIMIZE = 57461
const OR = 57412
const ORDER = 57356
const OUTER = 57392
const PARSER = 57362
const PARTITION = 57535
const PARTITIONS = 57536
const PRIMARY = 57453
const PROCESSLIST = 57543
const QUERY = 57532
const QUERYZ = 57544
const RADON = 57557
const REAL = 57471
const REGEXP = 57427
const RENAME = 57442
const REPAIR = 57460
const REPLACE = 57522
const RESHARD = 57561
const RIGHT = 57390
const ROLLBACK = 57553
const SELECT = 57348
const SEPARATOR = 57526
const SESSION = 57555
const SET = 57375
const SHARE = 57383
const SHIFT_LEFT = 57429
const SHIFT_RIGHT = 57430
const SHOW = 57455
const SIGNED = 57500
const SINGLE = 57548
const SMALLINT = 57465
const SQL_CACHE = 57386
const SQL_NO_CACHE = 57385
const START = 57550
const STATUS = 57510
const STRAIGHT_JOIN = 57388
const STRING = 57400
const TABLE = 57446
const TABLES = 57504
const TEXT = 57487
const THEN = 57418
const TIME = 57476
const TIMESTAMP = 57477
const TINYBLOB = 57492
const TINYINT = 57464
const TINYTEXT = 57488
const TO = 57449
const TRANSACTION = 57551
const TRUE = 57409
const TRUNCATE = 57462
const TXNZ = 57545
const UNARY = 57433
const UNION = 57347
const UNIQUE = 57364
const UNSIGNED = 57501
const UNUSED = 57534
const UPDATE = 57350
const USE = 57395
const USING = 57452
const UTC_DATE = 57519
const UTC_TIME = 57520
const UTC_TIMESTAMP = 57521
const VALUE = 57382
const VALUES = 57379
const VALUE_ARG = 57404
const VARBINARY = 57484
const VARCHAR = 57481
const VARIABLES = 57506
const VERSIONS = 57542
const VIEW = 57448
const WARNINGS = 57505
const WHEN = 57417
const WHERE = 57353
const WITH = 57531
const XA = 57539
const YEAR = 57479
const ZEROFILL = 57502
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 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.
func (*AliasedExpr) WalkSubtree ¶
func (node *AliasedExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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.
func (*AliasedTableExpr) WalkSubtree ¶
func (node *AliasedTableExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type AndExpr ¶
type AndExpr struct {
Left, Right Expr
}
AndExpr represents an AND expression.
func (*AndExpr) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type BinaryExpr ¶
BinaryExpr represents a binary value expression.
func (*BinaryExpr) Format ¶
func (node *BinaryExpr) Format(buf *TrackedBuffer)
Format formats the node.
func (*BinaryExpr) WalkSubtree ¶
func (node *BinaryExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type BoolVal ¶
type BoolVal bool
BoolVal is true or false.
func (BoolVal) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type CaseExpr ¶
CaseExpr represents a CASE expression.
func (*CaseExpr) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type Checksum ¶
type Checksum struct {
Table TableName
}
Checksum represents a CHECKSUM statement.
func (*Checksum) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (ColIdent) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type ColName ¶
type ColName struct { // Metadata is not populated by the parser. // It's a placeholder for analyzers to store // additional data, typically info about which // table or column this node references. Metadata interface{} Name ColIdent Qualifier TableName }
ColName represents a column name.
func (*ColName) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (*CollateExpr) WalkSubtree ¶
func (node *CollateExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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.
func (*ColumnDefinition) WalkSubtree ¶
func (col *ColumnDefinition) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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 )
type ColumnOption ¶
type ColumnOption struct { // Generic field options. NotNull BoolVal Autoincrement BoolVal Default *SQLVal Comment *SQLVal OnUpdate *SQLVal // Key specification PrimaryKeyOpt ColumnPrimaryKeyOption UniqueKeyOpt ColumnUniqueKeyOption // contains filtered or unexported fields }
func (ColumnOption) GetOptType ¶
func (col ColumnOption) GetOptType() ColumnOpt
type ColumnOptionList ¶
type ColumnOptionList []*ColumnOption
type ColumnOptionListOpt ¶
type ColumnOptionListOpt struct {
ColOptList ColumnOptionList
}
func (*ColumnOptionListOpt) GetColumnOption ¶
func (co *ColumnOptionListOpt) GetColumnOption(opt ColumnOpt) *ColumnOption
type ColumnPrimaryKeyOption ¶
type ColumnPrimaryKeyOption int
ColumnPrimaryKeyOption and ColumnUniqueKeyOption 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 *SQLVal Comment *SQLVal // Numeric field options Length *SQLVal Unsigned BoolVal Zerofill BoolVal Scale *SQLVal // Text field options Charset string Collate string // Enum values EnumValues []string // Key specification 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
func (*ColumnType) WalkSubtree ¶
func (ct *ColumnType) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type ColumnUniqueKeyOption ¶
type ColumnUniqueKeyOption int
const ( // ColUniqueKeyNone 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
func (Columns) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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 Comments ¶
type Comments [][]byte
Comments represents a list of comments.
func (Comments) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type ComparisonExpr ¶
ComparisonExpr represents a two-value comparison expression.
func (*ComparisonExpr) Format ¶
func (node *ComparisonExpr) Format(buf *TrackedBuffer)
Format formats the node.
func (*ComparisonExpr) WalkSubtree ¶
func (node *ComparisonExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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.
func (*ConvertExpr) WalkSubtree ¶
func (node *ConvertExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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.
func (*ConvertType) WalkSubtree ¶
func (node *ConvertType) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type ConvertUsingExpr ¶
ConvertUsingExpr represents a call to CONVERT(expr USING charset).
func (*ConvertUsingExpr) Format ¶
func (node *ConvertUsingExpr) Format(buf *TrackedBuffer)
Format formats the node.
func (*ConvertUsingExpr) WalkSubtree ¶
func (node *ConvertUsingExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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 // 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.
func (*DDL) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type DatabaseOption ¶
DatabaseOption represents database option. See: https://dev.mysql.com/doc/refman/5.7/en/create-database.html
type DatabaseOptionList ¶
type DatabaseOptionList []*DatabaseOption
type DatabaseOptionListOpt ¶
type DatabaseOptionListOpt struct {
DBOptList DatabaseOptionList
}
func (DatabaseOptionListOpt) Format ¶
func (optList DatabaseOptionListOpt) Format(buf *TrackedBuffer)
Format formats the node
type Default ¶
type Default struct {
ColName string
}
Default represents a DEFAULT expression.
func (*Default) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type Delete ¶
Delete represents a DELETE statement.
func (*Delete) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (*ExistsExpr) WalkSubtree ¶
func (node *ExistsExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type Explain ¶
type Explain struct { }
Explain represents a explain statement.
func (*Explain) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (Exprs) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (*FuncExpr) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type GroupBy ¶
type GroupBy []Expr
GroupBy represents a GROUP BY clause.
func (GroupBy) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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
func (*GroupConcatExpr) WalkSubtree ¶
func (node *GroupConcatExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type IndexColumn ¶
IndexColumn describes a column in an index definition with optional length
type IndexDefinition ¶
type IndexDefinition struct { Info *IndexInfo Columns []*IndexColumn }
IndexDefinition describes an index in a CREATE TABLE statement
func (*IndexDefinition) Format ¶
func (idx *IndexDefinition) Format(buf *TrackedBuffer)
Format formats the node.
func (*IndexDefinition) WalkSubtree ¶
func (idx *IndexDefinition) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type IndexHints ¶
IndexHints represents a list of index hints.
func (*IndexHints) Format ¶
func (node *IndexHints) Format(buf *TrackedBuffer)
Format formats the node.
func (*IndexHints) WalkSubtree ¶
func (node *IndexHints) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type IndexInfo ¶
IndexInfo describes the name and type of an index in a CREATE TABLE statement
func (*IndexInfo) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (*Insert) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (*IntervalExpr) WalkSubtree ¶
func (node *IntervalExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type IsExpr ¶
IsExpr represents an IS ... or an IS NOT ... expression.
func (*IsExpr) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type JoinTableExpr ¶
JoinTableExpr represents a TableExpr that's a JOIN operation.
func (*JoinTableExpr) Format ¶
func (node *JoinTableExpr) Format(buf *TrackedBuffer)
Format formats the node.
func (*JoinTableExpr) WalkSubtree ¶
func (node *JoinTableExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type Kill ¶
type Kill struct {
QueryID *NumVal
}
Kill represents a KILL statement.
func (*Kill) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type LengthScaleOption ¶
LengthScaleOption is used for types that have an optional length and scale
type Limit ¶
type Limit struct {
Offset, Rowcount Expr
}
Limit represents a LIMIT clause.
func (*Limit) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type ListArg ¶
type ListArg []byte
ListArg represents a named list argument.
func (ListArg) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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
func (*MatchExpr) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type Nextval ¶
type Nextval struct {
Expr Expr
}
Nextval defines the NEXT VALUE expression.
func (Nextval) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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 NotExpr ¶
type NotExpr struct {
Expr Expr
}
NotExpr represents a NOT expression.
func (*NotExpr) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type NullVal ¶
type NullVal struct{}
NullVal represents a NULL value.
func (*NullVal) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type NumVal ¶
type NumVal struct {
// contains filtered or unexported fields
}
NumVal represents numval tuple.
type OnDup ¶
type OnDup UpdateExprs
OnDup represents an ON DUPLICATE KEY clause.
func (OnDup) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type OrExpr ¶
type OrExpr struct {
Left, Right Expr
}
OrExpr represents an OR expression.
func (*OrExpr) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type Order ¶
Order represents an ordering expression.
func (*Order) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type OrderBy ¶
type OrderBy []*Order
OrderBy represents an ORDER By clause.
func (OrderBy) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (*OtherAdmin) WalkSubtree ¶
func (node *OtherAdmin) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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.
func (*OtherRead) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (*ParenExpr) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type ParenSelect ¶
type ParenSelect struct {
Select SelectStatement
}
ParenSelect is a parenthesized SELECT statement.
func (*ParenSelect) AddOrder ¶
func (node *ParenSelect) AddOrder(order *Order)
AddOrder adds an order by element
func (*ParenSelect) Format ¶
func (node *ParenSelect) Format(buf *TrackedBuffer)
Format formats the node.
func (*ParenSelect) SetLimit ¶
func (node *ParenSelect) SetLimit(limit *Limit)
SetLimit sets the limit clause
func (*ParenSelect) WalkSubtree ¶
func (node *ParenSelect) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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.
func (*ParenTableExpr) WalkSubtree ¶
func (node *ParenTableExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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 Radon ¶
Radon represents the radon statement.
func (*Radon) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type RangeCond ¶
RangeCond represents a BETWEEN or a NOT BETWEEN expression.
func (*RangeCond) Format ¶
func (node *RangeCond) Format(buf *TrackedBuffer)
Format formats the node.
func (*RangeCond) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type SQLNode ¶
type SQLNode interface { Format(buf *TrackedBuffer) // WalkSubtree calls visit on all underlying nodes // of the subtree, but not the current one. Walking // must be interrupted if visit returns an error. WalkSubtree(visit Visit) error }
SQLNode defines the interface for all nodes generated by the parser.
type SQLVal ¶
SQLVal represents a single value.
func NewStrValWithoutQuote ¶
NewStrValWithoutQuote builds a new string that will be output without quote later in Format.
func (*SQLVal) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (*Select) AddWhere ¶
AddWhere adds the boolean expression to the WHERE clause as an AND condition. If the expression is an OR clause, it parenthesizes it. Currently, the OR operator is the only one that's lower precedence than AND.
func (*Select) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (SelectExprs) WalkSubtree ¶
func (node SelectExprs) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type SelectStatement ¶
type SelectStatement interface { AddOrder(*Order) SetLimit(*Limit) SQLNode // contains filtered or unexported methods }
SelectStatement any SELECT statement.
type Set ¶
Set represents a SET statement.
func (*Set) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type SetExprs ¶
type SetExprs []*SetExpr
SetExprs represents a list of set expressions.
func (SetExprs) WalkSubtree ¶
type Show ¶
type Show struct { Type string Full string Table TableName Database TableName From string Limit *Limit Filter *ShowFilter }
Show represents a show statement.
func (*Show) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type ShowFilter ¶
ShowFilter is show tables filter
func (*ShowFilter) Format ¶
func (node *ShowFilter) Format(buf *TrackedBuffer)
Format formats the node.
func (*ShowFilter) WalkSubtree ¶
func (node *ShowFilter) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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.
func (*StarExpr) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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 Subquery ¶
type Subquery struct {
Select SelectStatement
}
Subquery represents a subquery.
func (*Subquery) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (TableExprs) WalkSubtree ¶
func (node TableExprs) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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.
func (TableIdent) WalkSubtree ¶
func (node TableIdent) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type TableName ¶
type TableName struct {
Name, Qualifier TableIdent
}
TableName represents a table name. Qualifier, if specified, represents a database or keyspace. TableName is a value struct whose fields are case sensitive. This means two TableName vars can be compared for equality and a TableName can also be used as key in a map.
func (TableName) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type TableNames ¶
type TableNames []TableName
TableNames is a list of TableName.
func (TableNames) Format ¶
func (node TableNames) Format(buf *TrackedBuffer)
Format formats the node.
func (TableNames) WalkSubtree ¶
func (node TableNames) WalkSubtree(visit Visit) error
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 TableOptionList ¶
type TableOptionList []*TableOption
type TableOptionListOpt ¶
type TableOptionListOpt struct {
TblOptList TableOptionList
}
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 )
type TableOptions ¶
TableOptions is used by TableSpec
func (TableOptions) Format ¶
func (opts TableOptions) Format(buf *TrackedBuffer)
Format formats the node.
func (TableOptions) WalkSubtree ¶
func (opts TableOptions) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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
func (*TableSpec) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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.
func (*Transaction) WalkSubtree ¶
func (node *Transaction) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type TupleEqualityList ¶
TupleEqualityList is for generating equality constraints for tables that have composite primary keys.
func (*TupleEqualityList) EncodeSQL ¶
func (tpl *TupleEqualityList) EncodeSQL(buf *strings.Builder)
EncodeSQL generates the where clause constraints for the tuple equality.
type UnaryExpr ¶
UnaryExpr represents a unary value expression.
func (*UnaryExpr) Format ¶
func (node *UnaryExpr) Format(buf *TrackedBuffer)
Format formats the node.
func (*UnaryExpr) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type Union ¶
type Union struct { Type string Left, Right SelectStatement OrderBy OrderBy Limit *Limit Lock string }
Union represents a UNION statement.
func (*Union) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type Update ¶
type Update struct { Comments Comments Table TableName Exprs UpdateExprs Where *Where OrderBy OrderBy Limit *Limit }
Update represents an UPDATE statement.
func (*Update) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type UpdateExpr ¶
UpdateExpr represents an update expression.
func (*UpdateExpr) Format ¶
func (node *UpdateExpr) Format(buf *TrackedBuffer)
Format formats the node.
func (*UpdateExpr) WalkSubtree ¶
func (node *UpdateExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
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.
func (UpdateExprs) WalkSubtree ¶
func (node UpdateExprs) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type Use ¶
type Use struct {
DBName TableIdent
}
Use represents a use statement.
func (*Use) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type ValTuple ¶
type ValTuple Exprs
ValTuple represents a tuple of actual values.
func (ValTuple) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type Values ¶
type Values []ValTuple
Values represents a VALUES clause.
func (Values) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
type ValuesFuncExpr ¶
ValuesFuncExpr represents a function call.
func (*ValuesFuncExpr) Format ¶
func (node *ValuesFuncExpr) Format(buf *TrackedBuffer)
Format formats the node.
func (*ValuesFuncExpr) WalkSubtree ¶
func (node *ValuesFuncExpr) WalkSubtree(visit Visit) error
WalkSubtree walks the nodes of the subtree.
type Visit ¶
Visit defines the signature of a function that can be used to visit all nodes of a parse tree.
type When ¶
When represents a WHEN sub-expression.
func (*When) WalkSubtree ¶
WalkSubtree walks the nodes of the subtree.
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. |