sqlparser

package
v1.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 27, 2021 License: BSD-3-Clause Imports: 13 Imported by: 0

Documentation

Index

Constants

View Source
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.

View Source
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.

View Source
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"
)
View Source
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"

	// InsertStr represents insert action.
	InsertStr = "insert"
	// ReplaceStr represents replace action.
	ReplaceStr = "replace"

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

	// DDL strings.
	CreateDBStr             = "create database"
	CreateTableStr          = "create table"
	CreatePartitionTableStr = "create partition table"
	CreateIndexStr          = "create index"
	DropDBStr               = "drop database"
	DropTableStr            = "drop table"
	DropIndexStr            = "drop index"
	AlterStr                = "alter"
	AlterEngineStr          = "alter table"
	AlterCharsetStr         = "alter table charset"
	AlterAddColumnStr       = "alter table add column"
	AlterDropColumnStr      = "alter table drop column"
	AlterModifyColumnStr    = "alter table modify column"
	RenameStr               = "rename table"
	TruncateTableStr        = "truncate table"
	SingleTableType         = "singletable"
	GlobalTableType         = "globaltable"
	PartitionTableHash      = "partitiontablehash"
	NormalTableType         = "normaltable"
	PartitionTableList      = "partitiontablelist"

	// Index key type strings.
	IndexStr    = "index "
	FullTextStr = "fulltext index "
	SpatialStr  = "spatial index "
	UniqueStr   = "unique index "

	// The following constants represent SHOW statements.
	ShowDatabasesStr      = "databases"
	ShowCreateDatabaseStr = "create database"
	ShowTableStatusStr    = "table status"
	ShowTablesStr         = "tables"
	ShowColumnsStr        = "columns"
	ShowCreateTableStr    = "create table"
	ShowEnginesStr        = "engines"
	ShowStatusStr         = "status"
	ShowVersionsStr       = "versions"
	ShowProcesslistStr    = "processlist"
	ShowQueryzStr         = "queryz"
	ShowTxnzStr           = "txnz"
	ShowWarningsStr       = "warnings"
	ShowVariablesStr      = "variables"
	ShowBinlogEventsStr   = "binlog events"
	ShowUnsupportedStr    = "unsupported"

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

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

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

	// ComparisonExpr.Operator
	EqualStr             = "="
	LessThanStr          = "<"
	GreaterThanStr       = ">"
	LessEqualStr         = "<="
	GreaterEqualStr      = ">="
	NotEqualStr          = "!="
	NullSafeEqualStr     = "<=>"
	InStr                = "in"
	NotInStr             = "not in"
	LikeStr              = "like"
	NotLikeStr           = "not like"
	RegexpStr            = "regexp"
	NotRegexpStr         = "not regexp"
	JSONExtractOp        = "->"
	JSONUnquoteExtractOp = "->>"

	// RangeCond.Operator
	BetweenStr    = "between"
	NotBetweenStr = "not between"

	// IsExpr.Operator
	IsNullStr     = "is null"
	IsNotNullStr  = "is not null"
	IsTrueStr     = "is true"
	IsNotTrueStr  = "is not true"
	IsFalseStr    = "is false"
	IsNotFalseStr = "is not false"

	// BinaryExpr.Operator
	BitAndStr     = "&"
	BitOrStr      = "|"
	BitXorStr     = "^"
	PlusStr       = "+"
	MinusStr      = "-"
	MultStr       = "*"
	DivStr        = "/"
	IntDivStr     = "div"
	ModStr        = "%"
	ShiftLeftStr  = "<<"
	ShiftRightStr = ">>"

	// UnaryExpr.Operator.
	UPlusStr  = "+"
	UMinusStr = "-"
	TildaStr  = "~"
	BangStr   = "!"
	BinaryStr = "binary "

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

	// MatchExpr.Option.
	BooleanModeStr                           = " in boolean mode"
	NaturalLanguageModeStr                   = " in natural language mode"
	NaturalLanguageModeWithQueryExpansionStr = " in natural language mode with query expansion"
	QueryExpansionStr                        = " with query expansion"

	// Order.Direction.
	AscScr  = "asc"
	DescScr = "desc"

	AttachStr     = "attach"
	DetachStr     = "detach"
	AttachListStr = "attachlist"
	ReshardStr    = "reshard"
	CleanupStr    = "cleanup"

	// Transaction isolation levels.
	ReadUncommitted = "read uncommitted"
	ReadCommitted   = "read committed"
	RepeatableRead  = "repeatable read"
	Serializable    = "serializable"

	// Transaction access mode.
	TxReadOnly  = "read only"
	TxReadWrite = "read write"

	// StartTxnStr represents the txn start transaction.
	StartTxnStr = "start transaction"

	// BeginTxnStr represents the txn begin.
	BeginTxnStr = "begin"

	// RollbackTxnStr represents the txn rollback.
	RollbackTxnStr = "rollback"

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

Variables

View Source
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 Append

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

Append appends the SQLNode to the buffer.

func Backtick

func Backtick(in string) string

Backtick produces a backticked literal given an input string.

func CheckIndexAlgorithm

func CheckIndexAlgorithm(algorithm string) bool

CheckIndexAlgorithm use to check if the string value matches a supported value. Supported values: inplace, copy, default.

func CheckIndexLock

func CheckIndexLock(lock string) bool

CheckIndexLock use to check if the string value matches a supported value. Supported values: default, exclusive, none, shared.

func EncodeValue

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

EncodeValue encodes one bind variable value into the query.

func ExtractMysqlComment

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

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

func IsColName(node Expr) bool

IsColName returns true if the Expr is a *ColName.

func IsDML

func IsDML(sql string) bool

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

func IsNull

func IsNull(node Expr) bool

IsNull returns true if the Expr is SQL NULL

func IsSimpleTuple

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

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 NewPlanValue

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

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

func Preview(sql string) int

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

func SkipQueryPlanCacheDirective

func SkipQueryPlanCacheDirective(stmt Statement) bool

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

func StrToLower

func StrToLower(str string) string

StrToLower use to convert str to lower string

func String

func String(node SQLNode) string

String returns a string representation of an SQLNode.

func StringIn

func StringIn(str string, values ...string) bool

StringIn is a convenience function that returns true if str matches any of the values.

func StripComments

func StripComments(sql string) string

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

func StripLeadingComments

func StripLeadingComments(sql string) string

StripLeadingComments trims the SQL string and removes any leading comments

func Walk

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.

Types

type AliasedExpr

type AliasedExpr struct {
	Expr Expr
	As   ColIdent
}

AliasedExpr defines an aliased SELECT expression.

func (*AliasedExpr) Format

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

Format formats the node.

type AliasedTableExpr

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

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

func (*AliasedTableExpr) Format

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

Format formats the node.

type AndExpr

type AndExpr struct {
	Left, Right Expr
}

AndExpr represents an AND expression.

func (*AndExpr) Format

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

Format formats the node.

type ApplyFunc

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 BinaryExpr

type BinaryExpr struct {
	Operator    string
	Left, Right Expr
}

BinaryExpr represents a binary value expression.

func (*BinaryExpr) Format

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

Format formats the node.

type BoolVal

type BoolVal bool

BoolVal is true or false.

func (BoolVal) Format

func (node BoolVal) Format(buf *TrackedBuffer)

Format formats the node.

type CaseExpr

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

CaseExpr represents a CASE expression.

func (*CaseExpr) Format

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

Format formats the node.

type Checksum

type Checksum struct {
	Table TableName
}

Checksum represents a CHECKSUM statement.

func (*Checksum) Format

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

Format formats the node.

type ColIdent

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

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

func NewColIdent

func NewColIdent(str string) ColIdent

NewColIdent makes a new ColIdent.

func (ColIdent) CompliantName

func (node ColIdent) CompliantName() string

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

func (ColIdent) Equal

func (node ColIdent) Equal(in ColIdent) bool

Equal performs a case-insensitive compare.

func (ColIdent) EqualString

func (node ColIdent) EqualString(str string) bool

EqualString performs a case-insensitive compare with str.

func (ColIdent) Format

func (node ColIdent) Format(buf *TrackedBuffer)

Format formats the node.

func (ColIdent) IsEmpty

func (node ColIdent) IsEmpty() bool

IsEmpty returns true if the name is empty.

func (ColIdent) Lowered

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

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

MarshalJSON marshals into JSON.

func (ColIdent) String

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

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

UnmarshalJSON unmarshals from JSON.

type ColName

type ColName struct {
	// Metadata is not populated by the parser.
	// It's a placeholder for analyzers to store
	// additional data, typically info about which
	// table or column this node references.
	Metadata  interface{}
	Name      ColIdent
	Qualifier TableName
}

ColName represents a column name.

func (*ColName) Equal

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

Equal returns true if the column names match.

func (*ColName) Format

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

Format formats the node.

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

type CollateExpr struct {
	Expr    Expr
	Charset string
}

CollateExpr represents dynamic collate operator.

func (*CollateExpr) Format

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

Format formats the node.

type ColumnDefinition

type ColumnDefinition struct {
	Name ColIdent
	Type ColumnType
}

ColumnDefinition describes a column in a CREATE TABLE statement

func (*ColumnDefinition) Format

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

Format formats the node.

type ColumnOpt

type ColumnOpt int
const (
	ColumnOptionNone ColumnOpt = iota

	// NotNull enum.
	ColumnOptionNotNull

	// Autoincrement enum.
	ColumnOptionAutoincrement

	// Default enum.
	ColumnOptionDefault

	// Comment enum.
	ColumnOptionComment

	// OnUpdate enum
	ColumnOptionOnUpdate

	// PrimarykeyOption enum.
	ColumnOptionKeyPrimaryOpt

	// UniquekeyOption enum.
	ColumnOptionKeyUniqueOpt

	// CollateOption enum
	ColumnOptionCollate

	// ColumnFormatOption enum
	ColumnOptionFormat

	// ColumnStorageOption enum
	ColumnOptionStorage
)

type ColumnOption

type ColumnOption struct {

	// Generic field options.
	NotNull       BoolVal
	Autoincrement BoolVal
	Default       *SQLVal
	Comment       *SQLVal
	OnUpdate      string
	Collate       *SQLVal
	ColumnFormat  string
	Storage       string
	// Key specification
	PrimaryKeyOpt ColumnPrimaryKeyOption
	UniqueKeyOpt  ColumnUniqueKeyOption
	// contains filtered or unexported fields
}

func (ColumnOption) GetOptType

func (col ColumnOption) GetOptType() ColumnOpt

type ColumnOptionListOpt

type ColumnOptionListOpt struct {
	ColOptList []*ColumnOption
}

func (*ColumnOptionListOpt) GetColumnOption

func (co *ColumnOptionListOpt) GetColumnOption(opt ColumnOpt) *ColumnOption

type ColumnPrimaryKeyOption

type ColumnPrimaryKeyOption int

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

const (
	// ColKeyPrimaryNone enum.
	ColKeyPrimaryNone ColumnPrimaryKeyOption = iota

	// ColKeyPrimary enum.
	ColKeyPrimary
)

type ColumnType

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

	// Generic field options.
	NotNull       BoolVal
	Autoincrement BoolVal
	Default       *SQLVal
	OnUpdate      string
	Comment       *SQLVal
	Collate       *SQLVal
	ColumnFormat  string
	Storage       string

	// Numeric field options
	Length   *SQLVal
	Unsigned BoolVal
	Zerofill BoolVal
	Scale    *SQLVal

	// Text field options
	Charset string

	// Enum values
	EnumValues []string

	// Key specification
	PrimaryKeyOpt ColumnPrimaryKeyOption
	UniqueKeyOpt  ColumnUniqueKeyOption
}

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

func (*ColumnType) Format

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

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

type ColumnUniqueKeyOption

type ColumnUniqueKeyOption int

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

const (
	// ColKeyUniqueNone enum.
	ColKeyUniqueNone ColumnUniqueKeyOption = iota

	// ColKeyUniqueKey enum.
	ColKeyUniqueKey
)

type Columns

type Columns []ColIdent

Columns represents an insert column list.

func (Columns) FindColumn

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

func (node Columns) Format(buf *TrackedBuffer)

Format formats the node.

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

func (node Comments) Format(buf *TrackedBuffer)

Format formats the node.

type ComparisonExpr

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

ComparisonExpr represents a two-value comparison expression.

func (*ComparisonExpr) Format

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

Format formats the node.

type ConvertExpr

type ConvertExpr struct {
	Expr Expr
	Type *ConvertType
}

ConvertExpr represents a call to CONVERT(expr, type) or it's equivalent CAST(expr AS type). Both are rewritten to the former.

func (*ConvertExpr) Format

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

Format formats the node.

type ConvertType

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

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

Format formats the node.

type ConvertUsingExpr

type ConvertUsingExpr struct {
	Expr Expr
	Type string
}

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

func (*ConvertUsingExpr) Format

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

Format formats the node.

type Cursor

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

A Cursor describes a node encountered during Apply. Information about the node and its parent is available from the Node and Parent methods.

func (*Cursor) Node

func (c *Cursor) Node() SQLNode

Node returns the current Node.

func (*Cursor) Parent

func (c *Cursor) Parent() SQLNode

Parent returns the parent of the current Node.

func (*Cursor) Replace

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 DDL

type DDL struct {
	Action          string
	Engine          string
	Charset         string
	IndexName       string
	PartitionName   string
	BackendName     string
	IfExists        bool
	IfNotExists     bool
	Table           TableName
	NewName         TableName
	Database        TableIdent
	DatabaseOptions DatabaseOptionListOpt
	TableSpec       *TableSpec

	// [UNIQUE | FULLTEXT | SPATIAL] index.
	IndexType string
	IndexOpts *IndexOptions

	// Tables is set if Action is DropStr.
	Tables TableNames

	// table column operation
	DropColumnName  string
	ModifyColumnDef *ColumnDefinition

	// Partition options.
	PartitionOptions PartitionOptions
	PartitionNum     *SQLVal
}

DDL represents a CREATE, ALTER, DROP or RENAME statement. Table is set for AlterStr, DropStr, RenameStr. NewName is set for AlterStr, CreateStr, RenameStr.

func (*DDL) Format

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

Format formats the node.

type DatabaseOption

type DatabaseOption struct {
	Value            string
	CharsetOrCollate string
}

DatabaseOption represents database option. See: https://dev.mysql.com/doc/refman/5.7/en/create-database.html

type DatabaseOptionListOpt

type DatabaseOptionListOpt struct {
	DBOptList []*DatabaseOption
}

func (DatabaseOptionListOpt) Format

func (optList DatabaseOptionListOpt) Format(buf *TrackedBuffer)

Format formats the node

type Default

type Default struct {
	ColName string
}

Default represents a DEFAULT expression.

func (*Default) Format

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

Format formats the node.

type Delete

type Delete struct {
	Comments Comments
	Table    TableName
	Where    *Where
	OrderBy  OrderBy
	Limit    *Limit
}

Delete represents a DELETE statement.

func (*Delete) Format

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

Format formats the node.

type Encodable

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

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

type ExistsExpr

type ExistsExpr struct {
	Subquery *Subquery
}

ExistsExpr represents an EXISTS expression.

func (*ExistsExpr) Format

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

Format formats the node.

type Explain

type Explain struct{}

Explain represents a explain statement.

func (*Explain) Format

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

Format formats the node.

type Expr

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

Expr represents an expression.

func CloneExpr

func CloneExpr(node Expr) Expr

CloneExpr used to copy a new Expr.

func ReplaceExpr

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.

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

func (node Exprs) Format(buf *TrackedBuffer)

Format formats the node.

type FuncExpr

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

FuncExpr represents a function call.

func (*FuncExpr) Format

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

Format formats the node.

func (*FuncExpr) IsAggregate

func (node *FuncExpr) IsAggregate() bool

IsAggregate returns true if the function is an aggregate.

type GroupBy

type GroupBy Exprs

GroupBy represents a GROUP BY clause.

func (GroupBy) Format

func (node GroupBy) Format(buf *TrackedBuffer)

Format formats the node.

type GroupConcatExpr

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

GroupConcatExpr represents a call to GROUP_CONCAT

func (*GroupConcatExpr) Format

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

Format formats the node

type IndexColumn

type IndexColumn struct {
	Column ColIdent
	Length *SQLVal
}

IndexColumn describes a column in an index definition with optional length

type IndexDefinition

type IndexDefinition struct {
	Type    string
	Name    ColIdent
	Opts    *IndexOptions
	Primary bool
	Unique  bool
}

IndexDefinition describes an index in a CREATE TABLE statement

func (*IndexDefinition) Format

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

Format formats the node.

type IndexHints

type IndexHints struct {
	Type    string
	Indexes []ColIdent
}

IndexHints represents a list of index hints.

func (*IndexHints) Format

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

Format formats the node.

type IndexOption

type IndexOption struct {
	Type IndexOptionType
	Val  *SQLVal
}

IndexOption represents the index options. See https://dev.mysql.com/doc/refman/5.7/en/create-index.html.

type IndexOptionType

type IndexOptionType int

IndexOptionType is the type for IndexOption.

const (
	// IndexOptionNone enum.
	IndexOptionNone IndexOptionType = iota
	// IndexOptionComment is 'comment' enum.
	IndexOptionComment
	// IndexOptionUsing is 'using' enum.
	IndexOptionUsing
	// IndexOptionBlockSize is 'key_block_size' enum.
	IndexOptionBlockSize
	// IndexOptionParser is 'with parser' enum.
	IndexOptionParser
	// IndexOptionAlgorithm is 'algorithm' enum.
	IndexOptionAlgorithm
	// IndexOptionLock is 'lock' enum.
	IndexOptionLock
)

type IndexOptions

type IndexOptions struct {
	Columns   []*IndexColumn
	Using     string
	Comment   string
	BlockSize *SQLVal
	Parser    string
	Algorithm string
	Lock      string
}

IndexOptions is used by IndexOpts.

func NewIndexOptions

func NewIndexOptions(columns []*IndexColumn, idxOptList []*IndexOption) *IndexOptions

NewIndexOptions use to create IndexOptions.

func (*IndexOptions) Format

func (opts *IndexOptions) Format(buf *TrackedBuffer)

Format formats the node.

type Insert

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

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

func (*Insert) Format

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

Format formats the node.

type InsertRows

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

InsertRows represents the rows for an INSERT statement.

type InsertValues

type InsertValues [][]sqltypes.Value

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

type IntervalExpr struct {
	Expr Expr
	Unit string
}

IntervalExpr represents a date-time INTERVAL expression.

func (*IntervalExpr) Format

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

Format formats the node.

type IsExpr

type IsExpr struct {
	Operator string
	Expr     Expr
}

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

func (*IsExpr) Format

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

Format formats the node.

type JoinTableExpr

type JoinTableExpr struct {
	LeftExpr  TableExpr
	Join      string
	RightExpr TableExpr
	On        Expr
}

JoinTableExpr represents a TableExpr that's a JOIN operation.

func (*JoinTableExpr) Format

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

Format formats the node.

type Kill

type Kill struct {
	QueryID *NumVal
}

Kill represents a KILL statement.

func (*Kill) Format

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

Format formats the node.

type LengthScaleOption

type LengthScaleOption struct {
	Length *SQLVal
	Scale  *SQLVal
}

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

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

Format formats the node.

type ListArg

type ListArg []byte

ListArg represents a named list argument.

func (ListArg) Format

func (node ListArg) Format(buf *TrackedBuffer)

Format formats the node.

type MarginComments

type MarginComments struct {
	Leading  string
	Trailing string
}

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

func SplitMarginComments

func SplitMarginComments(sql string) (query string, comments MarginComments)

SplitMarginComments pulls out any leading or trailing comments from a raw sql query. This function also trims leading (if there's a comment) and trailing whitespace.

type MatchExpr

type MatchExpr struct {
	Columns SelectExprs
	Expr    Expr
	Option  string
}

MatchExpr represents a call to the MATCH function

func (*MatchExpr) Format

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

Format formats the node

type Nextval

type Nextval struct {
	Expr Expr
}

Nextval defines the NEXT VALUE expression.

func (Nextval) Format

func (node Nextval) Format(buf *TrackedBuffer)

Format formats the node.

type NodeFormatter

type NodeFormatter func(buf *TrackedBuffer, node SQLNode)

NodeFormatter defines the signature of a custom node formatter function that can be given to TrackedBuffer for code generation.

type NotExpr

type NotExpr struct {
	Expr Expr
}

NotExpr represents a NOT expression.

func (*NotExpr) Format

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

Format formats the node.

type NullVal

type NullVal struct{}

NullVal represents a NULL value.

func (*NullVal) Format

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

Format formats the node.

type NumVal

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

NumVal represents numval tuple.

func (*NumVal) AsUint64

func (exp *NumVal) AsUint64() uint64

AsUint64 returns uint64 value.

type OnDup

type OnDup UpdateExprs

OnDup represents an ON DUPLICATE KEY clause.

func (OnDup) Format

func (node OnDup) Format(buf *TrackedBuffer)

Format formats the node.

type OptVal

type OptVal struct {
	Value Expr
}

OptVal represents the set variable value. See https://dev.mysql.com/doc/refman/5.7/en/set-variable.html

func (*OptVal) Format

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

Format formats the node.

type OrExpr

type OrExpr struct {
	Left, Right Expr
}

OrExpr represents an OR expression.

func (*OrExpr) Format

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

Format formats the node.

type Order

type Order struct {
	Expr      Expr
	Direction string
}

Order represents an ordering expression.

func (*Order) Format

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

Format formats the node.

type OrderBy

type OrderBy []*Order

OrderBy represents an ORDER By clause.

func (OrderBy) Format

func (node OrderBy) Format(buf *TrackedBuffer)

Format formats the node.

type OtherAdmin

type OtherAdmin struct{}

OtherAdmin represents a misc statement that relies on ADMIN privileges, such as REPAIR, OPTIMIZE, or TRUNCATE statement. It should be used only as an indicator. It does not contain the full AST for the statement.

func (*OtherAdmin) Format

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

Format formats the node.

type OtherRead

type OtherRead struct{}

OtherRead represents a DESCRIBE, or EXPLAIN statement. It should be used only as an indicator. It does not contain the full AST for the statement.

func (*OtherRead) Format

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

Format formats the node.

type ParenExpr

type ParenExpr struct {
	Expr Expr
}

ParenExpr represents a parenthesized boolean expression.

func (*ParenExpr) Format

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

Format formats the node.

type ParenSelect

type ParenSelect struct {
	Select SelectStatement
}

ParenSelect is a parenthesized SELECT statement.

func (*ParenSelect) AddOrder

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

AddOrder adds an order by element

func (*ParenSelect) Format

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

Format formats the node.

func (*ParenSelect) SetLimit

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

SetLimit sets the limit clause

type ParenTableExpr

type ParenTableExpr struct {
	Exprs TableExprs
}

ParenTableExpr represents a parenthesized list of TableExpr.

func (*ParenTableExpr) Format

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

Format formats the node.

type ParsedQuery

type ParsedQuery struct {
	Query string
	// contains filtered or unexported fields
}

ParsedQuery represents a parsed query where bind locations are precompued for fast substitutions.

func BuildParsedQuery

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

BuildParsedQuery builds a ParsedQuery from the input.

func NewParsedQuery

func NewParsedQuery(node SQLNode) *ParsedQuery

NewParsedQuery returns a ParsedQuery of the ast.

func (*ParsedQuery) GenerateQuery

func (pq *ParsedQuery) GenerateQuery(bindVariables map[string]*querypb.BindVariable, extras map[string]Encodable) (string, error)

GenerateQuery generates a query by substituting the specified bindVariables. The extras parameter specifies special parameters that can perform custom encoding.

func (*ParsedQuery) MarshalJSON

func (pq *ParsedQuery) MarshalJSON() ([]byte, error)

MarshalJSON is a custom JSON marshaler for ParsedQuery. Note that any queries longer that 512 bytes will be truncated.

type PartitionDefinition

type PartitionDefinition struct {
	Backend string
	Row     ValTuple
}

PartitionDefinition defines a single partition.

type PartitionOptions

type PartitionOptions []*PartitionDefinition

PartitionOptions specifies the partition options.

type Radon

type Radon struct {
	Action  string
	Row     ValTuple
	Table   TableName
	NewName TableName
}

Radon represents the radon statement.

func (*Radon) Format

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

Format formats the node.

type RangeCond

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

RangeCond represents a BETWEEN or a NOT BETWEEN expression.

func (*RangeCond) Format

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

Format formats the node.

type SQLNode

type SQLNode interface {
	Format(buf *TrackedBuffer)
}

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

func Rewrite

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

type SQLVal struct {
	Type ValType
	Val  []byte
}

SQLVal represents a single value.

func NewFloatVal

func NewFloatVal(in []byte) *SQLVal

NewFloatVal builds a new FloatVal.

func NewHexNum

func NewHexNum(in []byte) *SQLVal

NewHexNum builds a new HexNum.

func NewHexVal

func NewHexVal(in []byte) *SQLVal

NewHexVal builds a new HexVal.

func NewIntVal

func NewIntVal(in []byte) *SQLVal

NewIntVal builds a new IntVal.

func NewStrVal

func NewStrVal(in []byte) *SQLVal

NewStrVal builds a new StrVal.

func NewStrValWithoutQuote

func NewStrValWithoutQuote(in []byte) *SQLVal

NewStrValWithoutQuote builds a new string that will be output without quote later in Format.

func NewValArg

func NewValArg(in []byte) *SQLVal

NewValArg builds a new ValArg.

func (*SQLVal) Format

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

Format formats the node.

func (*SQLVal) HexDecode

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

HexDecode decodes the hexval into bytes.

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

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

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

AddOrder adds an order by element

func (*Select) AddWhere

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

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

Format formats the node.

func (*Select) SetLimit

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

SetLimit sets the limit clause

type SelectExpr

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

SelectExpr represents a SELECT expression.

func CloneSelectExpr

func CloneSelectExpr(node SelectExpr) SelectExpr

CloneSelectExpr used to copy a new SelectExpr.

type SelectExprs

type SelectExprs []SelectExpr

SelectExprs represents SELECT expressions.

func (SelectExprs) Format

func (node SelectExprs) Format(buf *TrackedBuffer)

Format formats the node.

type SelectStatement

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

SelectStatement any SELECT statement.

type Set

type Set struct {
	Comments Comments
	Exprs    SetExprs
}

Set represents a SET statement.

func (*Set) Format

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

Format formats the node.

type SetExpr

type SetExpr struct {
	// global|session
	Scope string
	Type  ColIdent
	Val   SetVal
}

SetExpr represents a set expression.

func (*SetExpr) Format

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

Format formats the node.

type SetExprs

type SetExprs []*SetExpr

SetExprs represents a list of set expressions.

func (SetExprs) Format

func (node SetExprs) Format(buf *TrackedBuffer)

Format formats the node.

type SetVal

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

SetVal represents a set variable value.

type Show

type Show struct {
	Type     string
	Full     string
	Table    TableName
	Database TableName
	From     string
	Limit    *Limit
	Filter   *ShowFilter
}

Show represents a show statement.

func (*Show) Format

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

Format formats the node.

type ShowFilter

type ShowFilter struct {
	Like   string
	Filter Expr
}

ShowFilter is show tables filter

func (*ShowFilter) Format

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

Format formats the node.

type SimpleTableExpr

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

SimpleTableExpr represents a simple table expression.

type StarExpr

type StarExpr struct {
	TableName TableName
}

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

func (*StarExpr) Format

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

Format formats the node.

type Statement

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

Statement represents a statement.

func Parse

func Parse(sql string) (Statement, error)

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

func ParseStrictDDL(sql string) (Statement, error)

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

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

Format formats the node.

type TableExpr

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

TableExpr represents a table expression.

type TableExprs

type TableExprs []TableExpr

TableExprs represents a list of table expressions.

func (TableExprs) Format

func (node TableExprs) Format(buf *TrackedBuffer)

Format formats the node.

type TableIdent

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

TableIdent is a case sensitive SQL identifier. It will be escaped with backquotes if necessary.

func GetTableName

func GetTableName(node SimpleTableExpr) TableIdent

GetTableName returns the table name from the SimpleTableExpr only if it's a simple expression. Otherwise, it returns "".

func NewTableIdent

func NewTableIdent(str string) TableIdent

NewTableIdent creates a new TableIdent.

func (TableIdent) CompliantName

func (node TableIdent) CompliantName() string

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

func (TableIdent) Format

func (node TableIdent) Format(buf *TrackedBuffer)

Format formats the node.

func (TableIdent) IsEmpty

func (node TableIdent) IsEmpty() bool

IsEmpty returns true if TabIdent is empty.

func (TableIdent) MarshalJSON

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

MarshalJSON marshals into JSON.

func (TableIdent) String

func (node TableIdent) String() string

String returns the unescaped table name. It must not be used for SQL generation. Use sqlparser.String instead. The Stringer conformance is for usage in templates.

func (*TableIdent) UnmarshalJSON

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

UnmarshalJSON unmarshals from JSON.

type TableName

type TableName struct {
	Name, Qualifier TableIdent
}

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

func (TableName) Format

func (node TableName) Format(buf *TrackedBuffer)

Format formats the node.

func (TableName) IsEmpty

func (node TableName) IsEmpty() bool

IsEmpty returns true if TableName is nil or empty.

type TableNames

type TableNames []TableName

TableNames is a list of TableName.

func (TableNames) Format

func (node TableNames) Format(buf *TrackedBuffer)

Format formats the node.

type TableOption

type TableOption struct {
	Type TableOptionType
	Val  *SQLVal
}

TableOption represents the table options. See https://dev.mysql.com/doc/refman/5.7/en/create-table.html

type TableOptionListOpt

type TableOptionListOpt struct {
	TblOptList []*TableOption
}

func (*TableOptionListOpt) CheckIfTableOptDuplicate

func (tblOptList *TableOptionListOpt) CheckIfTableOptDuplicate() string

Although each option can be appeared many times in MySQL, we make a constraint that each option should only be appeared just one time in RadonDB.

func (*TableOptionListOpt) GetTableOptValByType

func (tblOptList *TableOptionListOpt) GetTableOptValByType(optType TableOptionType) *SQLVal

type TableOptionType

type TableOptionType int

TableOptionType is the type for table_options

const (
	TableOptionNone TableOptionType = iota
	TableOptionComment
	TableOptionEngine
	TableOptionCharset
	TableOptionTableType
	TableOptionAutoInc
	TableOptionAvgRowLength
	TableOptionChecksum
	TableOptionCollate
	TableOptionCompression
	TableOptionConnection
	TableOptionDataDirectory
	TableOptionIndexDirectory
	TableOptionDelayKeyWrite
	TableOptionEncryption
	TableOptionInsertMethod
	TableOptionKeyBlockSize
	TableOptionMaxRows
	TableOptionMinRows
	TableOptionPackKeys
	TableOptionPassword
	TableOptionRowFormat
	TableOptionStatsAutoRecalc
	TableOptionStatsPersistent
	TableOptionStatsSamplePages
	TableOptionTableSpace
)

type TableOptions

type TableOptions struct {
	Comment          string
	Engine           string
	Charset          string
	Type             string
	AvgRowLength     string
	Checksum         string
	Collate          string
	Compression      string
	Connection       string
	DataDirectory    string
	IndexDirectory   string
	DelayKeyWrite    string
	Encryption       string
	InsertMethod     string
	KeyBlockSize     string
	MaxRows          string
	MinRows          string
	PackKeys         string
	Password         string
	RowFormat        string
	StatsAutoRecalc  string
	StatsPersistent  string
	StatsSamplePages string
	TableSpace       string
}

TableOptions is used by TableSpec

func (TableOptions) Format

func (opts TableOptions) Format(buf *TrackedBuffer)

Format formats the node.

type TableSpec

type TableSpec struct {
	Columns []*ColumnDefinition
	Indexes []*IndexDefinition
	Options TableOptions
}

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

func (*TableSpec) AddColumn

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

AddColumn appends the given column to the list in the spec

func (*TableSpec) AddIndex

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

AddIndex appends the given index to the list in the spec

func (*TableSpec) Format

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

Format formats the node.

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

func NewStringTokenizer(sql string) *Tokenizer

NewStringTokenizer creates a new Tokenizer for the sql string.

func (*Tokenizer) Error

func (tkn *Tokenizer) Error(err string)

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

func (*Tokenizer) Lex

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

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

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

func NewTrackedBuffer(nodeFormatter NodeFormatter) *TrackedBuffer

NewTrackedBuffer creates a new TrackedBuffer.

func (*TrackedBuffer) HasBindVars

func (buf *TrackedBuffer) HasBindVars() bool

HasBindVars returns true if the parsed query uses bind vars.

func (*TrackedBuffer) Myprintf

func (buf *TrackedBuffer) Myprintf(format string, values ...interface{})

Myprintf mimics fmt.Fprintf(buf, ...), but limited to Node(%v), Node.Value(%s) and string(%s). It also allows a %a for a value argument, in which case it adds tracking info for future substitutions.

The name must be something other than the usual Printf() to avoid "go vet" warnings due to our custom format specifiers.

func (*TrackedBuffer) ParsedQuery

func (buf *TrackedBuffer) ParsedQuery() *ParsedQuery

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

func (*TrackedBuffer) WriteArg

func (buf *TrackedBuffer) WriteArg(arg string)

WriteArg writes a value argument into the buffer along with tracking information for future substitutions. arg must contain the ":" or "::" prefix.

func (*TrackedBuffer) WriteNode

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

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

type Transaction

type Transaction struct {
	Action string
}

Transaction represents the transaction tuple.

func (*Transaction) Format

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

Format formats the node.

type TupleEqualityList

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

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

func (*TupleEqualityList) EncodeSQL

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

EncodeSQL generates the where clause constraints for the tuple equality.

type TxnVal

type TxnVal struct {
	Level string
	Mode  string
}

TxnVal represents the set-transaction characteristic. See https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html

func (*TxnVal) Format

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

Format formats the node.

type UnaryExpr

type UnaryExpr struct {
	Operator string
	Expr     Expr
}

UnaryExpr represents a unary value expression.

func (*UnaryExpr) Format

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

Format formats the node.

type Union

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

Union represents a UNION statement.

func (*Union) AddOrder

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

AddOrder adds an order by element

func (*Union) Format

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

Format formats the node.

func (*Union) SetLimit

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

SetLimit sets the limit clause

type Update

type Update struct {
	Comments Comments
	Table    TableName
	Exprs    UpdateExprs
	Where    *Where
	OrderBy  OrderBy
	Limit    *Limit
}

Update represents an UPDATE statement.

func (*Update) Format

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

Format formats the node.

type UpdateExpr

type UpdateExpr struct {
	Name *ColName
	Expr Expr
}

UpdateExpr represents an update expression.

func (*UpdateExpr) Format

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

Format formats the node.

type UpdateExprs

type UpdateExprs []*UpdateExpr

UpdateExprs represents a list of update expressions.

func (UpdateExprs) Format

func (node UpdateExprs) Format(buf *TrackedBuffer)

Format formats the node.

type Use

type Use struct {
	DBName TableIdent
}

Use represents a use statement.

func (*Use) Format

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

Format formats the node.

type ValTuple

type ValTuple Exprs

ValTuple represents a tuple of actual values.

func (ValTuple) Format

func (node ValTuple) Format(buf *TrackedBuffer)

Format formats the node.

type ValType

type ValType int

ValType specifies the type for SQLVal.

type Values

type Values []ValTuple

Values represents a VALUES clause.

func (Values) Format

func (node Values) Format(buf *TrackedBuffer)

Format formats the node.

type ValuesFuncExpr

type ValuesFuncExpr struct {
	Name     ColIdent
	Resolved Expr
}

ValuesFuncExpr represents a function call.

func (*ValuesFuncExpr) Format

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

Format formats the node.

type Visit

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

type When struct {
	Cond Expr
	Val  Expr
}

When represents a WHEN sub-expression.

func (*When) Format

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

Format formats the node.

type Where

type Where struct {
	Type string
	Expr Expr
}

Where represents a WHERE or HAVING clause.

func NewWhere

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

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

Format formats the node.

type Xa

type Xa struct{}

Xa represents a XA statement.

func (*Xa) Format

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

Format formats the node.

Directories

Path Synopsis
depends
query
Package query is a generated protocol buffer package.
Package query is a generated protocol buffer package.
sqltypes
Package sqltypes implements interfaces and types that represent SQL values.
Package sqltypes implements interfaces and types that represent SQL values.
Package visitorgen is responsible for taking the ast.go of Vitess and producing visitor infrastructure for it.
Package visitorgen is responsible for taking the ast.go of Vitess and producing visitor infrastructure for it.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL