GeezerVison

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

const (
	DistinctStr      = "distinct "
	StraightJoinHint = "straight_join "
)

const (
	ForUpdateStr = " for update"
	ShareModeStr = " lock in share mode"
)

const (
	SQLCacheStr   = "sql_cache "
	SQLNoCacheStr = "sql_no_cache "
)

const (
	UnionStr         = "union"
	UnionAllStr      = "union all"
	UnionDistinctStr = "union distinct"
)

const (
	InsertStr  = "insert"
	ReplaceStr = "replace"
)

const (
	SessionStr = "session"
	GlobalStr  = "global"
)

const (
	CreateStr        = "create"
	AlterStr         = "alter"
	DropStr          = "drop"
	RenameStr        = "rename"
	TruncateStr      = "truncate"
	CreateVindexStr  = "create vindex"
	AddColVindexStr  = "add vindex"
	DropColVindexStr = "drop vindex"

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

const (
	JoinStr             = "join"
	StraightJoinStr     = "straight_join"
	LeftJoinStr         = "left join"
	RightJoinStr        = "right join"
	NaturalJoinStr      = "natural join"
	NaturalLeftJoinStr  = "natural left join"
	NaturalRightJoinStr = "natural right join"
)

const (
	UseStr    = "use "
	IgnoreStr = "ignore "
	ForceStr  = "force "
)

const (
	WhereStr  = "where"
	HavingStr = "having"
)

const (
	EqualStr             = "="
	LessThanStr          = "<"
	GreaterThanStr       = ">"
	LessEqualStr         = "<="
	GreaterEqualStr      = ">="
	NotEqualStr          = "!="
	NullSafeEqualStr     = "<=>"
	InStr                = "in"
	NotInStr             = "not in"
	LikeStr              = "like"
	NotLikeStr           = "not like"
	RegexpStr            = "regexp"
	NotRegexpStr         = "not regexp"
	JSONExtractOp        = "->"
	JSONUnquoteExtractOp = "->>"
)

const (
	BetweenStr    = "between"
	NotBetweenStr = "not between"
)

const (
	IsNullStr     = "is null"
	IsNotNullStr  = "is not null"
	IsTrueStr     = "is true"
	IsNotTrueStr  = "is not true"
	IsFalseStr    = "is false"
	IsNotFalseStr = "is not false"
)

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

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

const (
	UPlusStr   = "+"
	UMinusStr  = "-"
	TildaStr   = "~"
	BangStr    = "!"
	BinaryStr  = "binary "
	UBinaryStr = "_binary "
)

const (
	BooleanModeStr                           = " in boolean mode"
	NaturalLanguageModeStr                   = " in natural language mode"
	NaturalLanguageModeWithQueryExpansionStr = " in natural language mode with query expansion"
	QueryExpansionStr                        = " with query expansion"
)

const (
	AscScr  = "asc"
	DescScr = "desc"
)

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

const ADD = 57442

const AGAINST = 57572

const ALL = 57362

const ALTER = 57438

const ANALYZE = 57441

const AND = 57410

const APPROXNUM = 57529

const AS = 57364

const ASC = 57366

const AUTO_INCREMENT = 57528

const BEGIN = 57477

const BETWEEN = 57412

const BIGINT = 57488

const BIGSERIAL = 57492

const BINARY = 57432

const BIT = 57482

const BIT_LITERAL = 57405

const BLOB = 57513

const BOOL = 57493

const BOOLEAN = 57494

const BY = 57358

const CASE = 57413

const CAST = 57566

const CHAR = 57504

const CHARACTER = 57506

const CHARSET = 57543

const COLLATE = 57431

const COLUMN = 57452

const COMMENT = 57403

const COMMENT_KEYWORD = 57404

const COMMIT = 57480

const COMMITTED = 57552

const CONSTRAINT = 57453

const CONVERT = 57565

const CREATE = 57437

const CROSS = 57389

const CURRENT_DATE = 57557

const CURRENT_TIME = 57558

const CURRENT_TIMESTAMP = 57555

const (
	CharacterSetStr = " character set"
)

const DATABASE = 57556

const DATABASES = 57533

const DATE = 57461

const DATETIME = 57502

const DECIMAL = 57498

const DEFAULT = 57371

const DELETE = 57352

const DESC = 57367

const DESCRIBE = 57459

const DISTINCT = 57363

const DIV = 57428

const DOUBLE = 57496

const DROP = 57439

const DUPLICATE = 57369

const ELSE = 57416

const END = 57417

const ENUM = 57518

const ESCAPE = 57462

const EXISTS = 57365

const EXPANSION = 57576

const EXPLAIN = 57460

const EXTENDED = 57539

const FALSE = 57408

const FLOAT = 57399

const FLOAT_TYPE = 57497

const FOR = 57361

const FORCE = 57392

const FOREIGN = 57456

const FROM = 57353

const FULL = 57540

const FULLTEXT = 57455

const GE = 57419

const GEOMETRY = 57519

const GEOMETRYCOLLECTION = 57523

const GLOBAL = 57544

const GROUP = 57355

const GROUP_CONCAT = 57569

const HAVING = 57356

const HEX = 57396

const HEXNUM = 57400

const ID = 57395

const IF = 57449

const IGNORE = 57448

const IN = 57425

const INDEX = 57445

const INNER = 57387

const INSERT = 57350

const INT = 57486

const INTEGER = 57487

const INTEGRAL = 57398

const INTERVAL = 57434

const INTNUM = 57489

const INTO = 57368

const IS = 57422

const ISOLATION = 57546

const JOIN = 57383

const JSON = 57517

const JSON_EXTRACT_OP = 57435

const JSON_UNQUOTE_EXTRACT_OP = 57436

const KEY = 57370

const KEYS = 57374

const KEY_BLOCK_SIZE = 57457

const LANGUAGE = 57573

const LAST_INSERT_ID = 57376

const LE = 57418

const LEFT = 57385

const LESS = 57469

const LEVEL = 57547

const LEX_ERROR = 57346

const LIKE = 57423

const LIMIT = 57359

const LINESTRING = 57521

const LIST_ARG = 57402

const LOCALTIME = 57559

const LOCALTIMESTAMP = 57560

const LOCK = 57373

const LONGBLOB = 57516

const LONGTEXT = 57512

const MATCH = 57571

const MAXVALUE = 57466

const MEDIUMBLOB = 57515

const MEDIUMINT = 57485

const MEDIUMTEXT = 57511

const MOD = 57429

const MODE = 57380

const MULTILINESTRING = 57525

const MULTIPOINT = 57524

const MULTIPOLYGON = 57526

const NAMES = 57542

const NATURAL = 57390

const NCHAR = 57508

const NE = 57420

const NEXT = 57377

const NOT = 57411

const NULL = 57406

const NULLX = 57527

const NULL_SAFE_EQUAL = 57421

const NUMERIC = 57499

const OFFSET = 57360

const ON = 57393

const ONLY = 57550

const OPTIMIZE = 57464

const OR = 57409

const ORDER = 57357

const OUTER = 57388

const PARTITION = 57467

const POINT = 57520

const POLYGON = 57522

const PRIMARY = 57451

const PROCEDURE = 57471

const PROCESSLIST = 57541

const QUERY = 57575

const READ = 57548

const REAL = 57495

const REGEXP = 57424

const RENAME = 57440

const REORGANIZE = 57468

const REPAIR = 57463

const REPEATABLE = 57551

const REPLACE = 57564

const RIGHT = 57386

const ROLLBACK = 57481

const (
	ReorganizeStr = "reorganize partition"
)

const SCHEMA = 57443

const SELECT = 57348

const SEPARATOR = 57570

const SERIAL = 57491

const SERIALIZABLE = 57554

const SESSION = 57545

const SET = 57372

const SHARE = 57379

const SHIFT_LEFT = 57426

const SHIFT_RIGHT = 57427

const SHOW = 57458

const SIGNED = 57530

const SMALLINT = 57484

const SMALLSERIAL = 57490

const SPATIAL = 57454

const SQL_CACHE = 57382

const SQL_NO_CACHE = 57381

const START = 57478

const STATUS = 57475

const STRAIGHT_JOIN = 57384

const STREAM = 57349

const STRING = 57397

const SUBSTR = 57567

const SUBSTRING = 57568

const TABLE = 57444

const TABLES = 57534

const TEXT = 57509

const THAN = 57470

const THEN = 57415

const TIME = 57500

const TIMESTAMP = 57501

const TINYBLOB = 57514

const TINYINT = 57483

const TINYTEXT = 57510

const TO = 57447

const TRANSACTION = 57479

const TRIGGER = 57472

const TRUE = 57407

const TRUNCATE = 57465

const UNARY = 57430

const UNCOMMITTED = 57553

const UNDERSCORE_BINARY = 57433

const UNION = 57347

const UNIQUE = 57450

const UNSIGNED = 57531

const UNUSED = 57577

const UPDATE = 57351

const USE = 57391

const USING = 57394

const UTC_DATE = 57561

const UTC_TIME = 57562

const UTC_TIMESTAMP = 57563

const VALUE = 57378

const VALUES = 57375

const VALUE_ARG = 57401

const VARBINARY = 57507

const VARCHAR = 57505

const VARIABLES = 57476

const VIEW = 57446

const VINDEX = 57473

const VINDEXES = 57474

const VITESS_KEYSPACES = 57535

const VITESS_SHARDS = 57536

const VITESS_TABLETS = 57537

const VSCHEMA_TABLES = 57538

const WHEN = 57414

const WHERE = 57354

const WITH = 57574

const WRITE = 57549

const YEAR = 57503

const ZEROFILL = 57532

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

func Append ¶

func Append(buf *bytes.Buffer, 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 EncodeValue ¶

func EncodeValue(buf *bytes.Buffer, 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 ExtractSetValues ¶

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 ¶

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

func KeywordString(id int) string

KeywordString returns the string corresponding to the given keyword

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. Within Select constructs, bind vars are deduped. This allows us to identify vindex equality. Otherwise, every value is treated as distinct.

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

func RedactSQLQuery(sql string) (string, error)

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

func SkipQueryPlanCacheDirective ¶

func SkipQueryPlanCacheDirective(stmt Statement) bool

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

func SplitStatement ¶

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 ¶

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

func StmtType(stmtType int) string

StmtType returns the statement type as a 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 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.

type AliasedExpr ¶

type AliasedExpr struct {
	Expr Expr
	As   ColIdent
}

AliasedExpr defines an aliased SELECT expression.

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

type AliasedTableExpr ¶

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 (node *AliasedTableExpr) Format(buf *TrackedBuffer)

func (node *AliasedTableExpr) RemoveHints() *AliasedTableExpr

type AndExpr ¶

type AndExpr struct {
	Left, Right Expr
}

AndExpr represents an AND expression.

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

type Begin ¶

type Begin struct{}

Begin represents a Begin statement.

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

type BinaryExpr ¶

type BinaryExpr struct {
	Operator    string
	Left, Right Expr
}

BinaryExpr represents a binary value expression.

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

type BoolVal ¶

type BoolVal bool

BoolVal is true or false.

func (node BoolVal) Format(buf *TrackedBuffer)

type CaseExpr ¶

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

CaseExpr represents a CASE expression.

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

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(str string) ColIdent

func (node ColIdent) CompliantName() string

func (node ColIdent) Equal(in ColIdent) bool

func (node ColIdent) EqualString(str string) bool

func (node ColIdent) Format(buf *TrackedBuffer)

func (node ColIdent) IsEmpty() bool

func (node ColIdent) Lowered() string

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

func (node ColIdent) String() string

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

type ColName ¶

type 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 (node *ColName) Equal(c *ColName) bool

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

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 (node *CollateExpr) Format(buf *TrackedBuffer)

type ColumnDefinition ¶

type ColumnDefinition struct {
	Name ColIdent
	Type ColumnType
}

ColumnDefinition describes a column in a CREATE TABLE statement

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

type ColumnKeyOption ¶

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 ¶

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

	// Generic field options.
	NotNull       BoolVal
	Autoincrement BoolVal
	Default       *SQLVal
	OnUpdate      *SQLVal
	Comment       *SQLVal

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

	// Text field options
	Charset string
	Collate string

	// Enum values
	EnumValues []string

	// Key specification
	KeyOpt ColumnKeyOption
}

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

func (ct *ColumnType) DescribeType() string

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

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

type Columns ¶

type Columns []ColIdent

Columns represents an insert column list.

func (node Columns) FindColumn(col ColIdent) int

func (node Columns) Format(buf *TrackedBuffer)

type CommentDirectives ¶

type CommentDirectives map[string]interface{}

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

func ExtractCommentDirectives(comments Comments) CommentDirectives

/*vt+ OPTION_ONE=1 OPTION_TWO OPTION_THREE=abcd */

func (d CommentDirectives) IsSet(key string) bool

type Comments ¶

type Comments [][]byte

Comments represents a list of comments.

func (node Comments) Format(buf *TrackedBuffer)

type Commit ¶

type Commit struct{}

Commit represents a Commit statement.

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

type ComparisonExpr ¶

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

ComparisonExpr represents a two-value comparison expression.

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

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 (node *ConvertExpr) Format(buf *TrackedBuffer)

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 (node *ConvertType) Format(buf *TrackedBuffer)

type ConvertUsingExpr ¶

type ConvertUsingExpr struct {
	Expr Expr
	Type string
}

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

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

type DBDDL ¶

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

DBDDL represents a CREATE, DROP database statement.

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

type DDL ¶

type DDL struct {
	Action        string
	Table         TableName
	NewName       TableName
	IfExists      bool
	TableSpec     *TableSpec
	PartitionSpec *PartitionSpec
	VindexSpec    *VindexSpec
	VindexCols    []ColIdent
}

DDL represents a CREATE, ALTER, DROP, RENAME or TRUNCATE statement. Table is set for AlterStr, DropStr, RenameStr, TruncateStr NewName is set for AlterStr, CreateStr, RenameStr. VindexSpec is set for CreateVindexStr, DropVindexStr, AddColVindexStr, DropColVindexStr VindexCols is set for AddColVindexStr

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

type Default ¶

type Default struct {
	ColName string
}

Default represents a DEFAULT expression.

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

type Delete ¶

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

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

type Encodable ¶

type Encodable interface {
	EncodeSQL(buf *bytes.Buffer)
}

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 (node *ExistsExpr) Format(buf *TrackedBuffer)

type Expr ¶

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

Expr represents an expression.

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

func ReplaceExpr(root, from, to Expr) Expr

type Exprs ¶

type Exprs []Expr

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

func (node Exprs) Format(buf *TrackedBuffer)

type FuncExpr ¶

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

FuncExpr represents a function call.

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

func (node *FuncExpr) IsAggregate() bool

type GroupBy ¶

type GroupBy []Expr

GroupBy represents a GROUP BY clause.

func (node GroupBy) Format(buf *TrackedBuffer)

type GroupConcatExpr ¶

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

GroupConcatExpr represents a call to GROUP_CONCAT

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

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 {
	Info    *IndexInfo
	Columns []*IndexColumn
	Options []*IndexOption
}

IndexDefinition describes an index in a CREATE TABLE statement

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

type IndexHints ¶

type IndexHints struct {
	Type    string
	Indexes []ColIdent
}

IndexHints represents a list of index hints.

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

type IndexInfo ¶

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 (ii *IndexInfo) Format(buf *TrackedBuffer)

type IndexOption ¶

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

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

type Insert ¶

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

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

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 (iv InsertValues) EncodeSQL(buf *bytes.Buffer)

type IntervalExpr ¶

type IntervalExpr struct {
	Expr Expr
	Unit string
}

IntervalExpr represents a date-time INTERVAL expression.

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

type IsExpr ¶

type IsExpr struct {
	Operator string
	Expr     Expr
}

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

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

type JoinCondition ¶

type JoinCondition struct {
	On    Expr
	Using Columns
}

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

func (node JoinCondition) Format(buf *TrackedBuffer)

type JoinTableExpr ¶

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

JoinTableExpr represents a TableExpr that's a JOIN operation.

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

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 (node *Limit) Format(buf *TrackedBuffer)

type ListArg ¶

type ListArg []byte

ListArg represents a named list argument.

func (node ListArg) Format(buf *TrackedBuffer)

type MarginComments ¶

type MarginComments struct {
	Leading  string
	Trailing string
}

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

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

type MatchExpr ¶

type MatchExpr struct {
	Columns SelectExprs
	Expr    Expr
	Option  string
}

MatchExpr represents a call to the MATCH function

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

type Nextval ¶

type Nextval struct {
	Expr Expr
}

Nextval defines the NEXT VALUE expression.

func (node Nextval) Format(buf *TrackedBuffer)

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 (node *NotExpr) Format(buf *TrackedBuffer)

type NullVal ¶

type NullVal struct{}

NullVal represents a NULL value.

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

type OnDup ¶

type OnDup UpdateExprs

OnDup represents an ON DUPLICATE KEY clause.

func (node OnDup) Format(buf *TrackedBuffer)

type OrExpr ¶

type OrExpr struct {
	Left, Right Expr
}

OrExpr represents an OR expression.

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

type Order ¶

type Order struct {
	Expr      Expr
	Direction string
}

Order represents an ordering expression.

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

type OrderBy ¶

type OrderBy []*Order

OrderBy represents an ORDER By clause.

func (node OrderBy) Format(buf *TrackedBuffer)

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 (node *OtherAdmin) Format(buf *TrackedBuffer)

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 (node *OtherRead) Format(buf *TrackedBuffer)

type ParenExpr ¶

type ParenExpr struct {
	Expr Expr
}

ParenExpr represents a parenthesized boolean expression.

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

type ParenSelect ¶

type ParenSelect struct {
	Select SelectStatement
}

ParenSelect is a parenthesized SELECT statement.

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

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

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

type ParenTableExpr ¶

type ParenTableExpr struct {
	Exprs TableExprs
}

ParenTableExpr represents a parenthesized list of TableExpr.

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

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(in string, vars ...interface{}) *ParsedQuery

func NewParsedQuery(node SQLNode) *ParsedQuery

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

type PartitionDefinition ¶

type PartitionDefinition struct {
	Name     ColIdent
	Limit    Expr
	Maxvalue bool
}

PartitionDefinition describes a very minimal partition definition

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

type PartitionSpec ¶

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

PartitionSpec describe partition actions (for alter and create)

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

type Partitions ¶

type Partitions Columns

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

func (node Partitions) Format(buf *TrackedBuffer)

type RangeCond ¶

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

RangeCond represents a BETWEEN or a NOT BETWEEN expression.

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

type Rollback ¶

type Rollback struct{}

Rollback represents a Rollback statement.

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

type SQLNode ¶

type SQLNode interface {
	Format(buf *TrackedBuffer)
	// contains filtered or unexported methods
}

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

type SQLVal ¶

type SQLVal struct {
	Type ValType
	Val  []byte
}

SQLVal represents a single value.

func NewBitVal(in []byte) *SQLVal

func NewFloatVal(in []byte) *SQLVal

func NewHexNum(in []byte) *SQLVal

func NewHexVal(in []byte) *SQLVal

func NewIntVal(in []byte) *SQLVal

func NewStrVal(in []byte) *SQLVal

func NewValArg(in []byte) *SQLVal

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

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

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
}

Select represents a SELECT statement.

func (node *Select) AddHaving(expr Expr)

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

func (node *Select) AddWhere(expr Expr)

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

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

type SelectExpr ¶

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

SelectExpr represents a SELECT expression.

type SelectExprs ¶

type SelectExprs []SelectExpr

SelectExprs represents SELECT expressions.

func (node SelectExprs) Format(buf *TrackedBuffer)

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
	Scope    string
}

Set represents a SET statement.

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

type SetExpr ¶

type SetExpr struct {
	Name ColIdent
	Expr Expr
}

SetExpr represents a set expression.

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

type SetExprs ¶

type SetExprs []*SetExpr

SetExprs represents a list of set expressions.

func (node SetExprs) Format(buf *TrackedBuffer)

type SetKey ¶

type SetKey struct {
	Key   string
	Scope string
}

SetKey is the extracted key from one SetExpr

type Show ¶

type Show struct {
	Type          string
	OnTable       TableName
	ShowTablesOpt *ShowTablesOpt
	Scope         string
}

Show represents a show statement.

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

func (node *Show) HasOnTable() bool

type ShowFilter ¶

type ShowFilter struct {
	Like   string
	Filter Expr
}

ShowFilter is show tables filter

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

type ShowTablesOpt ¶

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

ShowTablesOpt is show tables option

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 (node *StarExpr) Format(buf *TrackedBuffer)

type Statement ¶

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

Statement represents a statement.

func Parse(sql string) (Statement, error)

sql := "SELECT * FROM table WHERE a = 'abc'"
stmt, err := Parse(sql)
if err != nil {
	// Do something with the err
}

// Otherwise do something with stmt
switch stmt := stmt.(type) {
case *Select:
	_ = stmt
case *Insert:
}

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

r := strings.NewReader("INSERT INTO table1 VALUES (1, 'a'); INSERT INTO table2 VALUES (3, 4);")

tokens := NewTokenizer(r)
for {
	stmt, err := ParseNext(tokens)
	if err == io.EOF {
		break
	}
	// Do something with stmt or err.
	_ = stmt
}

func ParseStrictDDL(sql string) (Statement, error)

type Stream ¶

type Stream struct {
	Comments   Comments
	SelectExpr SelectExpr
	Table      TableName
}

Stream represents a SELECT statement.

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

type Subquery ¶

type Subquery struct {
	Select SelectStatement
}

Subquery represents a subquery.

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

type SubstrExpr ¶

type SubstrExpr struct {
	Name *ColName
	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)

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

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 (node TableExprs) Format(buf *TrackedBuffer)

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(node SimpleTableExpr) TableIdent

func NewTableIdent(str string) TableIdent

func (node TableIdent) CompliantName() string

func (node TableIdent) Format(buf *TrackedBuffer)

func (node TableIdent) IsEmpty() bool

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

func (node TableIdent) String() string

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

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 (node TableName) Format(buf *TrackedBuffer)

func (node TableName) IsEmpty() bool

func (node TableName) ToViewName() TableName

type TableNames ¶

type TableNames []TableName

TableNames is a list of TableName.

func (node TableNames) Format(buf *TrackedBuffer)

type TableSpec ¶

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

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

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

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

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

type Tokenizer ¶

type Tokenizer struct {
	InStream      io.Reader
	AllowComments bool
	ForceEOF      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(sql string) *Tokenizer

func NewTokenizer(r io.Reader) *Tokenizer

func (tkn *Tokenizer) Error(err string)

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

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

type TrackedBuffer ¶

type TrackedBuffer struct {
	*bytes.Buffer
	// 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(nodeFormatter NodeFormatter) *TrackedBuffer

func (buf *TrackedBuffer) HasBindVars() bool

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

func (buf *TrackedBuffer) ParsedQuery() *ParsedQuery

func (buf *TrackedBuffer) WriteArg(arg string)

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

type TupleEqualityList ¶

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

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

func (tpl *TupleEqualityList) EncodeSQL(buf *bytes.Buffer)

type UnaryExpr ¶

type UnaryExpr struct {
	Operator string
	Expr     Expr
}

UnaryExpr represents a unary value expression.

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

type Union ¶

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

Union represents a UNION statement.

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

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

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

type Update ¶

type Update struct {
	Comments   Comments
	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 validateSubquerySamePlan.

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

type UpdateExpr ¶

type UpdateExpr struct {
	Name *ColName
	Expr Expr
}

UpdateExpr represents an update expression.

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

type UpdateExprs ¶

type UpdateExprs []*UpdateExpr

UpdateExprs represents a list of update expressions.

func (node UpdateExprs) Format(buf *TrackedBuffer)

type Use ¶

type Use struct {
	DBName TableIdent
}

Use represents a use statement.

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

type ValTuple ¶

type ValTuple Exprs

ValTuple represents a tuple of actual values.

func (node ValTuple) Format(buf *TrackedBuffer)

type ValType ¶

type ValType int

ValType specifies the type for SQLVal.

type Values ¶

type Values []ValTuple

Values represents a VALUES clause.

func (node Values) Format(buf *TrackedBuffer)

type ValuesFuncExpr ¶

type ValuesFuncExpr struct {
	Name *ColName
}

ValuesFuncExpr represents a function call.

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

type VindexParam ¶

type VindexParam struct {
	Key ColIdent
	Val string
}

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

func (node VindexParam) Format(buf *TrackedBuffer)

type VindexSpec ¶

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

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

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

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

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 (node *When) Format(buf *TrackedBuffer)

type Where ¶

type Where struct {
	Type string
	Expr Expr
}

Where represents a WHERE or HAVING clause.

func NewWhere(typ string, expr Expr) *Where

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