vitess: github.com/youtube/vitess/go/vt/sqlparser Index | Files | Directories

package sqlparser

import "github.com/youtube/vitess/go/vt/sqlparser"

Index

Package Files

analyzer.go ast.go ast_funcs.go comments.go constants.go encodable.go expression_rewriting.go impossible_query.go like_filter.go normalizer.go parsed_query.go parser.go redact_query.go rewriter.go rewriter_api.go sql.go token.go tracked_buffer.go truncate_query.go

Constants

const (
    StrVal = ValType(iota)
    IntVal
    FloatVal
    HexNum
    HexVal
    ValArg
    BitVal
)

These are the possible Valtype values. HexNum represents a 0x... value. It cannot be treated as a simple value because it can be interpreted differently depending on the context.

const (
    // DirectiveMultiShardAutocommit is the query comment directive to allow
    // single round trip autocommit with a multi-shard statement.
    DirectiveMultiShardAutocommit = "MULTI_SHARD_AUTOCOMMIT"
    // DirectiveSkipQueryPlanCache skips query plan cache when set.
    DirectiveSkipQueryPlanCache = "SKIP_QUERY_PLAN_CACHE"
    // DirectiveQueryTimeout sets a query timeout in vtgate. Only supported for SELECTS.
    DirectiveQueryTimeout = "QUERY_TIMEOUT_MS"
    // DirectiveScatterErrorsAsWarnings enables partial success scatter select queries
    DirectiveScatterErrorsAsWarnings = "SCATTER_ERRORS_AS_WARNINGS"
)
const (
    // Select.Distinct
    DistinctStr      = "distinct "
    StraightJoinHint = "straight_join "

    // Select.Lock
    ForUpdateStr = " for update"
    ShareModeStr = " lock in share mode"

    // Select.Cache
    SQLCacheStr   = "sql_cache "
    SQLNoCacheStr = "sql_no_cache "

    // Union.Type
    UnionStr         = "union"
    UnionAllStr      = "union all"
    UnionDistinctStr = "union distinct"

    // DDL strings.
    InsertStr  = "insert"
    ReplaceStr = "replace"

    // Set.Scope or Show.Scope
    SessionStr        = "session"
    GlobalStr         = "global"
    VitessMetadataStr = "vitess_metadata"
    ImplicitStr       = ""

    // DDL strings.
    CreateStr           = "create"
    AlterStr            = "alter"
    DropStr             = "drop"
    RenameStr           = "rename"
    TruncateStr         = "truncate"
    FlushStr            = "flush"
    CreateVindexStr     = "create vindex"
    DropVindexStr       = "drop vindex"
    AddVschemaTableStr  = "add vschema table"
    DropVschemaTableStr = "drop vschema table"
    AddColVindexStr     = "on table add vindex"
    DropColVindexStr    = "on table drop vindex"
    AddSequenceStr      = "add sequence"
    AddAutoIncStr       = "add auto_increment"

    // Vindex DDL param to specify the owner of a vindex
    VindexOwnerStr = "owner"

    // Partition strings
    ReorganizeStr = "reorganize partition"

    // JoinTableExpr.Join
    JoinStr             = "join"
    StraightJoinStr     = "straight_join"
    LeftJoinStr         = "left join"
    RightJoinStr        = "right join"
    NaturalJoinStr      = "natural join"
    NaturalLeftJoinStr  = "natural left join"
    NaturalRightJoinStr = "natural right join"

    // Index hints.
    UseStr    = "use "
    IgnoreStr = "ignore "
    ForceStr  = "force "

    // Where.Type
    WhereStr  = "where"
    HavingStr = "having"

    // ComparisonExpr.Operator
    EqualStr             = "="
    LessThanStr          = "<"
    GreaterThanStr       = ">"
    LessEqualStr         = "<="
    GreaterEqualStr      = ">="
    NotEqualStr          = "!="
    NullSafeEqualStr     = "<=>"
    InStr                = "in"
    NotInStr             = "not in"
    LikeStr              = "like"
    NotLikeStr           = "not like"
    RegexpStr            = "regexp"
    NotRegexpStr         = "not regexp"
    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 "
    UBinaryStr = "_binary "
    Utf8mb4Str = "_utf8mb4 "

    // this string is "character set" and this comment is required
    CharacterSetStr = " character set"
    CharsetStr      = "charset"

    // 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"

    // SetExpr.Expr, for SET TRANSACTION ... or START TRANSACTION
    // TransactionStr is the Name for a SET TRANSACTION statement
    TransactionStr = "transaction"

    IsolationLevelReadUncommitted = "isolation level read uncommitted"
    IsolationLevelReadCommitted   = "isolation level read committed"
    IsolationLevelRepeatableRead  = "isolation level repeatable read"
    IsolationLevelSerializable    = "isolation level serializable"

    TxReadOnly  = "read only"
    TxReadWrite = "read write"
)
const (
    //LastInsertIDName is a reserved bind var name for last_insert_id()
    LastInsertIDName = "__lastInsertId"
    //DBVarName is a reserved bind var name for database()
    DBVarName = "__vtdbname"
)
const ACTION = 57462
const ACTIVE = 57617
const ADD = 57446
const ADMIN = 57618
const AGAINST = 57585
const ALL = 57362
const ALTER = 57442
const ANALYZE = 57445
const AND = 57413
const APPROXNUM = 57538
const ARRAY = 57592
const AS = 57364
const ASC = 57366
const AUTO_INCREMENT = 57537
const BEGIN = 57490
const BETWEEN = 57415
const BIGINT = 57501
const BINARY = 57435
const BIT = 57495
const BIT_LITERAL = 57407
const BLOB = 57522
const BOOL = 57514
const BOOLEAN = 57586
const BUCKETS = 57619
const BY = 57358
const CASCADE = 57463
const CASE = 57416
const CAST = 57577
const CHAR = 57512
const CHARACTER = 57515
const CHARSET = 57554
const CHECK = 57461
const CLONE = 57620
const COLLATE = 57434
const COLLATION = 57542
const COLUMN = 57457
const COLUMNS = 57549
const COMMENT = 57405
const COMMENT_KEYWORD = 57406
const COMMIT = 57493
const COMMITTED = 57563
const COMPONENT = 57621
const CONSTRAINT = 57464
const CONVERT = 57576
const CREATE = 57441
const CROSS = 57391
const CUME_DIST = 57593
const CURRENT_DATE = 57568
const CURRENT_TIME = 57569
const CURRENT_TIMESTAMP = 57566
const DATABASE = 57567
const DATABASES = 57543
const DATE = 57472
const DATETIME = 57510
const DECIMAL = 57506
const DEFAULT = 57371
const DEFINITION = 57622
const DELETE = 57352
const DENSE_RANK = 57595
const DESC = 57367
const DESCRIBE = 57470
const DESCRIPTION = 57594
const DISTINCT = 57363
const DISTINCTROW = 57376
const DIV = 57431
const DOUBLE = 57504
const DROP = 57443
const DUPLICATE = 57369
const ELSE = 57419
const EMPTY = 57596
const END = 57420
const ENFORCED = 57623
const ENGINES = 57551
const ENUM = 57527
const ESCAPE = 57473
const EXCEPT = 57597
const EXCLUDE = 57624
const EXISTS = 57365
const EXPANSION = 57590
const EXPLAIN = 57471
const FALSE = 57410
const FIELDS = 57550
const FIRST_VALUE = 57598
const FLOAT = 57401
const FLOAT_TYPE = 57505
const FLUSH = 57447
const FOLLOWING = 57625
const FOR = 57361
const FORCE = 57394
const FOREIGN = 57465
const FROM = 57353
const FULL = 57547
const FULLTEXT = 57459
const GE = 57422
const GEOMCOLLECTION = 57626
const GEOMETRY = 57528
const GEOMETRYCOLLECTION = 57532
const GET_MASTER_PUBLIC_KEY = 57627
const GLOBAL = 57555
const GROUP = 57355
const GROUPING = 57599
const GROUPS = 57600
const GROUP_CONCAT = 57580
const HAVING = 57356
const HEX = 57398
const HEXNUM = 57402
const HISTOGRAM = 57628
const HISTORY = 57629
const ID = 57397
const IF = 57454
const IGNORE = 57453
const IN = 57428
const INACTIVE = 57630
const INDEX = 57450
const INNER = 57389
const INSERT = 57350
const INT = 57499
const INTEGER = 57500
const INTEGRAL = 57400
const INTERVAL = 57438
const INTNUM = 57502
const INTO = 57368
const INVISIBLE = 57631
const IS = 57425
const ISOLATION = 57557
const JOIN = 57385
const JSON = 57526
const JSON_EXTRACT_OP = 57439
const JSON_TABLE = 57601
const JSON_UNQUOTE_EXTRACT_OP = 57440
const KEY = 57370
const KEYS = 57375
const KEY_BLOCK_SIZE = 57460
const LAG = 57602
const LANGUAGE = 57587
const LAST_INSERT_ID = 57378
const LAST_VALUE = 57603
const LATERAL = 57604
const LE = 57421
const LEAD = 57605
const LEFT = 57387
const LESS = 57480
const LEVEL = 57558
const LEX_ERROR = 57346
const LIKE = 57426
const LIMIT = 57359
const LINESTRING = 57530
const LIST_ARG = 57404
const LOCALTIME = 57570
const LOCALTIMESTAMP = 57571
const LOCK = 57373
const LOCKED = 57632
const LONGBLOB = 57525
const LONGTEXT = 57521
const MASTER_COMPRESSION_ALGORITHMS = 57633
const MASTER_PUBLIC_KEY_PATH = 57634
const MASTER_TLS_CIPHERSUITES = 57635
const MASTER_ZSTD_COMPRESSION_LEVEL = 57636
const MATCH = 57584
const MAXVALUE = 57477
const MEDIUMBLOB = 57524
const MEDIUMINT = 57498
const MEDIUMTEXT = 57520
const MEMBER = 57606
const MOD = 57432
const MODE = 57382
const MULTILINESTRING = 57534
const MULTIPOINT = 57533
const MULTIPOLYGON = 57535
const NAMES = 57553
const NATURAL = 57392
const NCHAR = 57517
const NE = 57423
const NESTED = 57637
const NETWORK_NAMESPACE = 57638
const NEXT = 57379
const NO = 57466
const NOT = 57414
const NOWAIT = 57639
const NTH_VALUE = 57607
const NTILE = 57608
const NULL = 57408
const NULLS = 57640
const NULLX = 57536
const NULL_SAFE_EQUAL = 57424
const NUMERIC = 57507
const OF = 57609
const OFF = 57411
const OFFSET = 57360
const OJ = 57641
const OLD = 57642
const ON = 57395
const ONLY = 57561
const OPTIMIZE = 57475
const OPTIONAL = 57643
const OR = 57412
const ORDER = 57357
const ORDINALITY = 57644
const ORGANIZATION = 57645
const OTHERS = 57646
const OUTER = 57390
const OVER = 57610
const PARTITION = 57478
const PATH = 57647
const PERCENT_RANK = 57611
const PERSIST = 57648
const PERSIST_ONLY = 57649
const PLUGINS = 57552
const POINT = 57529
const POLYGON = 57531
const PRECEDING = 57650
const PRIMARY = 57456
const PRIVILEGE_CHECKS_USER = 57651
const PROCEDURE = 57482
const PROCESS = 57652
const PROCESSLIST = 57548
const QUERY = 57589
const RANDOM = 57653
const RANK = 57612
const READ = 57559
const REAL = 57503
const RECURSIVE = 57613
const REFERENCE = 57654
const REFERENCES = 57467
const REGEXP = 57427
const RENAME = 57444
const REORGANIZE = 57479
const REPAIR = 57474
const REPEATABLE = 57562
const REPLACE = 57575
const REQUIRE_ROW_FORMAT = 57655
const RESOURCE = 57656
const RESPECT = 57657
const RESTART = 57658
const RESTRICT = 57468
const RETAIN = 57659
const REUSE = 57660
const RIGHT = 57388
const ROLE = 57661
const ROLLBACK = 57494
const ROW_NUMBER = 57614
const SCHEMA = 57448
const SECONDARY = 57662
const SECONDARY_ENGINE = 57663
const SECONDARY_LOAD = 57664
const SECONDARY_UNLOAD = 57665
const SELECT = 57348
const SEPARATOR = 57581
const SEQUENCE = 57489
const SERIALIZABLE = 57565
const SESSION = 57556
const SET = 57372
const SHARE = 57381
const SHIFT_LEFT = 57429
const SHIFT_RIGHT = 57430
const SHOW = 57469
const SIGNED = 57539
const SKIP = 57666
const SMALLINT = 57497
const SPATIAL = 57458
const SQL_CACHE = 57384
const SQL_NO_CACHE = 57383
const SRID = 57667
const START = 57491
const STATUS = 57486
const STRAIGHT_JOIN = 57386
const STREAM = 57349
const STRING = 57399
const SUBSTR = 57578
const SUBSTRING = 57579
const SYSTEM = 57615
const TABLE = 57449
const TABLES = 57544
const TEXT = 57518
const THAN = 57481
const THEN = 57418
const THREAD_PRIORITY = 57668
const TIES = 57669
const TIME = 57508
const TIMESTAMP = 57509
const TIMESTAMPADD = 57582
const TIMESTAMPDIFF = 57583
const TINYBLOB = 57523
const TINYINT = 57496
const TINYTEXT = 57519
const TO = 57452
const TRANSACTION = 57492
const TRIGGER = 57483
const TRUE = 57409
const TRUNCATE = 57476
const UNARY = 57433
const UNBOUNDED = 57670
const UNCOMMITTED = 57564
const UNDERSCORE_BINARY = 57436
const UNDERSCORE_UTF8MB4 = 57437
const UNION = 57347
const UNIQUE = 57455
const UNLOCK = 57374
const UNSIGNED = 57540
const UNUSED = 57591
const UPDATE = 57351
const USE = 57393
const USING = 57396
const UTC_DATE = 57572
const UTC_TIME = 57573
const UTC_TIMESTAMP = 57574
const VALUE = 57380
const VALUES = 57377
const VALUE_ARG = 57403
const VARBINARY = 57516
const VARCHAR = 57513
const VARIABLES = 57487
const VCPU = 57671
const VIEW = 57451
const VINDEX = 57484
const VINDEXES = 57485
const VISIBLE = 57672
const VITESS_METADATA = 57545
const VSCHEMA = 57546
const WARNINGS = 57488
const WHEN = 57417
const WHERE = 57354
const WINDOW = 57616
const WITH = 57588
const WRITE = 57560
const YEAR = 57511
const ZEROFILL = 57541

Variables

var (
    // TruncateUILen truncate queries in debug UIs to the given length. 0 means unlimited.
    TruncateUILen = flag.Int("sql-max-length-ui", 512, "truncate queries in debug UIs to the given length (default 512)")

    // TruncateErrLen truncate queries in error logs to the given length. 0 means unlimited.
    TruncateErrLen = flag.Int("sql-max-length-errors", 0, "truncate queries in error logs to the given length (default unlimited)")
)
var Aggregates = map[string]bool{
    "avg":          true,
    "bit_and":      true,
    "bit_or":       true,
    "bit_xor":      true,
    "count":        true,
    "group_concat": true,
    "max":          true,
    "min":          true,
    "std":          true,
    "stddev_pop":   true,
    "stddev_samp":  true,
    "stddev":       true,
    "sum":          true,
    "var_pop":      true,
    "var_samp":     true,
    "variance":     true,
}

Aggregates is a map of all aggregate functions.

var ErrEmpty = errors.New("empty statement")

ErrEmpty is a sentinel error returned when parsing empty statements.

func Append Uses

func Append(buf *strings.Builder, node SQLNode)

Append appends the SQLNode to the buffer.

func EncodeValue Uses

func EncodeValue(buf *strings.Builder, value *querypb.BindVariable)

EncodeValue encodes one bind variable value into the query.

func ExtractMysqlComment Uses

func ExtractMysqlComment(sql string) (version string, innerSQL string)

ExtractMysqlComment extracts the version and SQL from a comment-only query such as /*!50708 sql here */

func ExtractSetValues Uses

func ExtractSetValues(sql string) (keyValues map[SetKey]interface{}, scope string, err error)

ExtractSetValues returns a map of key-value pairs if the query is a SET statement. Values can be bool, int64 or string. Since set variable names are case insensitive, all keys are returned as lower case.

func FetchBindVar Uses

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 Uses

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 Uses

func GetBindvars(stmt Statement) map[string]struct{}

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 IsColName Uses

func IsColName(node Expr) bool

IsColName returns true if the Expr is a *ColName.

func IsDML Uses

func IsDML(sql string) bool

IsDML returns true if the query is an INSERT, UPDATE or DELETE statement.

func IsNull Uses

func IsNull(node Expr) bool

IsNull returns true if the Expr is SQL NULL

func IsSimpleTuple Uses

func IsSimpleTuple(node Expr) bool

IsSimpleTuple returns true if the Expr is a ValTuple that contains simple values or if it's a list arg.

func IsValue Uses

func IsValue(node Expr) bool

IsValue returns true if the Expr is a string, integral or value arg. NULL is not considered to be a value.

func KeywordString Uses

func KeywordString(id int) string

KeywordString returns the string corresponding to the given keyword

func LikeToRegexp Uses

func LikeToRegexp(likeExpr string) *regexp.Regexp

LikeToRegexp converts a like sql expression to regular expression

func NewPlanValue Uses

func NewPlanValue(node Expr) (sqltypes.PlanValue, error)

NewPlanValue builds a sqltypes.PlanValue from an Expr.

func Normalize Uses

func Normalize(stmt Statement, bindVars map[string]*querypb.BindVariable, prefix string)

Normalize changes the statement to use bind values, and updates the bind vars to those values. The supplied prefix is used to generate the bind var names. The function ensures that there are no collisions with existing bind vars. Within Select constructs, bind vars are deduped. This allows us to identify vindex equality. Otherwise, every value is treated as distinct.

func ParseTokenizer Uses

func ParseTokenizer(tokenizer *Tokenizer) int

ParseTokenizer is a raw interface to parse from the given tokenizer. This does not used pooled parsers, and should not be used in general.

func RedactSQLQuery Uses

func RedactSQLQuery(sql string) (string, error)

RedactSQLQuery returns a sql string with the params stripped out for display

func SkipQueryPlanCacheDirective Uses

func SkipQueryPlanCacheDirective(stmt Statement) bool

SkipQueryPlanCacheDirective returns true if skip query plan cache directive is set to true in query.

func SplitStatement Uses

func SplitStatement(blob string) (string, string, error)

SplitStatement returns the first sql statement up to either a ; or EOF and the remainder from the given buffer

func SplitStatementToPieces Uses

func SplitStatementToPieces(blob string) (pieces []string, err error)

SplitStatementToPieces split raw sql statement that may have multi sql pieces to sql pieces returns the sql pieces blob contains; or error if sql cannot be parsed

func String Uses

func String(node SQLNode) string

String returns a string representation of an SQLNode.

func StripComments Uses

func StripComments(sql string) string

StripComments removes all comments from the string regardless of where they occur

func StripLeadingComments Uses

func StripLeadingComments(sql string) string

StripLeadingComments trims the SQL string and removes any leading comments

func TruncateForLog Uses

func TruncateForLog(query string) string

TruncateForLog is used when displaying queries as part of error logs to avoid overwhelming logging systems with potentially long queries and bind value data.

func TruncateForUI Uses

func TruncateForUI(query string) string

TruncateForUI is used when displaying queries on various Vitess status pages to keep the pages small enough to load and render properly

func Walk Uses

func Walk(visit Visit, nodes ...SQLNode) error

Walk calls visit on every node. If visit returns true, the underlying nodes are also visited. If it returns an error, walking is interrupted, and the error is returned.

type AliasedExpr Uses

type AliasedExpr struct {
    Expr Expr
    As   ColIdent
}

AliasedExpr defines an aliased SELECT expression.

func (*AliasedExpr) Format Uses

func (node *AliasedExpr) Format(buf *TrackedBuffer)

Format formats the node.

type AliasedTableExpr Uses

type AliasedTableExpr struct {
    Expr       SimpleTableExpr
    Partitions Partitions
    As         TableIdent
    Hints      *IndexHints
}

AliasedTableExpr represents a table expression coupled with an optional alias or index hint. If As is empty, no alias was used.

func (*AliasedTableExpr) Format Uses

func (node *AliasedTableExpr) Format(buf *TrackedBuffer)

Format formats the node.

func (*AliasedTableExpr) RemoveHints Uses

func (node *AliasedTableExpr) RemoveHints() *AliasedTableExpr

RemoveHints returns a new AliasedTableExpr with the hints removed.

type AndExpr Uses

type AndExpr struct {
    Left, Right Expr
}

AndExpr represents an AND expression.

func (*AndExpr) Format Uses

func (node *AndExpr) Format(buf *TrackedBuffer)

Format formats the node.

type ApplyFunc Uses

type ApplyFunc func(*Cursor) bool

An ApplyFunc is invoked by Rewrite for each node n, even if n is nil, before and/or after the node's children, using a Cursor describing the current node and providing operations on it.

The return value of ApplyFunc controls the syntax tree traversal. See Rewrite for details.

type AutoIncSpec Uses

type AutoIncSpec struct {
    Column   ColIdent
    Sequence TableName
}

AutoIncSpec defines and autoincrement value for a ADD AUTO_INCREMENT statement

func (*AutoIncSpec) Format Uses

func (node *AutoIncSpec) Format(buf *TrackedBuffer)

Format formats the node.

type Begin Uses

type Begin struct{}

Begin represents a Begin statement.

func (*Begin) Format Uses

func (node *Begin) Format(buf *TrackedBuffer)

Format formats the node.

type BinaryExpr Uses

type BinaryExpr struct {
    Operator    string
    Left, Right Expr
}

BinaryExpr represents a binary value expression.

func (*BinaryExpr) Format Uses

func (node *BinaryExpr) Format(buf *TrackedBuffer)

Format formats the node.

type BoolVal Uses

type BoolVal bool

BoolVal is true or false.

func (BoolVal) Format Uses

func (node BoolVal) Format(buf *TrackedBuffer)

Format formats the node.

type CaseExpr Uses

type CaseExpr struct {
    Expr  Expr
    Whens []*When
    Else  Expr
}

CaseExpr represents a CASE expression.

func (*CaseExpr) Format Uses

func (node *CaseExpr) Format(buf *TrackedBuffer)

Format formats the node.

type ColIdent Uses

type ColIdent struct {
    // contains filtered or unexported fields
}

ColIdent is a case insensitive SQL identifier. It will be escaped with backquotes if necessary.

func NewColIdent Uses

func NewColIdent(str string) ColIdent

NewColIdent makes a new ColIdent.

func (ColIdent) CompliantName Uses

func (node ColIdent) CompliantName() string

CompliantName returns a compliant id name that can be used for a bind var.

func (ColIdent) Equal Uses

func (node ColIdent) Equal(in ColIdent) bool

Equal performs a case-insensitive compare.

func (ColIdent) EqualString Uses

func (node ColIdent) EqualString(str string) bool

EqualString performs a case-insensitive compare with str.

func (ColIdent) Format Uses

func (node ColIdent) Format(buf *TrackedBuffer)

Format formats the node.

func (ColIdent) IsEmpty Uses

func (node ColIdent) IsEmpty() bool

IsEmpty returns true if the name is empty.

func (ColIdent) Lowered Uses

func (node ColIdent) Lowered() string

Lowered returns a lower-cased column name. This function should generally be used only for optimizing comparisons.

func (ColIdent) MarshalJSON Uses

func (node ColIdent) MarshalJSON() ([]byte, error)

MarshalJSON marshals into JSON.

func (ColIdent) String Uses

func (node ColIdent) String() 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 Uses

func (node *ColIdent) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals from JSON.

type ColName Uses

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) Equal Uses

func (node *ColName) Equal(c *ColName) bool

Equal returns true if the column names match.

func (*ColName) Format Uses

func (node *ColName) Format(buf *TrackedBuffer)

Format formats the node.

type ColTuple Uses

type ColTuple interface {
    Expr
    // contains filtered or unexported methods
}

ColTuple represents a list of column values. It can be ValTuple, Subquery, ListArg.

type CollateExpr Uses

type CollateExpr struct {
    Expr    Expr
    Charset string
}

CollateExpr represents dynamic collate operator.

func (*CollateExpr) Format Uses

func (node *CollateExpr) Format(buf *TrackedBuffer)

Format formats the node.

type ColumnDefinition Uses

type ColumnDefinition struct {
    Name ColIdent
    // TODO: Should this not be a reference?
    Type ColumnType
}

ColumnDefinition describes a column in a CREATE TABLE statement

func (*ColumnDefinition) Format Uses

func (col *ColumnDefinition) Format(buf *TrackedBuffer)

Format formats the node.

type ColumnKeyOption Uses

type ColumnKeyOption int

ColumnKeyOption indicates whether or not the given column is defined as an index element and contains the type of the option

type ColumnType Uses

type ColumnType struct {
    // The base type string
    Type string

    // Generic field options.
    NotNull       BoolVal
    Autoincrement BoolVal
    Default       Expr
    OnUpdate      Expr
    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
    KeyOpt ColumnKeyOption
}

ColumnType represents a sql type in a CREATE TABLE statement All optional fields are nil if not specified

func (*ColumnType) DescribeType Uses

func (ct *ColumnType) DescribeType() string

DescribeType returns the abbreviated type information as required for describe table

func (*ColumnType) Format Uses

func (ct *ColumnType) Format(buf *TrackedBuffer)

Format returns a canonical string representation of the type and all relevant options

func (*ColumnType) SQLType Uses

func (ct *ColumnType) SQLType() querypb.Type

SQLType returns the sqltypes type code for the given column

type Columns Uses

type Columns []ColIdent

Columns represents an insert column list.

func (Columns) FindColumn Uses

func (node Columns) FindColumn(col ColIdent) int

FindColumn finds a column in the column list, returning the index if it exists or -1 otherwise

func (Columns) Format Uses

func (node Columns) Format(buf *TrackedBuffer)

Format formats the node.

type CommentDirectives Uses

type CommentDirectives map[string]interface{}

CommentDirectives is the parsed representation for execution directives conveyed in query comments

func ExtractCommentDirectives Uses

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 Uses

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 Uses

type Comments [][]byte

Comments represents a list of comments.

func (Comments) Format Uses

func (node Comments) Format(buf *TrackedBuffer)

Format formats the node.

type Commit Uses

type Commit struct{}

Commit represents a Commit statement.

func (*Commit) Format Uses

func (node *Commit) Format(buf *TrackedBuffer)

Format formats the node.

type ComparisonExpr Uses

type ComparisonExpr struct {
    Operator    string
    Left, Right Expr
    Escape      Expr
}

ComparisonExpr represents a two-value comparison expression.

func (*ComparisonExpr) Format Uses

func (node *ComparisonExpr) Format(buf *TrackedBuffer)

Format formats the node.

func (*ComparisonExpr) IsImpossible Uses

func (node *ComparisonExpr) IsImpossible() bool

IsImpossible returns true if the comparison in the expression can never evaluate to true. Note that this is not currently exhaustive to ALL impossible comparisons.

type ConstraintDefinition Uses

type ConstraintDefinition struct {
    Name    string
    Details ConstraintInfo
}

ConstraintDefinition describes a constraint in a CREATE TABLE statement

func (*ConstraintDefinition) Format Uses

func (c *ConstraintDefinition) Format(buf *TrackedBuffer)

Format formats the node.

type ConstraintInfo Uses

type ConstraintInfo interface {
    SQLNode
    // contains filtered or unexported methods
}

ConstraintInfo details a constraint in a CREATE TABLE statement

type ConvertExpr Uses

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 Uses

func (node *ConvertExpr) Format(buf *TrackedBuffer)

Format formats the node.

type ConvertType Uses

type ConvertType struct {
    Type     string
    Length   *SQLVal
    Scale    *SQLVal
    Operator string
    Charset  string
}

ConvertType represents the type in call to CONVERT(expr, type)

func (*ConvertType) Format Uses

func (node *ConvertType) Format(buf *TrackedBuffer)

Format formats the node.

type ConvertUsingExpr Uses

type ConvertUsingExpr struct {
    Expr Expr
    Type string
}

ConvertUsingExpr represents a call to CONVERT(expr USING charset).

func (*ConvertUsingExpr) Format Uses

func (node *ConvertUsingExpr) Format(buf *TrackedBuffer)

Format formats the node.

type CurTimeFuncExpr Uses

type CurTimeFuncExpr struct {
    Name ColIdent
    Fsp  Expr // fractional seconds precision, integer from 0 to 6
}

CurTimeFuncExpr represents the function and arguments for CURRENT DATE/TIME functions supported functions are documented in the grammar

func (*CurTimeFuncExpr) Format Uses

func (node *CurTimeFuncExpr) Format(buf *TrackedBuffer)

Format formats the node.

type Cursor Uses

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.

func (*Cursor) Node Uses

func (c *Cursor) Node() SQLNode

Node returns the current Node.

func (*Cursor) Parent Uses

func (c *Cursor) Parent() SQLNode

Parent returns the parent of the current Node.

func (*Cursor) Replace Uses

func (c *Cursor) Replace(newNode SQLNode)

Replace replaces the current node in the parent field with this new object. The use needs to make sure to not replace the object with something of the wrong type, or the visitor will panic.

type DBDDL Uses

type DBDDL struct {
    Action   string
    DBName   string
    IfExists bool
    Collate  string
    Charset  string
}

DBDDL represents a CREATE, DROP, or ALTER database statement.

func (*DBDDL) Format Uses

func (node *DBDDL) Format(buf *TrackedBuffer)

Format formats the node.

type DDL Uses

type DDL struct {
    Action string

    // FromTables is set if Action is RenameStr or DropStr.
    FromTables TableNames

    // ToTables is set if Action is RenameStr.
    ToTables TableNames

    // Table is set if Action is other than RenameStr or DropStr.
    Table TableName

    // The following fields are set if a DDL was fully analyzed.
    IfExists      bool
    TableSpec     *TableSpec
    OptLike       *OptLike
    PartitionSpec *PartitionSpec

    // VindexSpec is set for CreateVindexStr, DropVindexStr, AddColVindexStr, DropColVindexStr.
    VindexSpec *VindexSpec

    // VindexCols is set for AddColVindexStr.
    VindexCols []ColIdent

    // AutoIncSpec is set for AddAutoIncStr.
    AutoIncSpec *AutoIncSpec
}

DDL represents a CREATE, ALTER, DROP, RENAME, TRUNCATE or ANALYZE statement.

func (*DDL) AffectedTables Uses

func (node *DDL) AffectedTables() TableNames

AffectedTables returns the list table names affected by the DDL.

func (*DDL) Format Uses

func (node *DDL) Format(buf *TrackedBuffer)

Format formats the node.

type Default Uses

type Default struct {
    ColName string
}

Default represents a DEFAULT expression.

func (*Default) Format Uses

func (node *Default) Format(buf *TrackedBuffer)

Format formats the node.

type Delete Uses

type Delete struct {
    Comments   Comments
    Targets    TableNames
    TableExprs TableExprs
    Partitions Partitions
    Where      *Where
    OrderBy    OrderBy
    Limit      *Limit
}

Delete represents a DELETE statement. If you add fields here, consider adding them to calls to validateUnshardedRoute.

func (*Delete) Format Uses

func (node *Delete) Format(buf *TrackedBuffer)

Format formats the node.

type Encodable Uses

type Encodable interface {
    EncodeSQL(buf *strings.Builder)
}

Encodable defines the interface for types that can be custom-encoded into SQL.

type ExistsExpr Uses

type ExistsExpr struct {
    Subquery *Subquery
}

ExistsExpr represents an EXISTS expression.

func (*ExistsExpr) Format Uses

func (node *ExistsExpr) Format(buf *TrackedBuffer)

Format formats the node.

type Expr Uses

type Expr interface {
    SQLNode
    // contains filtered or unexported methods
}

Expr represents an expression.

func ExprFromValue Uses

func ExprFromValue(value sqltypes.Value) (Expr, error)

ExprFromValue converts the given Value into an Expr or returns an error.

func ReplaceExpr Uses

func ReplaceExpr(root, from, to Expr) Expr

ReplaceExpr finds the from expression from root and replaces it with to. If from matches root, then to is returned.

func SplitAndExpression Uses

func SplitAndExpression(filters []Expr, node Expr) []Expr

SplitAndExpression breaks up the Expr into AND-separated conditions and appends them to filters. Outer parenthesis are removed. Precedence should be taken into account if expressions are recombined.

type Exprs Uses

type Exprs []Expr

Exprs represents a list of value expressions. It's not a valid expression because it's not parenthesized.

func (Exprs) Format Uses

func (node Exprs) Format(buf *TrackedBuffer)

Format formats the node.

type ForeignKeyDefinition Uses

type ForeignKeyDefinition struct {
    Source            Columns
    ReferencedTable   TableName
    ReferencedColumns Columns
    OnDelete          ReferenceAction
    OnUpdate          ReferenceAction
}

ForeignKeyDefinition describes a foreign key in a CREATE TABLE statement

func (*ForeignKeyDefinition) Format Uses

func (f *ForeignKeyDefinition) Format(buf *TrackedBuffer)

Format formats the node.

type FuncExpr Uses

type FuncExpr struct {
    Qualifier TableIdent
    Name      ColIdent
    Distinct  bool
    Exprs     SelectExprs
}

FuncExpr represents a function call.

func (*FuncExpr) Format Uses

func (node *FuncExpr) Format(buf *TrackedBuffer)

Format formats the node.

func (*FuncExpr) IsAggregate Uses

func (node *FuncExpr) IsAggregate() bool

IsAggregate returns true if the function is an aggregate.

type GroupBy Uses

type GroupBy []Expr

GroupBy represents a GROUP BY clause.

func (GroupBy) Format Uses

func (node GroupBy) Format(buf *TrackedBuffer)

Format formats the node.

type GroupConcatExpr Uses

type GroupConcatExpr struct {
    Distinct  string
    Exprs     SelectExprs
    OrderBy   OrderBy
    Separator string
}

GroupConcatExpr represents a call to GROUP_CONCAT

func (*GroupConcatExpr) Format Uses

func (node *GroupConcatExpr) Format(buf *TrackedBuffer)

Format formats the node

type IndexColumn Uses

type IndexColumn struct {
    Column ColIdent
    Length *SQLVal
}

IndexColumn describes a column in an index definition with optional length

type IndexDefinition Uses

type IndexDefinition struct {
    Info    *IndexInfo
    Columns []*IndexColumn
    Options []*IndexOption
}

IndexDefinition describes an index in a CREATE TABLE statement

func (*IndexDefinition) Format Uses

func (idx *IndexDefinition) Format(buf *TrackedBuffer)

Format formats the node.

type IndexHints Uses

type IndexHints struct {
    Type    string
    Indexes []ColIdent
}

IndexHints represents a list of index hints.

func (*IndexHints) Format Uses

func (node *IndexHints) Format(buf *TrackedBuffer)

Format formats the node.

type IndexInfo Uses

type IndexInfo struct {
    Type    string
    Name    ColIdent
    Primary bool
    Spatial bool
    Unique  bool
}

IndexInfo describes the name and type of an index in a CREATE TABLE statement

func (*IndexInfo) Format Uses

func (ii *IndexInfo) Format(buf *TrackedBuffer)

Format formats the node.

type IndexOption Uses

type IndexOption struct {
    Name  string
    Value *SQLVal
    Using string
}

IndexOption is used for trailing options for indexes: COMMENT, KEY_BLOCK_SIZE, USING

type Insert Uses

type Insert struct {
    Action     string
    Comments   Comments
    Ignore     string
    Table      TableName
    Partitions Partitions
    Columns    Columns
    Rows       InsertRows
    OnDup      OnDup
}

Insert represents an INSERT or REPLACE statement. Per the MySQL docs, http://dev.mysql.com/doc/refman/5.7/en/replace.html Replace is the counterpart to `INSERT IGNORE`, and works exactly like a normal INSERT except if the row exists. In that case it first deletes the row and re-inserts with new values. For that reason we keep it as an Insert struct. Replaces are currently disallowed in sharded schemas because of the implications the deletion part may have on vindexes. If you add fields here, consider adding them to calls to validateUnshardedRoute.

func (*Insert) Format Uses

func (node *Insert) Format(buf *TrackedBuffer)

Format formats the node.

type InsertRows Uses

type InsertRows interface {
    SQLNode
    // contains filtered or unexported methods
}

InsertRows represents the rows for an INSERT statement.

type InsertValues Uses

type InsertValues [][]sqltypes.Value

InsertValues is a custom SQL encoder for the values of an insert statement.

func (InsertValues) EncodeSQL Uses

func (iv InsertValues) EncodeSQL(buf *strings.Builder)

EncodeSQL performs the SQL encoding for InsertValues.

type IntervalExpr Uses

type IntervalExpr struct {
    Expr Expr
    Unit string
}

IntervalExpr represents a date-time INTERVAL expression.

func (*IntervalExpr) Format Uses

func (node *IntervalExpr) Format(buf *TrackedBuffer)

Format formats the node.

type IsExpr Uses

type IsExpr struct {
    Operator string
    Expr     Expr
}

IsExpr represents an IS ... or an IS NOT ... expression.

func (*IsExpr) Format Uses

func (node *IsExpr) Format(buf *TrackedBuffer)

Format formats the node.

type JoinCondition Uses

type JoinCondition struct {
    On    Expr
    Using Columns
}

JoinCondition represents the join conditions (either a ON or USING clause) of a JoinTableExpr.

func (JoinCondition) Format Uses

func (node JoinCondition) Format(buf *TrackedBuffer)

Format formats the node.

type JoinTableExpr Uses

type JoinTableExpr struct {
    LeftExpr  TableExpr
    Join      string
    RightExpr TableExpr
    Condition JoinCondition
}

JoinTableExpr represents a TableExpr that's a JOIN operation.

func (*JoinTableExpr) Format Uses

func (node *JoinTableExpr) Format(buf *TrackedBuffer)

Format formats the node.

type LengthScaleOption Uses

type LengthScaleOption struct {
    Length *SQLVal
    Scale  *SQLVal
}

LengthScaleOption is used for types that have an optional length and scale

type Limit Uses

type Limit struct {
    Offset, Rowcount Expr
}

Limit represents a LIMIT clause.

func (*Limit) Format Uses

func (node *Limit) Format(buf *TrackedBuffer)

Format formats the node.

type ListArg Uses

type ListArg []byte

ListArg represents a named list argument.

func (ListArg) Format Uses

func (node ListArg) Format(buf *TrackedBuffer)

Format formats the node.

type MarginComments Uses

type MarginComments struct {
    Leading  string
    Trailing string
}

MarginComments holds the leading and trailing comments that surround a query.

func SplitMarginComments Uses

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 Uses

type MatchExpr struct {
    Columns SelectExprs
    Expr    Expr
    Option  string
}

MatchExpr represents a call to the MATCH function

func (*MatchExpr) Format Uses

func (node *MatchExpr) Format(buf *TrackedBuffer)

Format formats the node

type Nextval Uses

type Nextval struct {
    Expr Expr
}

Nextval defines the NEXT VALUE expression.

func (Nextval) Format Uses

func (node Nextval) Format(buf *TrackedBuffer)

Format formats the node.

type NodeFormatter Uses

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 Uses

type NotExpr struct {
    Expr Expr
}

NotExpr represents a NOT expression.

func (*NotExpr) Format Uses

func (node *NotExpr) Format(buf *TrackedBuffer)

Format formats the node.

type NullVal Uses

type NullVal struct{}

NullVal represents a NULL value.

func (*NullVal) Format Uses

func (node *NullVal) Format(buf *TrackedBuffer)

Format formats the node.

type OnDup Uses

type OnDup UpdateExprs

OnDup represents an ON DUPLICATE KEY clause.

func (OnDup) Format Uses

func (node OnDup) Format(buf *TrackedBuffer)

Format formats the node.

type OptLike Uses

type OptLike struct {
    LikeTable TableName
}

OptLike works for create table xxx like xxx

func (*OptLike) Format Uses

func (node *OptLike) Format(buf *TrackedBuffer)

Format formats the node.

type OrExpr Uses

type OrExpr struct {
    Left, Right Expr
}

OrExpr represents an OR expression.

func (*OrExpr) Format Uses

func (node *OrExpr) Format(buf *TrackedBuffer)

Format formats the node.

type Order Uses

type Order struct {
    Expr      Expr
    Direction string
}

Order represents an ordering expression.

func (*Order) Format Uses

func (node *Order) Format(buf *TrackedBuffer)

Format formats the node.

type OrderBy Uses

type OrderBy []*Order

OrderBy represents an ORDER By clause.

func (OrderBy) Format Uses

func (node OrderBy) Format(buf *TrackedBuffer)

Format formats the node.

type OtherAdmin Uses

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 Uses

func (node *OtherAdmin) Format(buf *TrackedBuffer)

Format formats the node.

type OtherRead Uses

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 Uses

func (node *OtherRead) Format(buf *TrackedBuffer)

Format formats the node.

type ParenExpr Uses

type ParenExpr struct {
    Expr Expr
}

ParenExpr represents a parenthesized boolean expression.

func (*ParenExpr) Format Uses

func (node *ParenExpr) Format(buf *TrackedBuffer)

Format formats the node.

type ParenSelect Uses

type ParenSelect struct {
    Select SelectStatement
}

ParenSelect is a parenthesized SELECT statement.

func (*ParenSelect) AddOrder Uses

func (node *ParenSelect) AddOrder(order *Order)

AddOrder adds an order by element

func (*ParenSelect) Format Uses

func (node *ParenSelect) Format(buf *TrackedBuffer)

Format formats the node.

func (*ParenSelect) SetLimit Uses

func (node *ParenSelect) SetLimit(limit *Limit)

SetLimit sets the limit clause

type ParenTableExpr Uses

type ParenTableExpr struct {
    Exprs TableExprs
}

ParenTableExpr represents a parenthesized list of TableExpr.

func (*ParenTableExpr) Format Uses

func (node *ParenTableExpr) Format(buf *TrackedBuffer)

Format formats the node.

type ParsedQuery Uses

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 Uses

func BuildParsedQuery(in string, vars ...interface{}) *ParsedQuery

BuildParsedQuery builds a ParsedQuery from the input.

func NewParsedQuery Uses

func NewParsedQuery(node SQLNode) *ParsedQuery

NewParsedQuery returns a ParsedQuery of the ast.

func (*ParsedQuery) Append Uses

func (pq *ParsedQuery) Append(buf *strings.Builder, bindVariables map[string]*querypb.BindVariable, extras map[string]Encodable) error

Append appends the generated query to the provided buffer.

func (*ParsedQuery) GenerateQuery Uses

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 Uses

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 Uses

type PartitionDefinition struct {
    Name     ColIdent
    Limit    Expr
    Maxvalue bool
}

PartitionDefinition describes a very minimal partition definition

func (*PartitionDefinition) Format Uses

func (node *PartitionDefinition) Format(buf *TrackedBuffer)

Format formats the node

type PartitionSpec Uses

type PartitionSpec struct {
    Action      string
    Name        ColIdent
    Definitions []*PartitionDefinition
}

PartitionSpec describe partition actions (for alter and create)

func (*PartitionSpec) Format Uses

func (node *PartitionSpec) Format(buf *TrackedBuffer)

Format formats the node.

type Partitions Uses

type Partitions Columns

Partitions is a type alias for Columns so we can handle printing efficiently

func (Partitions) Format Uses

func (node Partitions) Format(buf *TrackedBuffer)

Format formats the node

type PositionedErr Uses

type PositionedErr struct {
    Err  string
    Pos  int
    Near []byte
}

PositionedErr holds context related to parser errors

func (PositionedErr) Error Uses

func (p PositionedErr) Error() string

type RangeCond Uses

type RangeCond struct {
    Operator string
    Left     Expr
    From, To Expr
}

RangeCond represents a BETWEEN or a NOT BETWEEN expression.

func (*RangeCond) Format Uses

func (node *RangeCond) Format(buf *TrackedBuffer)

Format formats the node.

type ReferenceAction Uses

type ReferenceAction int

ReferenceAction indicates the action takes by a referential constraint e.g. the `CASCADE` in a `FOREIGN KEY .. ON DELETE CASCADE` table definition.

const (
    // DefaultAction indicates no action was explicitly specified.
    DefaultAction ReferenceAction = iota
    Restrict
    Cascade
    NoAction
    SetNull
    SetDefault
)

These map to the SQL-defined reference actions. See https://dev.mysql.com/doc/refman/8.0/en/create-table-foreign-keys.html#foreign-keys-referential-actions

func (ReferenceAction) Format Uses

func (a ReferenceAction) Format(buf *TrackedBuffer)

Format formats the node.

type RewriteASTResult Uses

type RewriteASTResult struct {
    AST              Statement
    NeedLastInsertID bool
    NeedDatabase     bool
}

RewriteASTResult contains the rewritten ast and meta information about it

func PrepareAST Uses

func PrepareAST(in Statement, bindVars map[string]*querypb.BindVariable, prefix string) (*RewriteASTResult, error)

PrepareAST will normalize the query

func RewriteAST Uses

func RewriteAST(in Statement) (*RewriteASTResult, error)

RewriteAST rewrites the whole AST, replacing function calls and adding column aliases to queries

type Rollback Uses

type Rollback struct{}

Rollback represents a Rollback statement.

func (*Rollback) Format Uses

func (node *Rollback) Format(buf *TrackedBuffer)

Format formats the node.

type SQLNode Uses

type SQLNode interface {
    Format(buf *TrackedBuffer)
}

SQLNode defines the interface for all nodes generated by the parser.

func Rewrite Uses

func Rewrite(node SQLNode, pre, post ApplyFunc) (result SQLNode)

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 Uses

type SQLVal struct {
    Type ValType
    Val  []byte
}

SQLVal represents a single value.

func NewBitVal Uses

func NewBitVal(in []byte) *SQLVal

NewBitVal builds a new BitVal containing a bit literal.

func NewFloatVal Uses

func NewFloatVal(in []byte) *SQLVal

NewFloatVal builds a new FloatVal.

func NewHexNum Uses

func NewHexNum(in []byte) *SQLVal

NewHexNum builds a new HexNum.

func NewHexVal Uses

func NewHexVal(in []byte) *SQLVal

NewHexVal builds a new HexVal.

func NewIntVal Uses

func NewIntVal(in []byte) *SQLVal

NewIntVal builds a new IntVal.

func NewStrVal Uses

func NewStrVal(in []byte) *SQLVal

NewStrVal builds a new StrVal.

func NewValArg Uses

func NewValArg(in []byte) *SQLVal

NewValArg builds a new ValArg.

func (*SQLVal) Format Uses

func (node *SQLVal) Format(buf *TrackedBuffer)

Format formats the node.

func (*SQLVal) HexDecode Uses

func (node *SQLVal) HexDecode() ([]byte, error)

HexDecode decodes the hexval into bytes.

type Select Uses

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
}

Select represents a SELECT statement.

func (*Select) AddHaving Uses

func (node *Select) AddHaving(expr Expr)

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) AddOrder Uses

func (node *Select) AddOrder(order *Order)

AddOrder adds an order by element

func (*Select) AddWhere Uses

func (node *Select) AddWhere(expr Expr)

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) Format Uses

func (node *Select) Format(buf *TrackedBuffer)

Format formats the node.

func (*Select) SetLimit Uses

func (node *Select) SetLimit(limit *Limit)

SetLimit sets the limit clause

type SelectExpr Uses

type SelectExpr interface {
    SQLNode
    // contains filtered or unexported methods
}

SelectExpr represents a SELECT expression.

type SelectExprs Uses

type SelectExprs []SelectExpr

SelectExprs represents SELECT expressions.

func (SelectExprs) Format Uses

func (node SelectExprs) Format(buf *TrackedBuffer)

Format formats the node.

type SelectStatement Uses

type SelectStatement interface {
    AddOrder(*Order)
    SetLimit(*Limit)
    SQLNode
    // contains filtered or unexported methods
}

SelectStatement any SELECT statement.

type Set Uses

type Set struct {
    Comments Comments
    Exprs    SetExprs
    Scope    string
}

Set represents a SET statement.

func (*Set) Format Uses

func (node *Set) Format(buf *TrackedBuffer)

Format formats the node.

type SetExpr Uses

type SetExpr struct {
    Name ColIdent
    Expr Expr
}

SetExpr represents a set expression.

func (*SetExpr) Format Uses

func (node *SetExpr) Format(buf *TrackedBuffer)

Format formats the node.

type SetExprs Uses

type SetExprs []*SetExpr

SetExprs represents a list of set expressions.

func (SetExprs) Format Uses

func (node SetExprs) Format(buf *TrackedBuffer)

Format formats the node.

type SetKey Uses

type SetKey struct {
    Key   string
    Scope string
}

SetKey is the extracted key from one SetExpr

type Show Uses

type Show struct {
    Type                   string
    OnTable                TableName
    Table                  TableName
    ShowTablesOpt          *ShowTablesOpt
    Scope                  string
    ShowCollationFilterOpt *Expr // TODO: this should not be a pointer
}

Show represents a show statement.

func (*Show) Format Uses

func (node *Show) Format(buf *TrackedBuffer)

Format formats the node.

func (*Show) HasOnTable Uses

func (node *Show) HasOnTable() bool

HasOnTable returns true if the show statement has an "on" clause

func (*Show) HasTable Uses

func (node *Show) HasTable() bool

HasTable returns true if the show statement has a parsed table name. Not all show statements parse table names.

type ShowFilter Uses

type ShowFilter struct {
    Like   string
    Filter Expr
}

ShowFilter is show tables filter

func (*ShowFilter) Format Uses

func (node *ShowFilter) Format(buf *TrackedBuffer)

Format formats the node.

type ShowTablesOpt Uses

type ShowTablesOpt struct {
    Full   string
    DbName string
    Filter *ShowFilter
}

ShowTablesOpt is show tables option

type SimpleTableExpr Uses

type SimpleTableExpr interface {
    SQLNode
    // contains filtered or unexported methods
}

SimpleTableExpr represents a simple table expression.

type StarExpr Uses

type StarExpr struct {
    TableName TableName
}

StarExpr defines a '*' or 'table.*' expression.

func (*StarExpr) Format Uses

func (node *StarExpr) Format(buf *TrackedBuffer)

Format formats the node.

type Statement Uses

type Statement interface {
    SQLNode
    // contains filtered or unexported methods
}

Statement represents a statement.

func Parse Uses

func Parse(sql string) (Statement, error)

Parse parses the SQL in full and returns a Statement, which is the AST representation of the query. If a DDL statement is partially parsed but still contains a syntax error, the error is ignored and the DDL is returned anyway.

func ParseNext Uses

func ParseNext(tokenizer *Tokenizer) (Statement, error)

ParseNext parses a single SQL statement from the tokenizer returning a Statement which is the AST representation of the query. The tokenizer will always read up to the end of the statement, allowing for the next call to ParseNext to parse any subsequent SQL statements. When there are no more statements to parse, a error of io.EOF is returned.

func ParseNextStrictDDL Uses

func ParseNextStrictDDL(tokenizer *Tokenizer) (Statement, error)

ParseNextStrictDDL is the same as ParseNext except it errors on partially parsed DDL statements.

func ParseStrictDDL Uses

func ParseStrictDDL(sql string) (Statement, error)

ParseStrictDDL is the same as Parse except it errors on partially parsed DDL statements.

type StatementType Uses

type StatementType int

StatementType encodes the type of a SQL statement

const (
    StmtSelect StatementType = iota
    StmtStream
    StmtInsert
    StmtReplace
    StmtUpdate
    StmtDelete
    StmtDDL
    StmtBegin
    StmtCommit
    StmtRollback
    StmtSet
    StmtShow
    StmtUse
    StmtOther
    StmtUnknown
    StmtComment
    StmtPriv
)

These constants are used to identify the SQL statement type. Changing this list will require reviewing all calls to Preview.

func Preview Uses

func Preview(sql string) StatementType

Preview analyzes the beginning of the query using a simpler and faster textual comparison to identify the statement type.

func (StatementType) String Uses

func (s StatementType) String() string

type Stream Uses

type Stream struct {
    Comments   Comments
    SelectExpr SelectExpr
    Table      TableName
}

Stream represents a SELECT statement.

func (*Stream) Format Uses

func (node *Stream) Format(buf *TrackedBuffer)

Format formats the node.

type Subquery Uses

type Subquery struct {
    Select SelectStatement
}

Subquery represents a subquery.

func (*Subquery) Format Uses

func (node *Subquery) Format(buf *TrackedBuffer)

Format formats the node.

type SubstrExpr Uses

type SubstrExpr struct {
    Name   *ColName
    StrVal *SQLVal
    From   Expr
    To     Expr
}

SubstrExpr represents a call to SubstrExpr(column, value_expression) or SubstrExpr(column, value_expression,value_expression) also supported syntax SubstrExpr(column from value_expression for value_expression). Additionally to column names, SubstrExpr is also supported for string values, e.g.: SubstrExpr('static string value', value_expression, value_expression) In this case StrVal will be set instead of Name.

func (*SubstrExpr) Format Uses

func (node *SubstrExpr) Format(buf *TrackedBuffer)

Format formats the node.

type TableExpr Uses

type TableExpr interface {
    SQLNode
    // contains filtered or unexported methods
}

TableExpr represents a table expression.

type TableExprs Uses

type TableExprs []TableExpr

TableExprs represents a list of table expressions.

func (TableExprs) Format Uses

func (node TableExprs) Format(buf *TrackedBuffer)

Format formats the node.

type TableIdent Uses

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 Uses

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 Uses

func NewTableIdent(str string) TableIdent

NewTableIdent creates a new TableIdent.

func (TableIdent) CompliantName Uses

func (node TableIdent) CompliantName() string

CompliantName returns a compliant id name that can be used for a bind var.

func (TableIdent) Format Uses

func (node TableIdent) Format(buf *TrackedBuffer)

Format formats the node.

func (TableIdent) IsEmpty Uses

func (node TableIdent) IsEmpty() bool

IsEmpty returns true if TabIdent is empty.

func (TableIdent) MarshalJSON Uses

func (node TableIdent) MarshalJSON() ([]byte, error)

MarshalJSON marshals into JSON.

func (TableIdent) String Uses

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 Uses

func (node *TableIdent) UnmarshalJSON(b []byte) error

UnmarshalJSON unmarshals from JSON.

type TableName Uses

type TableName struct {
    Name, Qualifier TableIdent
}

TableName represents a table name. Qualifier, if specified, represents a database or keyspace. TableName is a value struct whose fields are case sensitive. This means two TableName vars can be compared for equality and a TableName can also be used as key in a map.

func TableFromStatement Uses

func TableFromStatement(sql string) (TableName, error)

TableFromStatement returns the qualified table name for the query. This works only for select statements.

func (TableName) Format Uses

func (node TableName) Format(buf *TrackedBuffer)

Format formats the node.

func (TableName) IsEmpty Uses

func (node TableName) IsEmpty() bool

IsEmpty returns true if TableName is nil or empty.

func (TableName) ToViewName Uses

func (node TableName) ToViewName() TableName

ToViewName returns a TableName acceptable for use as a VIEW. VIEW names are always lowercase, so ToViewName lowercasese the name. Databases are case-sensitive so Qualifier is left untouched.

type TableNames Uses

type TableNames []TableName

TableNames is a list of TableName.

func (TableNames) Format Uses

func (node TableNames) Format(buf *TrackedBuffer)

Format formats the node.

type TableSpec Uses

type TableSpec struct {
    Columns     []*ColumnDefinition
    Indexes     []*IndexDefinition
    Constraints []*ConstraintDefinition
    Options     string
}

TableSpec describes the structure of a table from a CREATE TABLE statement

func (*TableSpec) AddColumn Uses

func (ts *TableSpec) AddColumn(cd *ColumnDefinition)

AddColumn appends the given column to the list in the spec

func (*TableSpec) AddConstraint Uses

func (ts *TableSpec) AddConstraint(cd *ConstraintDefinition)

AddConstraint appends the given index to the list in the spec

func (*TableSpec) AddIndex Uses

func (ts *TableSpec) AddIndex(id *IndexDefinition)

AddIndex appends the given index to the list in the spec

func (*TableSpec) Format Uses

func (ts *TableSpec) Format(buf *TrackedBuffer)

Format formats the node.

type TimestampFuncExpr Uses

type TimestampFuncExpr struct {
    Name  string
    Expr1 Expr
    Expr2 Expr
    Unit  string
}

TimestampFuncExpr represents the function and arguments for TIMESTAMP{ADD,DIFF} functions.

func (*TimestampFuncExpr) Format Uses

func (node *TimestampFuncExpr) Format(buf *TrackedBuffer)

Format formats the node.

type Tokenizer Uses

type Tokenizer struct {
    InStream            io.Reader
    AllowComments       bool
    SkipSpecialComments bool
    SkipToEnd           bool

    Position int

    LastError error

    ParseTree Statement
    // contains filtered or unexported fields
}

Tokenizer is the struct used to generate SQL tokens for the parser.

func NewStringTokenizer Uses

func NewStringTokenizer(sql string) *Tokenizer

NewStringTokenizer creates a new Tokenizer for the sql string.

func NewTokenizer Uses

func NewTokenizer(r io.Reader) *Tokenizer

NewTokenizer creates a new Tokenizer reading a sql string from the io.Reader.

func (*Tokenizer) Error Uses

func (tkn *Tokenizer) Error(err string)

Error is called by go yacc if there's a parsing error.

func (*Tokenizer) Lex Uses

func (tkn *Tokenizer) Lex(lval *yySymType) int

Lex returns the next token form the Tokenizer. This function is used by go yacc.

func (*Tokenizer) Scan Uses

func (tkn *Tokenizer) Scan() (int, []byte)

Scan scans the tokenizer for the next token and returns the token type and an optional value.

type TrackedBuffer Uses

type TrackedBuffer struct {
    *strings.Builder
    // contains filtered or unexported fields
}

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 Uses

func NewTrackedBuffer(nodeFormatter NodeFormatter) *TrackedBuffer

NewTrackedBuffer creates a new TrackedBuffer.

func (*TrackedBuffer) HasBindVars Uses

func (buf *TrackedBuffer) HasBindVars() bool

HasBindVars returns true if the parsed query uses bind vars.

func (*TrackedBuffer) Myprintf Uses

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 Uses

func (buf *TrackedBuffer) ParsedQuery() *ParsedQuery

ParsedQuery returns a ParsedQuery that contains bind locations for easy substitution.

func (*TrackedBuffer) WriteArg Uses

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 Uses

func (buf *TrackedBuffer) WriteNode(node SQLNode) *TrackedBuffer

WriteNode function, initiates the writing of a single SQLNode tree by passing through to Myprintf with a default format string

type TupleEqualityList Uses

type TupleEqualityList struct {
    Columns []ColIdent
    Rows    [][]sqltypes.Value
}

TupleEqualityList is for generating equality constraints for tables that have composite primary keys.

func (*TupleEqualityList) EncodeSQL Uses

func (tpl *TupleEqualityList) EncodeSQL(buf *strings.Builder)

EncodeSQL generates the where clause constraints for the tuple equality.

type UnaryExpr Uses

type UnaryExpr struct {
    Operator string
    Expr     Expr
}

UnaryExpr represents a unary value expression.

func (*UnaryExpr) Format Uses

func (node *UnaryExpr) Format(buf *TrackedBuffer)

Format formats the node.

type Union Uses

type Union struct {
    Type        string
    Left, Right SelectStatement
    OrderBy     OrderBy
    Limit       *Limit
    Lock        string
}

Union represents a UNION statement.

func (*Union) AddOrder Uses

func (node *Union) AddOrder(order *Order)

AddOrder adds an order by element

func (*Union) Format Uses

func (node *Union) Format(buf *TrackedBuffer)

Format formats the node.

func (*Union) SetLimit Uses

func (node *Union) SetLimit(limit *Limit)

SetLimit sets the limit clause

type Update Uses

type Update struct {
    Comments   Comments
    Ignore     string
    TableExprs TableExprs
    Exprs      UpdateExprs
    Where      *Where
    OrderBy    OrderBy
    Limit      *Limit
}

Update represents an UPDATE statement. If you add fields here, consider adding them to calls to validateUnshardedRoute.

func (*Update) Format Uses

func (node *Update) Format(buf *TrackedBuffer)

Format formats the node.

type UpdateExpr Uses

type UpdateExpr struct {
    Name *ColName
    Expr Expr
}

UpdateExpr represents an update expression.

func (*UpdateExpr) Format Uses

func (node *UpdateExpr) Format(buf *TrackedBuffer)

Format formats the node.

type UpdateExprs Uses

type UpdateExprs []*UpdateExpr

UpdateExprs represents a list of update expressions.

func (UpdateExprs) Format Uses

func (node UpdateExprs) Format(buf *TrackedBuffer)

Format formats the node.

type Use Uses

type Use struct {
    DBName TableIdent
}

Use represents a use statement.

func (*Use) Format Uses

func (node *Use) Format(buf *TrackedBuffer)

Format formats the node.

type ValTuple Uses

type ValTuple Exprs

ValTuple represents a tuple of actual values.

func (ValTuple) Format Uses

func (node ValTuple) Format(buf *TrackedBuffer)

Format formats the node.

type ValType Uses

type ValType int

ValType specifies the type for SQLVal.

type Values Uses

type Values []ValTuple

Values represents a VALUES clause.

func (Values) Format Uses

func (node Values) Format(buf *TrackedBuffer)

Format formats the node.

type ValuesFuncExpr Uses

type ValuesFuncExpr struct {
    Name *ColName
}

ValuesFuncExpr represents a function call.

func (*ValuesFuncExpr) Format Uses

func (node *ValuesFuncExpr) Format(buf *TrackedBuffer)

Format formats the node.

type VindexParam Uses

type VindexParam struct {
    Key ColIdent
    Val string
}

VindexParam defines a key/value parameter for a CREATE VINDEX statement

func (VindexParam) Format Uses

func (node VindexParam) Format(buf *TrackedBuffer)

Format formats the node.

type VindexSpec Uses

type VindexSpec struct {
    Name   ColIdent
    Type   ColIdent
    Params []VindexParam
}

VindexSpec defines a vindex for a CREATE VINDEX or DROP VINDEX statement

func (*VindexSpec) Format Uses

func (node *VindexSpec) Format(buf *TrackedBuffer)

Format formats the node. The "CREATE VINDEX" preamble was formatted in the containing DDL node Format, so this just prints the type, any parameters, and optionally the owner

func (*VindexSpec) ParseParams Uses

func (node *VindexSpec) ParseParams() (string, map[string]string)

ParseParams parses the vindex parameter list, pulling out the special-case "owner" parameter

type Visit Uses

type Visit func(node SQLNode) (kontinue bool, err error)

Visit defines the signature of a function that can be used to visit all nodes of a parse tree.

type When Uses

type When struct {
    Cond Expr
    Val  Expr
}

When represents a WHEN sub-expression.

func (*When) Format Uses

func (node *When) Format(buf *TrackedBuffer)

Format formats the node.

type Where Uses

type Where struct {
    Type string
    Expr Expr
}

Where represents a WHERE or HAVING clause.

func NewWhere Uses

func NewWhere(typ string, expr Expr) *Where

NewWhere creates a WHERE or HAVING clause out of a Expr. If the expression is nil, it returns nil.

func (*Where) Format Uses

func (node *Where) Format(buf *TrackedBuffer)

Format formats the node.

Directories

PathSynopsis
visitorgenPackage visitorgen is responsible for taking the ast.go of Vitess and and producing visitor infrastructure for it.
visitorgen/main

Package sqlparser imports 19 packages (graph) and is imported by 77 packages. Updated 2020-02-12. Refresh now. Tools for package owners.