sqlparser

Documentation

Index

• Constants
• Variables
• func Append(buf *strings.Builder, node SQLNode)
• func CanNormalize(stmt Statement) bool
• func Convert(e Expr) (evalengine.Expr, error)
• func EncodeValue(buf *strings.Builder, value *querypb.BindVariable)
• func ExtractMysqlComment(sql string) (string, string)
• func FetchBindVar(name string, bindVariables map[string]*querypb.BindVariable) (val *querypb.BindVariable, isList bool, err error)
• func FormatImpossibleQuery(buf *TrackedBuffer, node SQLNode)
• func Fuzz(data []byte) int
• func GetBindvars(stmt Statement) map[string]struct{}
• func IgnoreMaxMaxMemoryRowsDirective(stmt Statement) bool
• func IgnoreMaxPayloadSizeDirective(stmt Statement) bool
• func IsColName(node Expr) bool
• func IsDML(sql string) bool
• func IsDMLStatement(stmt Statement) bool
• func IsLockingFunc(node Expr) bool
• func IsNull(node Expr) bool
• func IsOnlineSchemaDDL(ddl *DDL, sql string) bool
• func IsSetStatement(stmt Statement) bool
• func IsSimpleTuple(node Expr) bool
• func IsValue(node Expr) bool
• func IsVschemaDDL(ddl *DDL) bool
• func KeywordString(id int) string
• func LikeToRegexp(likeExpr string) *regexp.Regexp
• func NewPlanValue(node Expr) (sqltypes.PlanValue, error)
• func Normalize(stmt Statement, bindVars map[string]*querypb.BindVariable, prefix string)
• func NormalizeAlphabetically(query string) (normalized string, err error)
• func ParseTokenizer(tokenizer *Tokenizer) int
• func QueryMatchesTemplates(query string, queryTemplates []string) (match bool, err error)
• func RedactSQLQuery(sql string) (string, error)
• func SkipQueryPlanCacheDirective(stmt Statement) bool
• func SplitStatement(blob string) (string, string, error)
• func SplitStatementToPieces(blob string) (pieces []string, err error)
• func String(node SQLNode) string
• func StripLeadingComments(sql string) string
• func TruncateForLog(query string) string
• func TruncateForUI(query string) string
• func Walk(visit Visit, nodes ...SQLNode) error
• type AccessMode
  • func (node AccessMode) Format(buf *TrackedBuffer)
• type AliasedExpr
  • func (node *AliasedExpr) Format(buf *TrackedBuffer)
• type AliasedTableExpr
  • func (node *AliasedTableExpr) Format(buf *TrackedBuffer)
  • func (node *AliasedTableExpr) RemoveHints() *AliasedTableExpr
• type AndExpr
  • func (node *AndExpr) Format(buf *TrackedBuffer)
• type ApplyFunc
• type Argument
  • func NewArgument(in []byte) Argument
  • func (node Argument) Format(buf *TrackedBuffer)
• type AtCount
• type AutoIncSpec
  • func (node *AutoIncSpec) Format(buf *TrackedBuffer)
• type Begin
  • func (node *Begin) Format(buf *TrackedBuffer)
• type BinaryExpr
  • func (node *BinaryExpr) Format(buf *TrackedBuffer)
• type BinaryExprOperator
  • func (op BinaryExprOperator) ToString() string
• type BindVarNeeds
  • func (bvn *BindVarNeeds) AddFuncResult(name string)
  • func (bvn *BindVarNeeds) AddSysVar(name string)
  • func (bvn *BindVarNeeds) AddUserDefVar(name string)
  • func (bvn *BindVarNeeds) HasRewrites() bool
  • func (bvn *BindVarNeeds) MergeWith(other *BindVarNeeds)
  • func (bvn *BindVarNeeds) NeedsFuncResult(name string) bool
  • func (bvn *BindVarNeeds) NeedsSysVar(name string) bool
• type BoolVal
  • func (node BoolVal) Format(buf *TrackedBuffer)
• type CaseExpr
  • func (node *CaseExpr) Format(buf *TrackedBuffer)
• type Characteristic
• type ColIdent
  • func NewColIdent(str string) ColIdent
  • func NewColIdentWithAt(str string, at AtCount) ColIdent
  • func (node ColIdent) AtCount() AtCount
  • 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
  • func NewColName(str string) *ColName
  • func (node *ColName) Equal(c *ColName) bool
  • func (node *ColName) Format(buf *TrackedBuffer)
• type ColTuple
• type CollateExpr
  • func (node *CollateExpr) Format(buf *TrackedBuffer)
• type ColumnDefinition
  • func (col *ColumnDefinition) Format(buf *TrackedBuffer)
• type ColumnKeyOption
• type ColumnType
  • func (ct *ColumnType) DescribeType() string
  • func (ct *ColumnType) Format(buf *TrackedBuffer)
  • func (ct *ColumnType) SQLType() querypb.Type
• type Columns
  • func (node Columns) FindColumn(col ColIdent) int
  • func (node Columns) Format(buf *TrackedBuffer)
• type CommentDirectives
  • func ExtractCommentDirectives(comments Comments) CommentDirectives
  • func (d CommentDirectives) IsSet(key string) bool
• type Comments
  • func (node Comments) Format(buf *TrackedBuffer)
• type Commit
  • func (node *Commit) Format(buf *TrackedBuffer)
• type ComparisonExpr
  • func (node *ComparisonExpr) Format(buf *TrackedBuffer)
  • func (node *ComparisonExpr) IsImpossible() bool
• type ComparisonExprOperator
  • func (op ComparisonExprOperator) ToString() string
• type ConstraintDefinition
  • func (c *ConstraintDefinition) Format(buf *TrackedBuffer)
• type ConstraintInfo
• type ConvertExpr
  • func (node *ConvertExpr) Format(buf *TrackedBuffer)
• type ConvertType
  • func (node *ConvertType) Format(buf *TrackedBuffer)
• type ConvertTypeOperator
  • func (op ConvertTypeOperator) ToString() string
• type ConvertUsingExpr
  • func (node *ConvertUsingExpr) Format(buf *TrackedBuffer)
• type CurTimeFuncExpr
  • func (node *CurTimeFuncExpr) Format(buf *TrackedBuffer)
• type Cursor
  • func (c *Cursor) Node() SQLNode
  • func (c *Cursor) Parent() SQLNode
  • func (c *Cursor) Replace(newNode SQLNode)
• type DBDDL
  • func (node *DBDDL) Format(buf *TrackedBuffer)
• type DBDDLAction
• type DDL
  • func (node *DDL) AffectedTables() TableNames
  • func (node *DDL) Format(buf *TrackedBuffer)
• type DDLAction
  • func (action DDLAction) ToString() string
• type DDLStrategy
• type Default
  • func (node *Default) Format(buf *TrackedBuffer)
• type Delete
  • func (node *Delete) Format(buf *TrackedBuffer)
• type Encodable
• type ExistsExpr
  • func (node *ExistsExpr) Format(buf *TrackedBuffer)
• type Explain
  • func (node *Explain) Format(buf *TrackedBuffer)
• type ExplainType
  • func (ty ExplainType) ToString() string
• type Expr
  • func ReplaceExpr(root, from, to Expr) Expr
  • func SplitAndExpression(filters []Expr, node Expr) []Expr
• type Exprs
  • func (node Exprs) Format(buf *TrackedBuffer)
• type ForeignKeyDefinition
  • func (f *ForeignKeyDefinition) Format(buf *TrackedBuffer)
• type FuncExpr
  • func (node *FuncExpr) Format(buf *TrackedBuffer)
  • func (node *FuncExpr) IsAggregate() bool
• type GroupBy
  • func (node GroupBy) Format(buf *TrackedBuffer)
• type GroupConcatExpr
  • func (node *GroupConcatExpr) Format(buf *TrackedBuffer)
• type Ignore
  • func (ignore Ignore) ToString() string
• type IndexColumn
• type IndexDefinition
  • func (idx *IndexDefinition) Format(buf *TrackedBuffer)
• type IndexHints
  • func (node *IndexHints) Format(buf *TrackedBuffer)
• type IndexHintsType
  • func (ty IndexHintsType) ToString() string
• type IndexInfo
  • func (ii *IndexInfo) Format(buf *TrackedBuffer)
• type IndexOption
• type Insert
  • func (node *Insert) Format(buf *TrackedBuffer)
• type InsertAction
• type InsertRows
• type InsertValues
  • func (iv InsertValues) EncodeSQL(buf *strings.Builder)
• type IntervalExpr
  • func (node *IntervalExpr) Format(buf *TrackedBuffer)
• type IsExpr
  • func (node *IsExpr) Format(buf *TrackedBuffer)
• type IsExprOperator
  • func (op IsExprOperator) ToString() string
• type IsolationLevel
  • func (node IsolationLevel) Format(buf *TrackedBuffer)
• type JoinCondition
  • func (node JoinCondition) Format(buf *TrackedBuffer)
• type JoinTableExpr
  • func (node *JoinTableExpr) Format(buf *TrackedBuffer)
• type JoinType
  • func (joinType JoinType) ToString() string
• type LengthScaleOption
• type Limit
  • func (node *Limit) Format(buf *TrackedBuffer)
• type ListArg
  • func (node ListArg) Format(buf *TrackedBuffer)
• type Literal
  • func NewBitLiteral(in []byte) *Literal
  • func NewFloatLiteral(in []byte) *Literal
  • func NewHexLiteral(in []byte) *Literal
  • func NewHexNumLiteral(in []byte) *Literal
  • func NewIntLiteral(in []byte) *Literal
  • func NewStrLiteral(in []byte) *Literal
  • func (node *Literal) Format(buf *TrackedBuffer)
  • func (node *Literal) HexDecode() ([]byte, error)
• type Lock
  • func (lock Lock) ToString() string
• type MarginComments
  • func SplitMarginComments(sql string) (query string, comments MarginComments)
• type MatchExpr
  • func (node *MatchExpr) Format(buf *TrackedBuffer)
• type MatchExprOption
  • func (option MatchExprOption) ToString() string
• type Nextval
  • func (node Nextval) Format(buf *TrackedBuffer)
• type NodeFormatter
• type NotExpr
  • func (node *NotExpr) Format(buf *TrackedBuffer)
• type NullVal
  • func (node *NullVal) Format(buf *TrackedBuffer)
• type OnDup
  • func (node OnDup) Format(buf *TrackedBuffer)
• type OnlineDDLHint
• type OptLike
  • func (node *OptLike) Format(buf *TrackedBuffer)
• type OrExpr
  • func (node *OrExpr) Format(buf *TrackedBuffer)
• type Order
  • func (node *Order) Format(buf *TrackedBuffer)
• type OrderBy
  • func (node OrderBy) Format(buf *TrackedBuffer)
• type OrderDirection
  • func (dir OrderDirection) ToString() string
• type OtherAdmin
  • func (node *OtherAdmin) Format(buf *TrackedBuffer)
• type OtherRead
  • func (node *OtherRead) Format(buf *TrackedBuffer)
• type ParenSelect
  • func (node *ParenSelect) AddOrder(order *Order)
  • func (node *ParenSelect) Format(buf *TrackedBuffer)
  • func (node *ParenSelect) SetLimit(limit *Limit)
  • func (node *ParenSelect) SetLock(lock Lock)
• type ParenTableExpr
  • func (node *ParenTableExpr) Format(buf *TrackedBuffer)
• type ParsedQuery
  • func BuildParsedQuery(in string, vars ...interface{}) *ParsedQuery
  • func NewParsedQuery(node SQLNode) *ParsedQuery
  • func (pq *ParsedQuery) Append(buf *strings.Builder, bindVariables map[string]*querypb.BindVariable, ...) error
  • func (pq *ParsedQuery) GenerateQuery(bindVariables map[string]*querypb.BindVariable, extras map[string]Encodable) (string, error)
  • func (pq *ParsedQuery) MarshalJSON() ([]byte, error)
• type PartitionDefinition
  • func (node *PartitionDefinition) Format(buf *TrackedBuffer)
• type PartitionSpec
  • func (node *PartitionSpec) Format(buf *TrackedBuffer)
• type PartitionSpecAction
• type Partitions
  • func (node Partitions) Format(buf *TrackedBuffer)
• type PositionedErr
  • func (p PositionedErr) Error() string
• type Precendence
• type RangeCond
  • func (node *RangeCond) Format(buf *TrackedBuffer)
• type RangeCondOperator
  • func (op RangeCondOperator) ToString() string
• type ReferenceAction
  • func (a ReferenceAction) Format(buf *TrackedBuffer)
• type Release
  • func (node *Release) Format(buf *TrackedBuffer)
• type RewriteASTResult
  • func PrepareAST(in Statement, bindVars map[string]*querypb.BindVariable, prefix string, ...) (*RewriteASTResult, error)
  • func RewriteAST(in Statement) (*RewriteASTResult, error)
• type Rollback
  • func (node *Rollback) Format(buf *TrackedBuffer)
• type SQLNode
  • func Rewrite(node SQLNode, pre, post ApplyFunc) (result SQLNode)
• type SRollback
  • func (node *SRollback) Format(buf *TrackedBuffer)
• type Savepoint
  • func (node *Savepoint) Format(buf *TrackedBuffer)
• type Scope
  • func (scope Scope) ToString() string
• type Select
  • func NewSelect(comments Comments, exprs SelectExprs, selectOptions []string, from TableExprs, ...) *Select
  • 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)
  • func (node *Select) SetLock(lock Lock)
• type SelectExpr
• type SelectExprs
  • func (node SelectExprs) Format(buf *TrackedBuffer)
• type SelectStatement
• type Set
  • func (node *Set) Format(buf *TrackedBuffer)
• type SetExpr
  • func (node *SetExpr) Format(buf *TrackedBuffer)
• type SetExprs
  • func (node SetExprs) Format(buf *TrackedBuffer)
• type SetTransaction
  • func (node *SetTransaction) Format(buf *TrackedBuffer)
• type Show
  • func (node *Show) Format(buf *TrackedBuffer)
  • func (node *Show) HasOnTable() bool
  • func (node *Show) HasTable() bool
• type ShowFilter
  • func (node *ShowFilter) Format(buf *TrackedBuffer)
• type ShowTableStatus
  • func (node *ShowTableStatus) Format(buf *TrackedBuffer)
• type ShowTablesOpt
• type SimpleTableExpr
• type StarExpr
  • func (node *StarExpr) Format(buf *TrackedBuffer)
• type Statement
  • func Parse(sql string) (Statement, error)
  • func ParseNext(tokenizer *Tokenizer) (Statement, error)
  • func ParseNextStrictDDL(tokenizer *Tokenizer) (Statement, error)
  • func ParseStrictDDL(sql string) (Statement, error)
• type StatementType
  • func ASTToStatementType(stmt Statement) StatementType
  • func Preview(sql string) StatementType
  • func (s StatementType) String() string
• type Stream
  • func (node *Stream) Format(buf *TrackedBuffer)
• type Subquery
  • func (node *Subquery) Format(buf *TrackedBuffer)
• type SubstrExpr
  • func (node *SubstrExpr) Format(buf *TrackedBuffer)
• type TableExpr
• type TableExprs
  • func (node TableExprs) Format(buf *TrackedBuffer)
• type TableIdent
  • 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
  • func TableFromStatement(sql string) (TableName, error)
  • func (node TableName) Format(buf *TrackedBuffer)
  • func (node TableName) IsEmpty() bool
  • func (node TableName) ToViewName() TableName
• type TableNames
  • func (node TableNames) Format(buf *TrackedBuffer)
• type TableSpec
  • func (ts *TableSpec) AddColumn(cd *ColumnDefinition)
  • func (ts *TableSpec) AddConstraint(cd *ConstraintDefinition)
  • func (ts *TableSpec) AddIndex(id *IndexDefinition)
  • func (ts *TableSpec) Format(buf *TrackedBuffer)
• type TimestampFuncExpr
  • func (node *TimestampFuncExpr) Format(buf *TrackedBuffer)
• type Tokenizer
  • 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
  • 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
  • func (tpl *TupleEqualityList) EncodeSQL(buf *strings.Builder)
• type UnaryExpr
  • func (node *UnaryExpr) Format(buf *TrackedBuffer)
• type UnaryExprOperator
  • func (op UnaryExprOperator) ToString() string
• type Union
  • func Unionize(lhs, rhs SelectStatement, typ UnionType, by OrderBy, limit *Limit, lock Lock) *Union
  • func (node *Union) AddOrder(order *Order)
  • func (node *Union) Format(buf *TrackedBuffer)
  • func (node *Union) SetLimit(limit *Limit)
  • func (node *Union) SetLock(lock Lock)
• type UnionSelect
  • func (node *UnionSelect) Format(buf *TrackedBuffer)
• type UnionType
• type Update
  • func (node *Update) Format(buf *TrackedBuffer)
• type UpdateExpr
  • func (node *UpdateExpr) Format(buf *TrackedBuffer)
• type UpdateExprs
  • func (node UpdateExprs) Format(buf *TrackedBuffer)
• type Use
  • func (node *Use) Format(buf *TrackedBuffer)
• type VStream
  • func (node *VStream) Format(buf *TrackedBuffer)
• type ValTuple
  • func (node ValTuple) Format(buf *TrackedBuffer)
• type ValType
• type Values
  • func (node Values) Format(buf *TrackedBuffer)
• type ValuesFuncExpr
  • func (node *ValuesFuncExpr) Format(buf *TrackedBuffer)
• type VindexParam
  • func (node VindexParam) Format(buf *TrackedBuffer)
• type VindexSpec
  • func (node *VindexSpec) Format(buf *TrackedBuffer)
  • func (node *VindexSpec) ParseParams() (string, map[string]string)
• type Visit
• type When
  • func (node *When) Format(buf *TrackedBuffer)
• type Where
  • func NewWhere(typ WhereType, expr Expr) *Where
  • func (node *Where) Format(buf *TrackedBuffer)
• type WhereType
  • func (whereType WhereType) ToString() string
• type XorExpr
  • func (node *XorExpr) Format(buf *TrackedBuffer)

Constants

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

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

const (
	// DirectiveMultiShardAutocommit is the query comment directive to allow
	// single round trip autocommit with a multi-shard statement.
	DirectiveMultiShardAutocommit = "MULTI_SHARD_AUTOCOMMIT"
	// DirectiveSkipQueryPlanCache skips query plan cache when set.
	DirectiveSkipQueryPlanCache = "SKIP_QUERY_PLAN_CACHE"
	// DirectiveQueryTimeout sets a query timeout in vtgate. Only supported for SELECTS.
	DirectiveQueryTimeout = "QUERY_TIMEOUT_MS"
	// DirectiveScatterErrorsAsWarnings enables partial success scatter select queries
	DirectiveScatterErrorsAsWarnings = "SCATTER_ERRORS_AS_WARNINGS"
	// DirectiveIgnoreMaxPayloadSize skips payload size validation when set.
	DirectiveIgnoreMaxPayloadSize = "IGNORE_MAX_PAYLOAD_SIZE"
	// DirectiveIgnoreMaxMemoryRows skips memory row validation when set.
	DirectiveIgnoreMaxMemoryRows = "IGNORE_MAX_MEMORY_ROWS"
)

const (
	// Select.Distinct
	DistinctStr         = "distinct "
	StraightJoinHint    = "straight_join "
	SQLCalcFoundRowsStr = "sql_calc_found_rows "

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

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

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

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

	// Set.Scope or Show.Scope
	SessionStr        = "session"
	GlobalStr         = "global"
	VitessMetadataStr = "vitess_metadata"
	VariableStr       = "variable"
	LocalStr          = "local"
	ImplicitStr       = ""

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

	// Online DDL hint
	OnlineStr = "online"

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

	// Partition strings
	ReorganizeStr = "reorganize partition"

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

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

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

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

	// 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           = ">>"
	JSONExtractOpStr        = "->"
	JSONUnquoteExtractOpStr = "->>"

	// UnaryExpr.Operator
	UPlusStr   = "+"
	UMinusStr  = "-"
	TildaStr   = "~"
	BangStr    = "!"
	BinaryStr  = "binary "
	UBinaryStr = "_binary "
	Utf8mb4Str = "_utf8mb4 "
	Utf8Str    = "_utf8 "
	Latin1Str  = "_latin1 "

	// ConvertType.Operator
	CharacterSetStr = " character set"
	NoOperatorStr   = ""
	CharsetStr      = "charset"

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

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

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

	// Transaction isolation levels
	ReadUncommittedStr = "read uncommitted"
	ReadCommittedStr   = "read committed"
	RepeatableReadStr  = "repeatable read"
	SerializableStr    = "serializable"

	TxReadOnly  = "read only"
	TxReadWrite = "read write"

	// Explain formats
	EmptyStr       = ""
	TreeStr        = "tree"
	JSONStr        = "json"
	VitessStr      = "vitess"
	TraditionalStr = "traditional"
	AnalyzeStr     = "analyze"
)

const (
	//LastInsertIDName is a reserved bind var name for last_insert_id()
	LastInsertIDName = "__lastInsertId"

	//DBVarName is a reserved bind var name for database()
	DBVarName = "__vtdbname"

	//FoundRowsName is a reserved bind var name for found_rows()
	FoundRowsName = "__vtfrows"

	//RowCountName is a reserved bind var name for row_count()
	RowCountName = "__vtrcount"

	//UserDefinedVariableName is what we prepend bind var names for user defined variables
	UserDefinedVariableName = "__vtudv"
)

const ACTION = 57473

const ACTIVE = 57636

const ADD = 57456

const ADMIN = 57637

const AGAINST = 57604

const ALL = 57363

const ALTER = 57452

const ANALYZE = 57455

const AND = 57421

const APPROXNUM = 57552

const ARRAY = 57611

const AS = 57365

const ASC = 57367

const AT_AT_ID = 57404

const AT_ID = 57403

const AUTO_INCREMENT = 57551

const BEGIN = 57501

const BETWEEN = 57423

const BIGINT = 57515

const BINARY = 57443

const BIT = 57509

const BIT_LITERAL = 57414

const BLOB = 57536

const BOOL = 57528

const BOOLEAN = 57605

const BUCKETS = 57638

const BY = 57359

const CASCADE = 57474

const CASE = 57424

const CAST = 57596

const CHAR = 57526

const CHARACTER = 57529

const CHARSET = 57573

const CHECK = 57471

const CLONE = 57639

const COLLATE = 57442

const COLLATION = 57556

const COLUMN = 57467

const COLUMNS = 57563

const COMMENT = 57412

const COMMENT_KEYWORD = 57413

const COMMIT = 57504

const COMMITTED = 57582

const COMPONENT = 57640

const CONSTRAINT = 57475

const CONVERT = 57595

const CREATE = 57451

const CROSS = 57396

const CUME_DIST = 57612

const CURRENT_DATE = 57587

const CURRENT_TIME = 57588

const CURRENT_TIMESTAMP = 57585

const DATABASE = 57586

const DATABASES = 57557

const DATE = 57483

const DATETIME = 57524

const DECIMAL = 57520

const DEFAULT = 57372

const DEFINITION = 57641

const DELETE = 57353

const DENSE_RANK = 57614

const DESC = 57368

const DESCRIBE = 57481

const DESCRIPTION = 57613

const DISTINCT = 57364

const DISTINCTROW = 57378

const DIV = 57439

const DO = 57377

const DOUBLE = 57518

const DROP = 57453

const DUPLICATE = 57370

const ELSE = 57427

const EMPTY = 57615

const END = 57428

const ENFORCED = 57642

const ENGINES = 57565

const ENUM = 57541

const ESCAPE = 57484

const EXCEPT = 57616

const EXCLUDE = 57643

const EXISTS = 57366

const EXPANSION = 57609

const EXPLAIN = 57482

const EXTENDED = 57567

const FALSE = 57417

const FIELDS = 57564

const FIRST_VALUE = 57617

const FLOAT = 57408

const FLOAT_TYPE = 57519

const FLUSH = 57457

const FOLLOWING = 57644

const FOR = 57362

const FORCE = 57399

const FOREIGN = 57476

const FORMAT = 57692

const FROM = 57354

const FULL = 57561

const FULLTEXT = 57469

const GE = 57430

const GEOMCOLLECTION = 57645

const GEOMETRY = 57542

const GEOMETRYCOLLECTION = 57546

const GET_MASTER_PUBLIC_KEY = 57646

const GLOBAL = 57574

const GROUP = 57356

const GROUPING = 57618

const GROUPS = 57619

const GROUP_CONCAT = 57599

const HAVING = 57357

const HEX = 57405

const HEXNUM = 57409

const HISTOGRAM = 57647

const HISTORY = 57648

const ID = 57402

const IF = 57464

const IGNORE = 57463

const IN = 57436

const INACTIVE = 57649

const INDEX = 57460

const INDEXES = 57472

const INNER = 57394

const INSERT = 57351

const INT = 57513

const INTEGER = 57514

const INTEGRAL = 57407

const INTERVAL = 57448

const INTNUM = 57516

const INTO = 57369

const INVISIBLE = 57650

const IS = 57433

const ISOLATION = 57576

const JOIN = 57390

const JSON = 57540

const JSON_EXTRACT_OP = 57449

const JSON_TABLE = 57620

const JSON_UNQUOTE_EXTRACT_OP = 57450

const KEY = 57371

const KEYS = 57376

const KEYSPACES = 57568

const KEY_BLOCK_SIZE = 57470

const LAG = 57621

const LANGUAGE = 57606

const LAST_INSERT_ID = 57382

const LAST_VALUE = 57622

const LATERAL = 57623

const LE = 57429

const LEAD = 57624

const LEFT = 57392

const LESS = 57491

const LEVEL = 57577

const LEX_ERROR = 57346

const LIKE = 57434

const LIMIT = 57360

const LINESTRING = 57544

const LIST_ARG = 57411

const LOCALTIME = 57589

const LOCALTIMESTAMP = 57590

const LOCK = 57374

const LOCKED = 57651

const LONGBLOB = 57539

const LONGTEXT = 57535

const MASTER_COMPRESSION_ALGORITHMS = 57652

const MASTER_PUBLIC_KEY_PATH = 57653

const MASTER_TLS_CIPHERSUITES = 57654

const MASTER_ZSTD_COMPRESSION_LEVEL = 57655

const MATCH = 57603

const MAXVALUE = 57488

const MEDIUMBLOB = 57538

const MEDIUMINT = 57512

const MEDIUMTEXT = 57534

const MEMBER = 57625

const MOD = 57440

const MODE = 57386

const MULTILINESTRING = 57548

const MULTIPOINT = 57547

const MULTIPOLYGON = 57549

const NAMES = 57572

const NATURAL = 57397

const NCHAR = 57531

const NE = 57431

const NESTED = 57656

const NETWORK_NAMESPACE = 57657

const NEXT = 57383

const NO = 57477

const NOT = 57422

const NOWAIT = 57658

const NTH_VALUE = 57626

const NTILE = 57627

const NULL = 57415

const NULLS = 57659

const NULLX = 57550

const NULL_SAFE_EQUAL = 57432

const NUMERIC = 57521

const OF = 57628

const OFF = 57418

const OFFSET = 57361

const OJ = 57660

const OLD = 57661

const ON = 57400

const ONLY = 57580

const OPTIMIZE = 57486

const OPTIONAL = 57662

const OR = 57419

const ORDER = 57358

const ORDINALITY = 57663

const ORGANIZATION = 57664

const OTHERS = 57665

const OUTER = 57395

const OUTFILE = 57379

const OVER = 57629

const PARTITION = 57489

const PATH = 57666

const PERCENT_RANK = 57630

const PERSIST = 57667

const PERSIST_ONLY = 57668

const PLUGINS = 57566

const POINT = 57543

const POLYGON = 57545

const PRECEDING = 57669

const PRIMARY = 57466

const PRIVILEGE_CHECKS_USER = 57670

const PROCEDURE = 57493

const PROCESS = 57671

const PROCESSLIST = 57562

const QUERY = 57608

const RANDOM = 57672

const RANK = 57631

const READ = 57578

const REAL = 57517

const RECURSIVE = 57632

const REFERENCE = 57673

const REFERENCES = 57478

const REGEXP = 57435

const RELEASE = 57507

const RENAME = 57454

const REORGANIZE = 57490

const REPAIR = 57485

const REPEATABLE = 57581

const REPLACE = 57594

const REQUIRE_ROW_FORMAT = 57674

const RESOURCE = 57675

const RESPECT = 57676

const RESTART = 57677

const RESTRICT = 57479

const RETAIN = 57678

const REUSE = 57679

const RIGHT = 57393

const ROLE = 57680

const ROLLBACK = 57505

const ROW_NUMBER = 57633

const S3 = 57380

const SAVEPOINT = 57506

const SCHEMA = 57458

const SECONDARY = 57681

const SECONDARY_ENGINE = 57682

const SECONDARY_LOAD = 57683

const SECONDARY_UNLOAD = 57684

const SELECT = 57348

const SEPARATOR = 57600

const SEQUENCE = 57500

const SERIALIZABLE = 57584

const SESSION = 57575

const SET = 57373

const SHARE = 57385

const SHIFT_LEFT = 57437

const SHIFT_RIGHT = 57438

const SHOW = 57480

const SIGNED = 57553

const SKIP = 57685

const SMALLINT = 57511

const SPATIAL = 57468

const SQL_CACHE = 57388

const SQL_CALC_FOUND_ROWS = 57389

const SQL_NO_CACHE = 57387

const SRID = 57686

const START = 57502

const STATUS = 57497

const STRAIGHT_JOIN = 57391

const STREAM = 57349

const STRING = 57406

const SUBSTR = 57597

const SUBSTRING = 57598

const SYSTEM = 57634

const TABLE = 57459

const TABLES = 57558

const TEXT = 57532

const THAN = 57492

const THEN = 57426

const THREAD_PRIORITY = 57687

const TIES = 57688

const TIME = 57522

const TIMESTAMP = 57523

const TIMESTAMPADD = 57601

const TIMESTAMPDIFF = 57602

const TINYBLOB = 57537

const TINYINT = 57510

const TINYTEXT = 57533

const TO = 57462

const TRADITIONAL = 57695

const TRANSACTION = 57503

const TREE = 57693

const TRIGGER = 57494

const TRUE = 57416

const TRUNCATE = 57487

const UNARY = 57441

const UNBOUNDED = 57689

const UNCOMMITTED = 57583

const UNDERSCORE_BINARY = 57444

const UNDERSCORE_LATIN1 = 57447

const UNDERSCORE_UTF8 = 57446

const UNDERSCORE_UTF8MB4 = 57445

const UNION = 57347

const UNIQUE = 57465

const UNLOCK = 57375

const UNSIGNED = 57554

const UNUSED = 57610

const UPDATE = 57352

const USE = 57398

const USING = 57401

const UTC_DATE = 57591

const UTC_TIME = 57592

const UTC_TIMESTAMP = 57593

const VALUE = 57384

const VALUES = 57381

const VALUE_ARG = 57410

const VARBINARY = 57530

const VARCHAR = 57527

const VARIABLES = 57498

const VCPU = 57690

const VIEW = 57461

const VINDEX = 57495

const VINDEXES = 57496

const VISIBLE = 57691

const VITESS = 57694

const VITESS_KEYSPACES = 57569

const VITESS_METADATA = 57559

const VITESS_SHARDS = 57570

const VITESS_TABLETS = 57571

const VSCHEMA = 57560

const VSTREAM = 57350

const WARNINGS = 57499

const WHEN = 57425

const WHERE = 57355

const WINDOW = 57635

const WITH = 57607

const WORK = 57508

const WRITE = 57579

const XOR = 57420

const YEAR = 57525

const ZEROFILL = 57555

Variables

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

	// TruncateErrLen truncate queries in error logs to the given length. 0 means unlimited.
	TruncateErrLen = flag.Int("sql-max-length-errors", 0, "truncate queries in error logs to the given length (default unlimited)")
)

var Aggregates = map[string]bool{
	"avg":          true,
	"bit_and":      true,
	"bit_or":       true,
	"bit_xor":      true,
	"count":        true,
	"group_concat": true,
	"max":          true,
	"min":          true,
	"std":          true,
	"stddev_pop":   true,
	"stddev_samp":  true,
	"stddev":       true,
	"sum":          true,
	"var_pop":      true,
	"var_samp":     true,
	"variance":     true,
}

Aggregates is a map of all aggregate functions.

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

ErrEmpty is a sentinel error returned when parsing empty statements.

var ErrExprNotSupported = fmt.Errorf("Expr Not Supported")

ErrExprNotSupported signals that the expression cannot be handled by expression evaluation engine.

Functions

func Append

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

Append appends the SQLNode to the buffer.

func CanNormalize

func CanNormalize(stmt Statement) bool

CanNormalize takes Statement and returns if the statement can be normalized.

func Convert

func Convert(e Expr) (evalengine.Expr, error)

Convert converts between AST expressions and executable expressions

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) (string, 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 Fuzz

func Fuzz(data []byte) int

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 IgnoreMaxMaxMemoryRowsDirective

func IgnoreMaxMaxMemoryRowsDirective(stmt Statement) bool

IgnoreMaxMaxMemoryRowsDirective returns true if the max memory rows override directive is set to true.

func IgnoreMaxPayloadSizeDirective

func IgnoreMaxPayloadSizeDirective(stmt Statement) bool

IgnoreMaxPayloadSizeDirective returns true if the max payload size override directive is set to true.

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 IsDMLStatement

func IsDMLStatement(stmt Statement) bool

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

func IsLockingFunc

func IsLockingFunc(node Expr) bool

IsLockingFunc returns true for all functions that are used to work with mysql advisory locks

func IsNull

func IsNull(node Expr) bool

IsNull returns true if the Expr is SQL NULL

func IsOnlineSchemaDDL

func IsOnlineSchemaDDL(ddl *DDL, sql string) bool

IsOnlineSchemaDDL returns true if the query is an online schema change DDL

func IsSetStatement

func IsSetStatement(stmt Statement) bool

IsSetStatement takes Statement and returns if the statement is set statement.

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 IsVschemaDDL

func IsVschemaDDL(ddl *DDL) bool

IsVschemaDDL returns true if the query is an Vschema alter ddl.

func KeywordString

func KeywordString(id int) string

KeywordString returns the string corresponding to the given keyword

func LikeToRegexp

func LikeToRegexp(likeExpr string) *regexp.Regexp

LikeToRegexp converts a like sql expression to regular expression

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 NormalizeAlphabetically

func NormalizeAlphabetically(query string) (normalized string, err error)

NormalizeAlphabetically rewrites given query such that: - WHERE 'AND' expressions are reordered alphabetically

func ParseTokenizer

func ParseTokenizer(tokenizer *Tokenizer) int

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

func QueryMatchesTemplates

func QueryMatchesTemplates(query string, queryTemplates []string) (match bool, err error)

QueryMatchesTemplates sees if the given query has the same fingerprint as one of the given templates (one is enough)

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 String

func String(node SQLNode) string

String returns a string representation of an SQLNode.

func StripLeadingComments

func StripLeadingComments(sql string) string

StripLeadingComments trims the SQL string and removes any leading comments

func TruncateForLog

func TruncateForLog(query string) string

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

func TruncateForUI

func TruncateForUI(query string) string

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

func Walk

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 AccessMode

type AccessMode int8

AccessMode is enum for the mode - ReadOnly or ReadWrite

const (
	ReadOnly AccessMode = iota
	ReadWrite
)

Constants for Enum type - AccessMode

func (AccessMode) Format

func (node AccessMode) Format(buf *TrackedBuffer)

Format formats the node.

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
	Partitions Partitions
	As         TableIdent
	Hints      *IndexHints
}

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

func (*AliasedTableExpr) Format

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

Format formats the node.

func (*AliasedTableExpr) RemoveHints

func (node *AliasedTableExpr) RemoveHints() *AliasedTableExpr

RemoveHints returns a new AliasedTableExpr with the hints removed.

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 Argument

type Argument []byte

Argument represents bindvariable expression

func NewArgument

func NewArgument(in []byte) Argument

NewArgument builds a new ValArg.

func (Argument) Format

func (node Argument) Format(buf *TrackedBuffer)

Format formats the node.

type AtCount

type AtCount int

AtCount represents the '@' count in ColIdent

const (
	// NoAt represents no @
	NoAt AtCount = iota
	// SingleAt represents @
	SingleAt
	// DoubleAt represnts @@
	DoubleAt
)

type AutoIncSpec

type AutoIncSpec struct {
	Column   ColIdent
	Sequence TableName
}

AutoIncSpec defines and autoincrement value for a ADD AUTO_INCREMENT statement

func (*AutoIncSpec) Format

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

Format formats the node.

type Begin

type Begin struct{}

Begin represents a Begin statement.

func (*Begin) Format

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

Format formats the node.

type BinaryExpr

type BinaryExpr struct {
	Operator    BinaryExprOperator
	Left, Right Expr
}

BinaryExpr represents a binary value expression.

func (*BinaryExpr) Format

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

Format formats the node.

type BinaryExprOperator

type BinaryExprOperator int8

BinaryExprOperator is an enum for BinaryExpr.Operator

const (
	BitAndOp BinaryExprOperator = iota
	BitOrOp
	BitXorOp
	PlusOp
	MinusOp
	MultOp
	DivOp
	IntDivOp
	ModOp
	ShiftLeftOp
	ShiftRightOp
	JSONExtractOp
	JSONUnquoteExtractOp
)

Constant for Enum Type - BinaryExprOperator

func (BinaryExprOperator) ToString

func (op BinaryExprOperator) ToString() string

ToString returns the operator as a string

type BindVarNeeds

type BindVarNeeds struct {
	NeedFunctionResult,
	NeedSystemVariable,

	NeedUserDefinedVariables []string
}

BindVarNeeds represents the bind vars that need to be provided as the result of expression rewriting.

func (*BindVarNeeds) AddFuncResult

func (bvn *BindVarNeeds) AddFuncResult(name string)

AddFuncResult adds a function bindvar need

func (*BindVarNeeds) AddSysVar

func (bvn *BindVarNeeds) AddSysVar(name string)

AddSysVar adds a system variable bindvar need

func (*BindVarNeeds) AddUserDefVar

func (bvn *BindVarNeeds) AddUserDefVar(name string)

AddUserDefVar adds a user defined variable bindvar need

func (*BindVarNeeds) HasRewrites

func (bvn *BindVarNeeds) HasRewrites() bool

func (*BindVarNeeds) MergeWith

func (bvn *BindVarNeeds) MergeWith(other *BindVarNeeds)

MergeWith adds bind vars needs coming from sub scopes

func (*BindVarNeeds) NeedsFuncResult

func (bvn *BindVarNeeds) NeedsFuncResult(name string) bool

NeedsFuncResult says if a function result needs to be provided

func (*BindVarNeeds) NeedsSysVar

func (bvn *BindVarNeeds) NeedsSysVar(name string) bool

NeedsSysVar says if a function result needs to be provided

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 Characteristic

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

Characteristic is a transaction related change

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 NewColIdentWithAt

func NewColIdentWithAt(str string, at AtCount) ColIdent

NewColIdentWithAt makes a new ColIdent.

func (ColIdent) AtCount

func (node ColIdent) AtCount() AtCount

AtCount return the '@' count present in ColIdent Name

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 NewColName

func NewColName(str string) *ColName

NewColName makes a new ColName

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
	// TODO: Should this not be a reference?
	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 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       bool
	Autoincrement bool
	Default       Expr
	OnUpdate      Expr
	Comment       *Literal

	// Numeric field options
	Length   *Literal
	Unsigned bool
	Zerofill bool
	Scale    *Literal

	// Text field options
	Charset string
	Collate string

	// Enum values
	EnumValues []string

	// Key specification
	KeyOpt ColumnKeyOption
}

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

func (*ColumnType) DescribeType

func (ct *ColumnType) DescribeType() string

DescribeType returns the abbreviated type information as required for describe table

func (*ColumnType) Format

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

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

func (*ColumnType) SQLType

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

SQLType returns the sqltypes type code for the given column

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 Commit

type Commit struct{}

Commit represents a Commit statement.

func (*Commit) Format

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

Format formats the node.

type ComparisonExpr

type ComparisonExpr struct {
	Operator    ComparisonExprOperator
	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.

func (*ComparisonExpr) IsImpossible

func (node *ComparisonExpr) IsImpossible() bool

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

type ComparisonExprOperator

type ComparisonExprOperator int8

ComparisonExprOperator is an enum for ComparisonExpr.Operator

const (
	EqualOp ComparisonExprOperator = iota
	LessThanOp
	GreaterThanOp
	LessEqualOp
	GreaterEqualOp
	NotEqualOp
	NullSafeEqualOp
	InOp
	NotInOp
	LikeOp
	NotLikeOp
	RegexpOp
	NotRegexpOp
)

Constants for Enum Type - ComparisonExprOperator

func (ComparisonExprOperator) ToString

func (op ComparisonExprOperator) ToString() string

ToString returns the operator as a string

type ConstraintDefinition

type ConstraintDefinition struct {
	Name    string
	Details ConstraintInfo
}

ConstraintDefinition describes a constraint in a CREATE TABLE statement

func (*ConstraintDefinition) Format

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

Format formats the node.

type ConstraintInfo

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

ConstraintInfo details a constraint in a CREATE TABLE statement

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   *Literal
	Scale    *Literal
	Operator ConvertTypeOperator
	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 ConvertTypeOperator

type ConvertTypeOperator int8

ConvertTypeOperator is an enum for ConvertType.Operator

const (
	NoOperator ConvertTypeOperator = iota
	CharacterSetOp
)

Constant for Enum Type - ConvertTypeOperator

func (ConvertTypeOperator) ToString

func (op ConvertTypeOperator) ToString() string

ToString returns the operator as a string

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 CurTimeFuncExpr

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

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

func (*CurTimeFuncExpr) Format

func (node *CurTimeFuncExpr) 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 DBDDL

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

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

func (*DBDDL) Format

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

Format formats the node.

type DBDDLAction

type DBDDLAction int8

DBDDLAction is an enum for DBDDL Actions

const (
	CreateDBDDLAction DBDDLAction = iota
	AlterDBDDLAction
	DropDBDDLAction
)

Constants for Enum Type - DBDDL.Action

type DDL

type DDL struct {
	Action DDLAction

	// FromTables is set if Action is RenameDDLAction or DropDDLAction.
	FromTables TableNames

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

	// Table is set if Action is other than RenameDDLAction or DropDDLAction.
	Table TableName

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

	// VindexSpec is set for CreateVindexDDLAction, DropVindexDDLAction, AddColVindexDDLAction, DropColVindexDDLAction.
	VindexSpec *VindexSpec

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

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

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

func (*DDL) AffectedTables

func (node *DDL) AffectedTables() TableNames

AffectedTables returns the list table names affected by the DDL.

func (*DDL) Format

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

Format formats the node.

type DDLAction

type DDLAction int8

DDLAction is an enum for DDL.Action

const (
	CreateDDLAction DDLAction = iota
	AlterDDLAction
	DropDDLAction
	RenameDDLAction
	TruncateDDLAction
	FlushDDLAction
	CreateVindexDDLAction
	DropVindexDDLAction
	AddVschemaTableDDLAction
	DropVschemaTableDDLAction
	AddColVindexDDLAction
	DropColVindexDDLAction
	AddSequenceDDLAction
	AddAutoIncDDLAction
)

Constants for Enum Type - DDL.Action

func (DDLAction) ToString

func (action DDLAction) ToString() string

ToString returns the string associated with the DDLAction Enum

type DDLStrategy

type DDLStrategy string

DDLStrategy suggests how an ALTER TABLE should run (e.g. "" for normal, "gh-ost" or "pt-osc")

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 {
	Ignore     Ignore
	Comments   Comments
	Targets    TableNames
	TableExprs TableExprs
	Partitions Partitions
	Where      *Where
	OrderBy    OrderBy
	Limit      *Limit
}

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

func (*Delete) Format

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 {
	Type      ExplainType
	Statement Statement
}

Explain represents an EXPLAIN statement

func (*Explain) Format

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

Format formats the node.

type ExplainType

type ExplainType int8

ExplainType is an enum for Explain.Type

const (
	EmptyType ExplainType = iota
	TreeType
	JSONType
	VitessType
	TraditionalType
	AnalyzeType
)

Constant for Enum Type - ExplainType

func (ExplainType) ToString

func (ty ExplainType) ToString() string

ToString returns the type as a string

type Expr

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

Expr represents an expression.

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.

func SplitAndExpression

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

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

type Exprs

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 ForeignKeyDefinition

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

ForeignKeyDefinition describes a foreign key in a CREATE TABLE statement

func (*ForeignKeyDefinition) Format

func (f *ForeignKeyDefinition) 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 []Expr

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  bool
	Exprs     SelectExprs
	OrderBy   OrderBy
	Separator string
	Limit     *Limit
}

GroupConcatExpr represents a call to GROUP_CONCAT

func (*GroupConcatExpr) Format

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

Format formats the node

type Ignore

type Ignore bool

Ignore represents whether ignore was specified or not

func (Ignore) ToString

func (ignore Ignore) ToString() string

ToString returns the IgnoreStr if ignore is true.

type IndexColumn

type IndexColumn struct {
	Column ColIdent
	Length *Literal
}

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 (*IndexDefinition) Format

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

Format formats the node.

type IndexHints

type IndexHints struct {
	Type    IndexHintsType
	Indexes []ColIdent
}

IndexHints represents a list of index hints.

func (*IndexHints) Format

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

Format formats the node.

type IndexHintsType

type IndexHintsType int8

IndexHintsType is an enum for IndexHints.Type

const (
	UseOp IndexHintsType = iota
	IgnoreOp
	ForceOp
)

Constant for Enum Type - IndexHintsType

func (IndexHintsType) ToString

func (ty IndexHintsType) ToString() string

ToString returns the type as a string

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

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

Format formats the node.

type IndexOption

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

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

type Insert

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

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

func (*Insert) Format

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

Format formats the node.

type InsertAction

type InsertAction int8

InsertAction is the action for insert.

const (
	InsertAct InsertAction = iota
	ReplaceAct
)

Constants for Enum Type - Insert.Action

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

type IsExprOperator int8

IsExprOperator is an enum for IsExpr.Operator

const (
	IsNullOp IsExprOperator = iota
	IsNotNullOp
	IsTrueOp
	IsNotTrueOp
	IsFalseOp
	IsNotFalseOp
)

Constant for Enum Type - IsExprOperator

func (IsExprOperator) ToString

func (op IsExprOperator) ToString() string

ToString returns the operator as a string

type IsolationLevel

type IsolationLevel int8

IsolationLevel is an enum for isolation levels

const (
	ReadUncommitted IsolationLevel = iota
	ReadCommitted
	RepeatableRead
	Serializable
)

Constants for Enum type - IsolationLevel

func (IsolationLevel) Format

func (node IsolationLevel) Format(buf *TrackedBuffer)

Format formats the node.

type JoinCondition

type JoinCondition struct {
	On    Expr
	Using Columns
}

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

func (JoinCondition) Format

func (node JoinCondition) Format(buf *TrackedBuffer)

Format formats the node.

type JoinTableExpr

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

JoinTableExpr represents a TableExpr that's a JOIN operation.

func (*JoinTableExpr) Format

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

Format formats the node.

type JoinType

type JoinType int8

JoinType represents the type of Join for JoinTableExpr

const (
	NormalJoinType JoinType = iota
	StraightJoinType
	LeftJoinType
	RightJoinType
	NaturalJoinType
	NaturalLeftJoinType
	NaturalRightJoinType
)

Constants for Enum Type - JoinType

func (JoinType) ToString

func (joinType JoinType) ToString() string

ToString returns the string associated with JoinType

type LengthScaleOption

type LengthScaleOption struct {
	Length *Literal
	Scale  *Literal
}

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 Literal

type Literal struct {
	Type ValType
	Val  []byte
}

Literal represents a fixed value.

func NewBitLiteral

func NewBitLiteral(in []byte) *Literal

NewBitLiteral builds a new BitVal containing a bit literal.

func NewFloatLiteral

func NewFloatLiteral(in []byte) *Literal

NewFloatLiteral builds a new FloatVal.

func NewHexLiteral

func NewHexLiteral(in []byte) *Literal

NewHexLiteral builds a new HexVal.

func NewHexNumLiteral

func NewHexNumLiteral(in []byte) *Literal

NewHexNumLiteral builds a new HexNum.

func NewIntLiteral

func NewIntLiteral(in []byte) *Literal

NewIntLiteral builds a new IntVal.

func NewStrLiteral

func NewStrLiteral(in []byte) *Literal

NewStrLiteral builds a new StrVal.

func (*Literal) Format

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

Format formats the node.

func (*Literal) HexDecode

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

HexDecode decodes the hexval into bytes.

type Lock

type Lock int8

Lock is an enum for the type of lock in the statement

const (
	NoLock Lock = iota
	ForUpdateLock
	ShareModeLock
)

Constants for Enum Type - Lock

func (Lock) ToString

func (lock Lock) ToString() string

ToString returns the string associated with the type of lock

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

MatchExpr represents a call to the MATCH function

func (*MatchExpr) Format

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

Format formats the node

type MatchExprOption

type MatchExprOption int8

MatchExprOption is an enum for MatchExpr.Option

const (
	NoOption MatchExprOption = iota
	BooleanModeOpt
	NaturalLanguageModeOpt
	NaturalLanguageModeWithQueryExpansionOpt
	QueryExpansionOpt
)

Constant for Enum Type - MatchExprOption

func (MatchExprOption) ToString

func (option MatchExprOption) ToString() string

ToString returns the option as a string

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

type OnlineDDLHint struct {
	Strategy DDLStrategy
	Options  string
}

OnlineDDLHint indicates strategy and options for running an online DDL

type OptLike

type OptLike struct {
	LikeTable TableName
}

OptLike works for create table xxx like xxx

func (*OptLike) Format

func (node *OptLike) 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 OrderDirection
}

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 OrderDirection

type OrderDirection int8

OrderDirection is an enum for Order.Direction

const (
	AscOrder OrderDirection = iota
	DescOrder
)

Constant for Enum Type - OrderDirection

func (OrderDirection) ToString

func (dir OrderDirection) ToString() string

ToString returns the direction as a string

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 ParenSelect

type ParenSelect struct {
	Select SelectStatement
}

ParenSelect is a parenthesized SELECT statement.

func (*ParenSelect) AddOrder

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

AddOrder adds an order by element

func (*ParenSelect) Format

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

Format formats the node.

func (*ParenSelect) SetLimit

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

SetLimit sets the limit clause

func (*ParenSelect) SetLock

func (node *ParenSelect) SetLock(lock Lock)

SetLock sets the lock 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) Append

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

Append appends the generated query to the provided buffer.

func (*ParsedQuery) GenerateQuery

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 {
	Name     ColIdent
	Limit    Expr
	Maxvalue bool
}

PartitionDefinition describes a very minimal partition definition

func (*PartitionDefinition) Format

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

Format formats the node

type PartitionSpec

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

PartitionSpec describe partition actions (for alter and create)

func (*PartitionSpec) Format

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

Format formats the node.

type PartitionSpecAction

type PartitionSpecAction int8

PartitionSpecAction is an enum for PartitionSpec.Action

const (
	ReorganizeAction PartitionSpecAction = iota
)

Constant for Enum Type - PartitionSpecAction

type Partitions

type Partitions Columns

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

func (Partitions) Format

func (node Partitions) Format(buf *TrackedBuffer)

Format formats the node

type PositionedErr

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

PositionedErr holds context related to parser errors

func (PositionedErr) Error

func (p PositionedErr) Error() string

type Precendence

type Precendence int

Precendence is used to know the precedence between operators, so we can introduce parens when needed in the String representation of the AST

const (
	Syntactic Precendence = iota
	P1
	P2
	P3
	P4
	P5
	P6
	P7
	P8
	P9
	P10
	P11
	P12
	P13
	P14
	P15
	P16
	P17
)

type RangeCond

type RangeCond struct {
	Operator RangeCondOperator
	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 RangeCondOperator

type RangeCondOperator int8

RangeCondOperator is an enum for RangeCond.Operator

const (
	BetweenOp RangeCondOperator = iota
	NotBetweenOp
)

Constant for Enum Type - RangeCondOperator

func (RangeCondOperator) ToString

func (op RangeCondOperator) ToString() string

ToString returns the operator as a string

type ReferenceAction

type ReferenceAction int

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

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

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

func (ReferenceAction) Format

func (a ReferenceAction) Format(buf *TrackedBuffer)

Format formats the node.

type Release

type Release struct {
	Name ColIdent
}

Release represents a release savepoint statement.

func (*Release) Format

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

Format formats the node.

type RewriteASTResult

type RewriteASTResult struct {
	*BindVarNeeds
	AST Statement // The rewritten AST
}

RewriteASTResult contains the rewritten ast and meta information about it

func PrepareAST

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

PrepareAST will normalize the query

func RewriteAST

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

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

type Rollback

type Rollback struct{}

Rollback represents a Rollback statement.

func (*Rollback) Format

func (node *Rollback) 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 SRollback

type SRollback struct {
	Name ColIdent
}

SRollback represents a rollback to savepoint statement.

func (*SRollback) Format

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

Format formats the node.

type Savepoint

type Savepoint struct {
	Name ColIdent
}

Savepoint represents a savepoint statement.

func (*Savepoint) Format

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

Format formats the node.

type Scope

type Scope int8

Scope is an enum for scope of query

const (
	ImplicitScope Scope = iota
	SessionScope
	GlobalScope
	VitessMetadataScope
	VariableScope
	LocalScope
)

Constants for Enum Type - Scope

func (Scope) ToString

func (scope Scope) ToString() string

ToString returns the string associated with the Scope enum

type Select

type Select struct {
	Cache            *bool // a reference here so it can be nil
	Distinct         bool
	StraightJoinHint bool
	SQLCalcFoundRows bool
	Comments         Comments
	SelectExprs      SelectExprs
	From             TableExprs
	Where            *Where
	GroupBy          GroupBy
	Having           *Where
	OrderBy          OrderBy
	Limit            *Limit
	Lock             Lock
	IntoOutfileS3    string
}

Select represents a SELECT statement.

func NewSelect

func NewSelect(comments Comments, exprs SelectExprs, selectOptions []string, from TableExprs, where *Where, groupBy GroupBy, having *Where) *Select

NewSelect is used to create 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.

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.

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

func (*Select) SetLock

func (node *Select) SetLock(lock Lock)

SetLock sets the lock clause

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

func (node SelectExprs) Format(buf *TrackedBuffer)

Format formats the node.

type SelectStatement

type SelectStatement interface {
	AddOrder(*Order)
	SetLimit(*Limit)
	SetLock(lock Lock)
	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 {
	Scope Scope
	Name  ColIdent
	Expr  Expr
}

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 SetTransaction

type SetTransaction struct {
	SQLNode
	Comments        Comments
	Scope           Scope
	Characteristics []Characteristic
}

SetTransaction represents a SET TRANSACTION statement.

func (*SetTransaction) Format

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

Format formats the node.

type Show

type Show struct {
	Extended               string
	Type                   string
	OnTable                TableName
	Table                  TableName
	ShowTablesOpt          *ShowTablesOpt
	Scope                  Scope
	ShowCollationFilterOpt Expr
}

Show represents a show statement.

func (*Show) Format

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

Format formats the node.

func (*Show) HasOnTable

func (node *Show) HasOnTable() bool

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

func (*Show) HasTable

func (node *Show) HasTable() bool

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

type ShowFilter

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 ShowTableStatus

type ShowTableStatus struct {
	DatabaseName string
	Filter       *ShowFilter
}

ShowTableStatus is a struct for SHOW TABLE STATUS queries.

func (*ShowTableStatus) Format

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

Format formats the node.

type ShowTablesOpt

type ShowTablesOpt struct {
	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 (*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 in full and returns a Statement, which is the AST representation of the query. If a DDL statement is partially parsed but still contains a syntax error, the error is ignored and the DDL is returned anyway.

func ParseNext

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

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

func ParseNextStrictDDL

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

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

func ParseStrictDDL

func ParseStrictDDL(sql string) (Statement, error)

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

type StatementType

type StatementType int

StatementType encodes the type of a SQL statement

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

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

func ASTToStatementType

func ASTToStatementType(stmt Statement) StatementType

ASTToStatementType returns a StatementType from an AST stmt

func Preview

func Preview(sql string) StatementType

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

func (StatementType) String

func (s StatementType) String() string

type Stream

type Stream struct {
	Comments   Comments
	SelectExpr SelectExpr
	Table      TableName
}

Stream represents a SELECT statement.

func (*Stream) Format

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

Format formats the node.

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 SubstrExpr

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

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

func (*SubstrExpr) Format

func (node *SubstrExpr) 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 TableFromStatement

func TableFromStatement(sql string) (TableName, error)

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

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.

func (TableName) ToViewName

func (node TableName) ToViewName() TableName

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

type TableNames

type TableNames []TableName

TableNames is a list of TableName.

func (TableNames) Format

func (node TableNames) Format(buf *TrackedBuffer)

Format formats the node.

type TableSpec

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

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

func (*TableSpec) AddColumn

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

AddColumn appends the given column to the list in the spec

func (*TableSpec) AddConstraint

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

AddConstraint appends the given index 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 TimestampFuncExpr

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

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

func (*TimestampFuncExpr) Format

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

Format formats the node.

type Tokenizer

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

	Position int

	LastError error

	ParseTree Statement
	// contains filtered or unexported fields
}

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

func NewStringTokenizer

func NewStringTokenizer(sql string) *Tokenizer

NewStringTokenizer creates a new Tokenizer for the sql string.

func NewTokenizer

func NewTokenizer(r io.Reader) *Tokenizer

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

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. It adds parens as needed to follow precedence rules when printing expressions. To handle parens correctly for left associative binary operators, use %l and %r to tell the TrackedBuffer which value is on the LHS and RHS

The name must be something other than the usual Printf() to avoid "go vet" warnings due to our custom format specifiers. *** THIS METHOD SHOULD NOT BE USED FROM ast.go. USE astPrintf INSTEAD ***

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

type UnaryExpr struct {
	Operator UnaryExprOperator
	Expr     Expr
}

UnaryExpr represents a unary value expression.

func (*UnaryExpr) Format

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

Format formats the node.

type UnaryExprOperator

type UnaryExprOperator int8

UnaryExprOperator is an enum for UnaryExpr.Operator

const (
	UPlusOp UnaryExprOperator = iota
	UMinusOp
	TildaOp
	BangOp
	BinaryOp
	UBinaryOp
	Utf8mb4Op
	Utf8Op
	Latin1Op
)

Constant for Enum Type - UnaryExprOperator

func (UnaryExprOperator) ToString

func (op UnaryExprOperator) ToString() string

ToString returns the operator as a string

type Union

type Union struct {
	FirstStatement SelectStatement
	UnionSelects   []*UnionSelect
	OrderBy        OrderBy
	Limit          *Limit
	Lock           Lock
}

Union represents a UNION statement.

func Unionize

func Unionize(lhs, rhs SelectStatement, typ UnionType, by OrderBy, limit *Limit, lock Lock) *Union

Unionize returns a UNION, either creating one or adding SELECT to an existing one

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

func (*Union) SetLock

func (node *Union) SetLock(lock Lock)

SetLock sets the lock clause

type UnionSelect

type UnionSelect struct {
	Type      UnionType
	Statement SelectStatement
}

UnionSelect represents union type and select statement after first select statement.

func (*UnionSelect) Format

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

Format formats the node.

type UnionType

type UnionType int8

UnionType is the type of union

const (
	UnionBasic UnionType = iota
	UnionAll
	UnionDistinct
)

Constants for Union.Type

type Update

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

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

func (*Update) Format

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 VStream

type VStream struct {
	Comments   Comments
	SelectExpr SelectExpr
	Table      TableName
	Where      *Where
	Limit      *Limit
}

VStream represents a VSTREAM statement.

func (*VStream) Format

func (node *VStream) 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 Literal.

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 *ColName
}

ValuesFuncExpr represents a function call.

func (*ValuesFuncExpr) Format

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

Format formats the node.

type VindexParam

type VindexParam struct {
	Key ColIdent
	Val string
}

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

func (VindexParam) Format

func (node VindexParam) Format(buf *TrackedBuffer)

Format formats the node.

type VindexSpec

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

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

func (*VindexSpec) Format

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

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

func (*VindexSpec) ParseParams

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

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

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 WhereType
	Expr Expr
}

Where represents a WHERE or HAVING clause.

func NewWhere

func NewWhere(typ WhereType, 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 WhereType

type WhereType int8

WhereType is an enum for Where.Type

const (
	WhereClause WhereType = iota
	HavingClause
)

Constants for Enum Type - WhereType

func (WhereType) ToString

func (whereType WhereType) ToString() string

ToString returns the string associated with WhereType

type XorExpr

type XorExpr struct {
	Left, Right Expr
}

XorExpr represents an XOR expression.

func (*XorExpr) Format

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

Format formats the node.