sqlparser

package
Version: v2.1.1+incompatible Latest Latest
Warning

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

Go to latest
Published: May 22, 2017 License: BSD-3-Clause Imports: 11 Imported by: 0

Documentation

Index

Constants

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

Select.Distinct

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

Select.Lock

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

Select.Cache

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

Union.Type

View Source
const (
	CreateStr = "create"
	AlterStr  = "alter"
	DropStr   = "drop"
	RenameStr = "rename"
)

DDL strings.

View Source
const (
	ShowDatabasesStr     = "show databases"
	ShowKeyspacesStr     = "show vitess_keyspaces"
	ShowShardsStr        = "show vitess_shards"
	ShowTablesStr        = "show tables"
	ShowVSchemaTablesStr = "show vschema_tables"
	ShowUnsupportedStr   = "show unsupported"
)

The frollowing constants represent SHOW statements.

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

JoinTableExpr.Join

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

Index hints.

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

Where.Type

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

ComparisonExpr.Operator

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

RangeCond.Operator

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

IsExpr.Operator

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

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

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

BinaryExpr.Operator

View Source
const (
	UPlusStr  = "+"
	UMinusStr = "-"
	TildaStr  = "~"
	BangStr   = "!"
	BinaryStr = "binary "
)

UnaryExpr.Operator

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

MatchExpr.Option

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

Order.Direction

View Source
const AGAINST = 57474
View Source
const ALL = 57361
View Source
const ALTER = 57432
View Source
const ANALYZE = 57435
View Source
const AND = 57405
View Source
const AS = 57363
View Source
const ASC = 57365
View Source
const BETWEEN = 57407
View Source
const BINARY = 57427
View Source
const BOOLEAN = 57475
View Source
const BY = 57357
View Source
const CASE = 57408
View Source
const CAST = 57470
View Source
const CHARACTER = 57458
View Source
const COLLATE = 57426
View Source
const COMMENT = 57400
View Source
const CONVERT = 57469
View Source
const CREATE = 57431
View Source
const CROSS = 57387
View Source
const CURRENT_DATE = 57461
View Source
const CURRENT_TIME = 57462
View Source
const CURRENT_TIMESTAMP = 57459
View Source
const (
	CharacterSetStr = " character set"
)

this string is "character set" and this comment is required

View Source
const DATABASE = 57460
View Source
const DATABASES = 57452
View Source
const DATE = 57447
View Source
const DEFAULT = 57370
View Source
const DELETE = 57351
View Source
const DESC = 57366
View Source
const DESCRIBE = 57445
View Source
const DISTINCT = 57362
View Source
const DIV = 57423
View Source
const DROP = 57433
View Source
const DUPLICATE = 57368
View Source
const ELSE = 57411
View Source
const END = 57412
View Source
const ESCAPE = 57448
View Source
const EXISTS = 57364
View Source
const EXPANSION = 57479
View Source
const EXPLAIN = 57446
View Source
const FALSE = 57403
View Source
const FLOAT = 57396
View Source
const FOR = 57360
View Source
const FORCE = 57390
View Source
const FROM = 57352
View Source
const GE = 57414
View Source
const GROUP = 57354
View Source
const GROUP_CONCAT = 57471
View Source
const HAVING = 57355
View Source
const HEX = 57393
View Source
const HEXNUM = 57397
View Source
const ID = 57392
View Source
const IF = 57441
View Source
const IGNORE = 57440
View Source
const IN = 57420
View Source
const INDEX = 57437
View Source
const INNER = 57385
View Source
const INSERT = 57349
View Source
const INTEGER = 57457
View Source
const INTEGRAL = 57395
View Source
const INTERVAL = 57428
View Source
const INTO = 57367
View Source
const IS = 57417
View Source
const JOIN = 57381
View Source
const JSON_EXTRACT_OP = 57429
View Source
const JSON_UNQUOTE_EXTRACT_OP = 57430
View Source
const KEY = 57369
View Source
const LANGUAGE = 57476
View Source
const LAST_INSERT_ID = 57374
View Source
const LE = 57413
View Source
const LEFT = 57383
View Source
const LEX_ERROR = 57346
View Source
const LIKE = 57418
View Source
const LIMIT = 57358
View Source
const LIST_ARG = 57399
View Source
const LOCALTIME = 57463
View Source
const LOCALTIMESTAMP = 57464
View Source
const LOCK = 57372
View Source
const MATCH = 57473
View Source
const MOD = 57424
View Source
const MODE = 57378
View Source
const NATURAL = 57388
View Source
const NE = 57415
View Source
const NEXT = 57375
View Source
const NOT = 57406
View Source
const NULL = 57401
View Source
const NULL_SAFE_EQUAL = 57416
View Source
const OFFSET = 57359
View Source
const ON = 57391
View Source
const OPTIMIZE = 57450
View Source
const OR = 57404
View Source
const ORDER = 57356
View Source
const OUTER = 57386
View Source
const QUERY = 57478
View Source
const REGEXP = 57419
View Source
const RENAME = 57434
View Source
const REPAIR = 57449
View Source
const REPLACE = 57468
View Source
const RIGHT = 57384
View Source
const SELECT = 57348
View Source
const SEPARATOR = 57472
View Source
const SET = 57371
View Source
const SHARE = 57377
View Source
const SHIFT_LEFT = 57421
View Source
const SHIFT_RIGHT = 57422
View Source
const SHOW = 57444
View Source
const SQL_CACHE = 57380
View Source
const SQL_NO_CACHE = 57379
View Source
const STRAIGHT_JOIN = 57382
View Source
const STRING = 57394
View Source
const TABLE = 57436
View Source
const TABLES = 57453
View Source
const THEN = 57410
View Source
const TO = 57439
View Source
const TRUE = 57402
View Source
const TRUNCATE = 57451
View Source
const UNARY = 57425
View Source
const UNION = 57347
View Source
const UNIQUE = 57442
View Source
const UNUSED = 57480
View Source
const UPDATE = 57350
View Source
const USE = 57389
View Source
const USING = 57443
View Source
const UTC_DATE = 57465
View Source
const UTC_TIME = 57466
View Source
const UTC_TIMESTAMP = 57467
View Source
const VALUE = 57376
View Source
const VALUES = 57373
View Source
const VALUE_ARG = 57398
View Source
const VIEW = 57438
View Source
const VITESS_KEYSPACES = 57454
View Source
const VITESS_SHARDS = 57455
View Source
const VSCHEMA_TABLES = 57456
View Source
const WHEN = 57409
View Source
const WHERE = 57353
View Source
const WITH = 57477

Variables

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

Aggregates is a map of all aggregate functions.

Functions

func Append

func Append(buf *bytes.Buffer, node SQLNode)

Append appends the SQLNode to the buffer.

func AsInterface

func AsInterface(node Expr) (interface{}, error)

AsInterface converts the Expr to an interface. It converts ValTuple to []interface{}, ValArg to string, StrVal to sqltypes.String, IntVal to sqltypes.Numeric, NullVal to nil. Otherwise, it returns an error.

func Backtick

func Backtick(in string) string

Backtick produces a backticked literal given an input string.

func EncodeValue

func EncodeValue(buf *bytes.Buffer, value interface{}) error

EncodeValue encodes one bind variable value into the query.

func ExtractSetNums

func ExtractSetNums(sql string) (map[string]int64, error)

ExtractSetNums returns a map of key-num pairs if the query is a SET statement. Otherwise, it returns an error.

func FetchBindVar

func FetchBindVar(name string, bindVariables map[string]interface{}) (val interface{}, isList bool, err error)

FetchBindVar resolves the bind variable by fetching it from bindVariables.

func FormatImpossibleQuery

func FormatImpossibleQuery(buf *TrackedBuffer, node SQLNode)

FormatImpossibleQuery creates an impossible query in a TrackedBuffer. An impossible query is a modified version of a query where all selects have where clauses that are impossible for mysql to resolve. This is used in the vtgate and vttablet:

- In the vtgate it's used for joins: if the first query returns no result, then vtgate uses the impossible query just to fetch field info from vttablet - In the vttablet, it's just an optimization: the field info is fetched once form MySQL, cached and reused for subsequent queries

func GetBindvars

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

GetBindvars returns a map of the bind vars referenced in the statement. TODO(sougou); This function gets called again from vtgate/planbuilder. Ideally, this should be done only once.

func HasPrefix

func HasPrefix(sql string, values ...string) bool

HasPrefix returns true if the query has one of the specified statement prefixes. For example, you can find out if a query is a DML with HasPrefix(sql, "insert", "update", "delete").

func IsColName

func IsColName(node Expr) bool

IsColName returns true if the Expr is a *ColName.

func IsDML

func IsDML(sql string) bool

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

func IsNull

func IsNull(node Expr) bool

IsNull returns true if the Expr is SQL NULL

func IsSimpleTuple

func IsSimpleTuple(node Expr) bool

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

func IsStatement

func IsStatement(sql, statement string) bool

IsStatement returns true if the sql matches a single-word statement like begin, commit or rollback.

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 Normalize

func Normalize(stmt Statement, bindVars map[string]interface{}, prefix string)

Normalize changes the statement to use bind values, and updates the bind vars to those values. The supplied prefix is used to generate the bind var names. The function ensures that there are no collisions with existing bind vars.

func SplitTrailingComments

func SplitTrailingComments(sql string) (query, comments string)

SplitTrailingComments splits the query trailing comments from the query.

func String

func String(node SQLNode) string

String returns a string representation of an SQLNode.

func StringIn

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

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

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

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

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

func (*AliasedTableExpr) Format

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

Format formats the node.

func (*AliasedTableExpr) WalkSubtree

func (node *AliasedTableExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type AndExpr

type AndExpr struct {
	Left, Right Expr
}

AndExpr represents an AND expression.

func (*AndExpr) Format

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

Format formats the node.

func (*AndExpr) WalkSubtree

func (node *AndExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type BinaryExpr

type BinaryExpr struct {
	Operator    string
	Left, Right Expr
}

BinaryExpr represents a binary value expression.

func (*BinaryExpr) Format

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

Format formats the node.

func (*BinaryExpr) WalkSubtree

func (node *BinaryExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type BoolVal

type BoolVal bool

BoolVal is true or false.

func (BoolVal) Format

func (node BoolVal) Format(buf *TrackedBuffer)

Format formats the node.

func (BoolVal) WalkSubtree

func (node BoolVal) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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.

func (*CaseExpr) WalkSubtree

func (node *CaseExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ColIdent

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

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

func NewColIdent

func NewColIdent(str string) ColIdent

NewColIdent makes a new ColIdent.

func (ColIdent) CompliantName

func (node ColIdent) CompliantName() string

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

func (ColIdent) Equal

func (node ColIdent) Equal(in ColIdent) bool

Equal performs a case-insensitive compare.

func (ColIdent) EqualString

func (node ColIdent) EqualString(str string) bool

EqualString performs a case-insensitive compare with str.

func (ColIdent) Format

func (node ColIdent) Format(buf *TrackedBuffer)

Format formats the node.

func (ColIdent) IsEmpty

func (node ColIdent) IsEmpty() bool

IsEmpty returns true if the name is empty.

func (ColIdent) Lowered

func (node ColIdent) Lowered() string

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

func (ColIdent) MarshalJSON

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

MarshalJSON marshals into JSON.

func (ColIdent) String

func (node ColIdent) String() string

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

func (*ColIdent) UnmarshalJSON

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

UnmarshalJSON unmarshals from JSON.

func (ColIdent) WalkSubtree

func (node ColIdent) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ColName

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

ColName represents a column name.

func (*ColName) 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.

func (*ColName) WalkSubtree

func (node *ColName) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ColTuple

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

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

type CollateExpr

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.

func (*CollateExpr) WalkSubtree

func (node *CollateExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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.

func (Columns) WalkSubtree

func (node Columns) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Comments

type Comments [][]byte

Comments represents a list of comments.

func (Comments) Format

func (node Comments) Format(buf *TrackedBuffer)

Format formats the node.

func (Comments) WalkSubtree

func (node Comments) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ComparisonExpr

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

ComparisonExpr represents a two-value comparison expression.

func (*ComparisonExpr) Format

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

Format formats the node.

func (*ComparisonExpr) WalkSubtree

func (node *ComparisonExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ConvertExpr

type ConvertExpr struct {
	Expr Expr
	Type *ConvertType
}

ConvertExpr represents a call to CONVERT(expr, type) CONVERT(expr USING transcoding_name) it not supported

func (*ConvertExpr) Format

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

Format formats the node.

func (*ConvertExpr) WalkSubtree

func (node *ConvertExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ConvertType

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

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

func (*ConvertType) Format

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

Format formats the node.

func (*ConvertType) WalkSubtree

func (node *ConvertType) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type DDL

type DDL struct {
	Action   string
	Table    *TableName
	NewName  *TableName
	IfExists bool
}

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

func (*DDL) Format

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

Format formats the node.

func (*DDL) WalkSubtree

func (node *DDL) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Delete

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

Delete represents a DELETE statement.

func (*Delete) Format

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

Format formats the node.

func (*Delete) WalkSubtree

func (node *Delete) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ExistsExpr

type ExistsExpr struct {
	Subquery *Subquery
}

ExistsExpr represents an EXISTS expression.

func (*ExistsExpr) Format

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

Format formats the node.

func (*ExistsExpr) WalkSubtree

func (node *ExistsExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Expr

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

Expr represents an expression.

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.

func (Exprs) WalkSubtree

func (node Exprs) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type FuncExpr

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

FuncExpr represents a function call.

func (*FuncExpr) 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.

func (*FuncExpr) WalkSubtree

func (node *FuncExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type GroupBy

type GroupBy []Expr

GroupBy represents a GROUP BY clause.

func (GroupBy) Format

func (node GroupBy) Format(buf *TrackedBuffer)

Format formats the node.

func (GroupBy) WalkSubtree

func (node GroupBy) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type GroupConcatExpr

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

GroupConcatExpr represents a call to GROUP_CONCAT

func (*GroupConcatExpr) Format

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

Format formats the node

func (*GroupConcatExpr) WalkSubtree

func (node *GroupConcatExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type IndexHints

type IndexHints struct {
	Type    string
	Indexes []ColIdent
}

IndexHints represents a list of index hints.

func (*IndexHints) Format

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

Format formats the node.

func (*IndexHints) WalkSubtree

func (node *IndexHints) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Insert

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

Insert represents an INSERT statement.

func (*Insert) Format

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

Format formats the node.

func (*Insert) WalkSubtree

func (node *Insert) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type InsertRows

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

InsertRows represents the rows for an INSERT statement.

type IntervalExpr

type IntervalExpr struct {
	Expr Expr
	Unit ColIdent
}

IntervalExpr represents a date-time INTERVAL expression.

func (*IntervalExpr) Format

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

Format formats the node.

func (*IntervalExpr) WalkSubtree

func (node *IntervalExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type IsExpr

type IsExpr struct {
	Operator string
	Expr     Expr
}

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

func (*IsExpr) Format

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

Format formats the node.

func (*IsExpr) WalkSubtree

func (node *IsExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type JoinTableExpr

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

JoinTableExpr represents a TableExpr that's a JOIN operation.

func (*JoinTableExpr) Format

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

Format formats the node.

func (*JoinTableExpr) WalkSubtree

func (node *JoinTableExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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.

func (*Limit) WalkSubtree

func (node *Limit) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ListArg

type ListArg []byte

ListArg represents a named list argument.

func (ListArg) Format

func (node ListArg) Format(buf *TrackedBuffer)

Format formats the node.

func (ListArg) WalkSubtree

func (node ListArg) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type MatchExpr

type MatchExpr struct {
	Columns SelectExprs
	Expr    Expr
	Option  string
}

MatchExpr represents a call to the MATCH function

func (*MatchExpr) Format

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

Format formats the node

func (*MatchExpr) WalkSubtree

func (node *MatchExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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.

func (Nextval) WalkSubtree

func (node Nextval) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type NonStarExpr

type NonStarExpr struct {
	Expr Expr
	As   ColIdent
}

NonStarExpr defines a non-'*' select expr.

func (*NonStarExpr) Format

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

Format formats the node.

func (*NonStarExpr) WalkSubtree

func (node *NonStarExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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.

func (*NotExpr) WalkSubtree

func (node *NotExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type NullVal

type NullVal struct{}

NullVal represents a NULL value.

func (*NullVal) Format

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

Format formats the node.

func (*NullVal) WalkSubtree

func (node *NullVal) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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.

func (OnDup) WalkSubtree

func (node OnDup) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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.

func (*OrExpr) WalkSubtree

func (node *OrExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Order

type Order struct {
	Expr      Expr
	Direction string
}

Order represents an ordering expression.

func (*Order) Format

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

Format formats the node.

func (*Order) WalkSubtree

func (node *Order) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type OrderBy

type OrderBy []*Order

OrderBy represents an ORDER By clause.

func (OrderBy) Format

func (node OrderBy) Format(buf *TrackedBuffer)

Format formats the node.

func (OrderBy) WalkSubtree

func (node OrderBy) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Other

type Other struct{}

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

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

Format formats the node.

func (*Other) WalkSubtree

func (node *Other) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ParenExpr

type ParenExpr struct {
	Expr Expr
}

ParenExpr represents a parenthesized boolean expression.

func (*ParenExpr) Format

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

Format formats the node.

func (*ParenExpr) WalkSubtree

func (node *ParenExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ParenSelect

type ParenSelect struct {
	Select SelectStatement
}

ParenSelect is a parenthesized SELECT statement.

func (*ParenSelect) AddOrder

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

AddOrder adds an order by element

func (*ParenSelect) Format

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

Format formats the node.

func (*ParenSelect) SetLimit

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

SetLimit sets the limit clause

func (*ParenSelect) WalkSubtree

func (node *ParenSelect) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ParenTableExpr

type ParenTableExpr struct {
	Exprs TableExprs
}

ParenTableExpr represents a parenthesized list of TableExpr.

func (*ParenTableExpr) Format

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

Format formats the node.

func (*ParenTableExpr) WalkSubtree

func (node *ParenTableExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ParsedQuery

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

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

func BuildParsedQuery

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

BuildParsedQuery builds a ParsedQuery from the input.

func GenerateParsedQuery

func GenerateParsedQuery(node SQLNode) *ParsedQuery

GenerateParsedQuery returns a ParsedQuery of the ast.

func (*ParsedQuery) GenerateQuery

func (pq *ParsedQuery) GenerateQuery(bindVariables map[string]interface{}) ([]byte, error)

GenerateQuery generates a query by substituting the specified bindVariables.

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 RangeCond

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

RangeCond represents a BETWEEN or a NOT BETWEEN expression.

func (*RangeCond) Format

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

Format formats the node.

func (*RangeCond) WalkSubtree

func (node *RangeCond) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type SQLNode

type SQLNode interface {
	Format(buf *TrackedBuffer)
	// WalkSubtree calls visit on all underlying nodes
	// of the subtree, but not the current one. Walking
	// must be interrupted if visit returns an error.
	WalkSubtree(visit Visit) error
}

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

type SQLVal

type SQLVal struct {
	Type ValType
	Val  []byte
}

SQLVal represents a single value.

func NewFloatVal

func NewFloatVal(in []byte) *SQLVal

NewFloatVal builds a new FloatVal.

func NewHexNum

func NewHexNum(in []byte) *SQLVal

NewHexNum builds a new HexNum.

func NewHexVal

func NewHexVal(in []byte) *SQLVal

NewHexVal builds a new HexVal.

func NewIntVal

func NewIntVal(in []byte) *SQLVal

NewIntVal builds a new IntVal.

func NewStrVal

func NewStrVal(in []byte) *SQLVal

NewStrVal builds a new StrVal.

func NewValArg

func NewValArg(in []byte) *SQLVal

NewValArg builds a new ValArg.

func (*SQLVal) Format

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

Format formats the node.

func (*SQLVal) HexDecode

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

HexDecode decodes the hexval into bytes.

func (*SQLVal) WalkSubtree

func (node *SQLVal) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Select

type Select struct {
	Cache       string
	Comments    Comments
	Distinct    string
	Hints       string
	SelectExprs SelectExprs
	From        TableExprs
	Where       *Where
	GroupBy     GroupBy
	Having      *Where
	OrderBy     OrderBy
	Limit       *Limit
	Lock        string
}

Select represents a SELECT statement.

func (*Select) AddHaving

func (node *Select) AddHaving(expr Expr)

AddHaving adds the boolean expression to the HAVING clause as an AND condition. If the expression is an OR clause, it parenthesizes it. Currently, the OR operator is the only one that's lower precedence than AND.

func (*Select) AddOrder

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

AddOrder adds an order by element

func (*Select) AddWhere

func (node *Select) AddWhere(expr Expr)

AddWhere adds the boolean expression to the WHERE clause as an AND condition. If the expression is an OR clause, it parenthesizes it. Currently, the OR operator is the only one that's lower precedence than AND.

func (*Select) Format

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

Format formats the node.

func (*Select) SetLimit

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

SetLimit sets the limit clause

func (*Select) WalkSubtree

func (node *Select) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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.

func (SelectExprs) WalkSubtree

func (node SelectExprs) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type SelectStatement

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

SelectStatement any SELECT statement.

type Set

type Set struct {
	Comments Comments
	Exprs    UpdateExprs
}

Set represents a SET statement.

func (*Set) Format

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

Format formats the node.

func (*Set) WalkSubtree

func (node *Set) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Show

type Show struct {
	Type string
}

Show represents a show statement.

func (*Show) Format

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

Format formats the node.

func (*Show) WalkSubtree

func (node *Show) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type SimpleTableExpr

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

SimpleTableExpr represents a simple table expression.

type StarExpr

type StarExpr struct {
	TableName *TableName
}

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

func (*StarExpr) Format

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

Format formats the node.

func (*StarExpr) WalkSubtree

func (node *StarExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Statement

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

Statement represents a statement.

func Parse

func Parse(sql string) (Statement, error)

Parse parses the sql and returns a Statement, which is the AST representation of the query.

type Subquery

type Subquery struct {
	Select SelectStatement
}

Subquery represents a subquery.

func (*Subquery) Format

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

Format formats the node.

func (*Subquery) WalkSubtree

func (node *Subquery) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type TableExpr

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

TableExpr represents a table expression.

type TableExprs

type TableExprs []TableExpr

TableExprs represents a list of table expressions.

func (TableExprs) Format

func (node TableExprs) Format(buf *TrackedBuffer)

Format formats the node.

func (TableExprs) WalkSubtree

func (node TableExprs) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type TableIdent

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

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

func GetTableName

func GetTableName(node SimpleTableExpr) TableIdent

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

func NewTableIdent

func NewTableIdent(str string) TableIdent

NewTableIdent creates a new TableIdent.

func (TableIdent) CompliantName

func (node TableIdent) CompliantName() string

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

func (TableIdent) Format

func (node TableIdent) Format(buf *TrackedBuffer)

Format formats the node.

func (TableIdent) IsEmpty

func (node TableIdent) IsEmpty() bool

IsEmpty returns true if TabIdent is empty.

func (TableIdent) MarshalJSON

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

MarshalJSON marshals into JSON.

func (TableIdent) String

func (node TableIdent) String() string

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

func (*TableIdent) UnmarshalJSON

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

UnmarshalJSON unmarshals from JSON.

func (TableIdent) WalkSubtree

func (node TableIdent) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type TableName

type TableName struct {
	Name, Qualifier TableIdent
}

TableName represents a table name. Qualifier, if specified, represents a database. It's generally not supported because vitess has its own rules about which database to send a query to.

func (*TableName) Equal

func (node *TableName) Equal(t *TableName) bool

Equal returns true if the table names match.

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.

func (*TableName) WalkSubtree

func (node *TableName) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Tokenizer

type Tokenizer struct {
	InStream      *strings.Reader
	AllowComments bool
	ForceEOF      bool

	Position int

	LastError string

	ParseTree Statement
	// contains filtered or unexported fields
}

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

func NewStringTokenizer

func NewStringTokenizer(sql string) *Tokenizer

NewStringTokenizer creates a new Tokenizer for the sql string.

func (*Tokenizer) Error

func (tkn *Tokenizer) Error(err string)

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

func (*Tokenizer) Lex

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

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

func (*Tokenizer) Scan

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

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

type TrackedBuffer

type TrackedBuffer struct {
	*bytes.Buffer
	// contains filtered or unexported fields
}

TrackedBuffer is used to rebuild a query from the ast. bindLocations keeps track of locations in the buffer that use bind variables for efficient future substitutions. nodeFormatter is the formatting function the buffer will use to format a node. By default(nil), it's FormatNode. But you can supply a different formatting function if you want to generate a query that's different from the default.

func NewTrackedBuffer

func NewTrackedBuffer(nodeFormatter func(buf *TrackedBuffer, node SQLNode)) *TrackedBuffer

NewTrackedBuffer creates a new TrackedBuffer.

func (*TrackedBuffer) HasBindVars

func (buf *TrackedBuffer) HasBindVars() bool

HasBindVars returns true if the parsed query uses bind vars.

func (*TrackedBuffer) Myprintf

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

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

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

func (*TrackedBuffer) ParsedQuery

func (buf *TrackedBuffer) ParsedQuery() *ParsedQuery

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

func (*TrackedBuffer) WriteArg

func (buf *TrackedBuffer) WriteArg(arg string)

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

func (*TrackedBuffer) WriteNode

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

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

type TupleEqualityList

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

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

func (*TupleEqualityList) Encode

func (tpl *TupleEqualityList) Encode(buf *bytes.Buffer) error

Encode generates the where clause constraints for the tuple equality.

type UnaryExpr

type UnaryExpr struct {
	Operator string
	Expr     Expr
}

UnaryExpr represents a unary value expression.

func (*UnaryExpr) Format

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

Format formats the node.

func (*UnaryExpr) WalkSubtree

func (node *UnaryExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Union

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

Union represents a UNION statement.

func (*Union) 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) WalkSubtree

func (node *Union) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Update

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

Update represents an UPDATE statement.

func (*Update) Format

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

Format formats the node.

func (*Update) WalkSubtree

func (node *Update) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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.

func (*UpdateExpr) WalkSubtree

func (node *UpdateExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type UpdateExprs

type UpdateExprs []*UpdateExpr

UpdateExprs represents a list of update expressions.

func (UpdateExprs) Format

func (node UpdateExprs) Format(buf *TrackedBuffer)

Format formats the node.

func (UpdateExprs) WalkSubtree

func (node UpdateExprs) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ValTuple

type ValTuple Exprs

ValTuple represents a tuple of actual values.

func (ValTuple) Format

func (node ValTuple) Format(buf *TrackedBuffer)

Format formats the node.

func (ValTuple) WalkSubtree

func (node ValTuple) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ValType

type ValType int

ValType specifies the type for SQLVal.

type Values

type Values []ValTuple

Values represents a VALUES clause.

func (Values) Format

func (node Values) Format(buf *TrackedBuffer)

Format formats the node.

func (Values) WalkSubtree

func (node Values) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ValuesFuncExpr

type ValuesFuncExpr struct {
	Name     ColIdent
	Resolved Expr
}

ValuesFuncExpr represents a function call.

func (*ValuesFuncExpr) Format

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

Format formats the node.

func (*ValuesFuncExpr) WalkSubtree

func (node *ValuesFuncExpr) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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.

func (*When) WalkSubtree

func (node *When) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Where

type Where struct {
	Type string
	Expr Expr
}

Where represents a WHERE or HAVING clause.

func NewWhere

func NewWhere(typ string, expr Expr) *Where

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

func (*Where) Format

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

Format formats the node.

func (*Where) WalkSubtree

func (node *Where) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL