sqlparser

Documentation

Index

• Constants
• Variables
• func AsInterface(node ValExpr) (interface{}, error)
• func EncodeValue(buf *bytes.Buffer, value interface{}) error
• func FetchBindVar(name string, bindVariables map[string]interface{}) (val interface{}, isList bool, err error)
• func GetColName(node Expr) string
• func GetTableName(node SimpleTableExpr) string
• func HasINClause(conditions []BoolExpr) bool
• func IsColName(node ValExpr) bool
• func IsNull(node ValExpr) bool
• func IsSimpleTuple(node ValExpr) bool
• func IsValue(node ValExpr) bool
• func String(node SQLNode) string
• func StringIn(str string, values ...string) bool
• type AliasedTableExpr
  • func (node *AliasedTableExpr) Format(buf *TrackedBuffer)
• type AndExpr
  • func (node *AndExpr) Format(buf *TrackedBuffer)
• type BinaryExpr
  • func (node *BinaryExpr) Format(buf *TrackedBuffer)
• type BoolExpr
• type BoolVal
  • func (node BoolVal) Format(buf *TrackedBuffer)
• type CaseExpr
  • func (node *CaseExpr) Format(buf *TrackedBuffer)
• type ColName
  • func (node *ColName) Format(buf *TrackedBuffer)
• type ColTuple
• type Columns
  • func (node Columns) Format(buf *TrackedBuffer)
• type Comments
  • func (node Comments) Format(buf *TrackedBuffer)
• type ComparisonExpr
  • func (node *ComparisonExpr) Format(buf *TrackedBuffer)
• type DDL
  • func (node *DDL) Format(buf *TrackedBuffer)
• type Delete
  • func (node *Delete) Format(buf *TrackedBuffer)
• type ExistsExpr
  • func (node *ExistsExpr) Format(buf *TrackedBuffer)
• type Expr
• type FuncExpr
  • func (node *FuncExpr) Format(buf *TrackedBuffer)
  • func (node *FuncExpr) IsAggregate() bool
• type GroupBy
  • func (node GroupBy) Format(buf *TrackedBuffer)
• type IndexHints
  • func (node *IndexHints) Format(buf *TrackedBuffer)
• type Insert
  • func (node *Insert) Format(buf *TrackedBuffer)
• type InsertRows
• type IsExpr
  • func (node *IsExpr) Format(buf *TrackedBuffer)
• type JoinTableExpr
  • func (node *JoinTableExpr) Format(buf *TrackedBuffer)
• type KeyrangeExpr
  • func (node *KeyrangeExpr) Format(buf *TrackedBuffer)
• type Limit
  • func (node *Limit) Format(buf *TrackedBuffer)
  • func (node *Limit) Limits() (offset, rowcount interface{}, err error)
• type ListArg
  • func (node ListArg) Format(buf *TrackedBuffer)
• type NonStarExpr
  • func (node *NonStarExpr) Format(buf *TrackedBuffer)
• type NotExpr
  • func (node *NotExpr) Format(buf *TrackedBuffer)
• type NullVal
  • func (node *NullVal) Format(buf *TrackedBuffer)
• type NumVal
  • func (node NumVal) Format(buf *TrackedBuffer)
• type OnDup
  • func (node OnDup) 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 Other
  • func (node *Other) Format(buf *TrackedBuffer)
• type ParenBoolExpr
  • func (node *ParenBoolExpr) Format(buf *TrackedBuffer)
• type ParenTableExpr
  • func (node *ParenTableExpr) Format(buf *TrackedBuffer)
• type ParsedQuery
  • func GenerateParsedQuery(node SQLNode) *ParsedQuery
  • func (pq *ParsedQuery) GenerateQuery(bindVariables map[string]interface{}) ([]byte, error)
  • func (pq *ParsedQuery) MarshalJSON() ([]byte, error)
• type RangeCond
  • func (node *RangeCond) Format(buf *TrackedBuffer)
• type RowTuple
• type SQLName
  • func (node SQLName) Format(buf *TrackedBuffer)
• type SQLNode
• type Select
  • func (node *Select) Format(buf *TrackedBuffer)
• type SelectExpr
• type SelectExprs
  • func (node SelectExprs) Format(buf *TrackedBuffer)
• type SelectStatement
• type Set
  • func (node *Set) Format(buf *TrackedBuffer)
• type SimpleTableExpr
• type StarExpr
  • func (node *StarExpr) Format(buf *TrackedBuffer)
• type Statement
  • func Parse(sql string) (Statement, error)
• type StrVal
  • func (node StrVal) Format(buf *TrackedBuffer)
• type Subquery
  • func (node *Subquery) Format(buf *TrackedBuffer)
• type TableExpr
• type TableExprs
  • func (node TableExprs) Format(buf *TrackedBuffer)
• type TableName
  • func (node *TableName) Format(buf *TrackedBuffer)
• type Tokenizer
  • func NewStringTokenizer(sql string) *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 func(buf *TrackedBuffer, node SQLNode)) *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)
• type TupleEqualityList
  • func (tpl *TupleEqualityList) Encode(buf *bytes.Buffer) error
• type UnaryExpr
  • func (node *UnaryExpr) Format(buf *TrackedBuffer)
• type Union
  • func (node *Union) Format(buf *TrackedBuffer)
• 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 ValArg
  • func (node ValArg) Format(buf *TrackedBuffer)
• type ValExpr
• type ValExprs
  • func (node ValExprs) Format(buf *TrackedBuffer)
• type ValTuple
  • func (node ValTuple) Format(buf *TrackedBuffer)
• type Values
  • func (node Values) Format(buf *TrackedBuffer)
• type When
  • func (node *When) Format(buf *TrackedBuffer)
• type Where
  • func NewWhere(typ string, expr BoolExpr) *Where
  • func (node *Where) Format(buf *TrackedBuffer)

Constants

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

Select.Lock

const (
	UnionStr     = "union"
	UnionAllStr  = "union all"
	SetMinusStr  = "minus"
	ExceptStr    = "except"
	IntersectStr = "intersect"
)

Union.Type

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

DDL strings.

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

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

Index hints.

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

Where.Type

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

ComparisonExpr.Operator

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

RangeCond.Operator

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

IsExpr.Operator

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

BinaryExpr.Operator

const (
	UPlusStr  = '+'
	UMinusStr = '-'
	TildaStr  = '~'
)

UnaryExpr.Operator

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

Order.Direction

const ALL = 57363

const ALTER = 57419

const ANALYZE = 57422

const AND = 57399

const AS = 57365

const ASC = 57367

const BETWEEN = 57401

const BY = 57360

const CASE = 57402

const COMMENT = 57394

const CREATE = 57418

const CROSS = 57384

const DEFAULT = 57372

const DELETE = 57354

const DESC = 57368

const DESCRIBE = 57432

const DISTINCT = 57364

const DROP = 57420

const DUPLICATE = 57370

const (
	DistinctStr = "distinct "
)

Select.Distinct

const ELSE = 57405

const END = 57417

const EXCEPT = 57349

const EXISTS = 57366

const EXPLAIN = 57433

const FALSE = 57397

const FOR = 57362

const FORCE = 57387

const FROM = 57355

const GE = 57407

const GROUP = 57357

const HAVING = 57358

const ID = 57389

const IF = 57428

const IGNORE = 57427

const IN = 57413

const INDEX = 57424

const INNER = 57382

const INSERT = 57352

const INTERSECT = 57350

const INTO = 57369

const IS = 57410

const JOIN = 57378

const KEY = 57371

const KEYRANGE = 57375

const LAST_INSERT_ID = 57377

const LE = 57406

const LEFT = 57380

const LEX_ERROR = 57346

const LIKE = 57411

const LIMIT = 57361

const LIST_ARG = 57393

const LOCK = 57374

const MINUS = 57348

const NATURAL = 57385

const NE = 57408

const NOT = 57400

const NULL = 57395

const NULL_SAFE_EQUAL = 57409

const NUMBER = 57391

const ON = 57388

const OR = 57398

const ORDER = 57359

const OUTER = 57383

const REGEXP = 57412

const RENAME = 57421

const RIGHT = 57381

const SELECT = 57351

const SET = 57373

const SHIFT_LEFT = 57414

const SHIFT_RIGHT = 57415

const SHOW = 57431

const STRAIGHT_JOIN = 57379

const STRING = 57390

const TABLE = 57423

const THEN = 57404

const TO = 57426

const TRUE = 57396

const UNARY = 57416

const UNION = 57347

const UNIQUE = 57429

const UPDATE = 57353

const USE = 57386

const USING = 57430

const VALUES = 57376

const VALUE_ARG = 57392

const VIEW = 57425

const WHEN = 57403

const WHERE = 57356

Variables

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 AllExprs = []Expr{
	&AndExpr{},
	&OrExpr{},
	&NotExpr{},
	&ParenBoolExpr{},
	&ComparisonExpr{},
	&RangeCond{},
	&IsExpr{},
	&ExistsExpr{},
	&KeyrangeExpr{},
	StrVal(""),
	NumVal(""),
	ValArg(""),
	&NullVal{},
	BoolVal(false),
	&ColName{},
	ValTuple{},
	&Subquery{},
	ListArg(""),
	&BinaryExpr{},
	&UnaryExpr{},
	&FuncExpr{},
	&CaseExpr{},
}

AllExprs must contain one variable for each AST type that satisfies Expr. This allows for external packages to verify that they're not missing on any types.

Functions

func AsInterface

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

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

func EncodeValue

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

EncodeValue encodes one bind variable value into the query.

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 GetColName

func GetColName(node Expr) string

GetColName returns the column name, only if it's a simple expression. Otherwise, it returns "".

func GetTableName

func GetTableName(node SimpleTableExpr) string

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

func HasINClause

func HasINClause(conditions []BoolExpr) bool

HasINClause returns true if any of the conditions has an IN clause.

func IsColName

func IsColName(node ValExpr) bool

IsColName returns true if the ValExpr is a *ColName.

func IsNull

func IsNull(node ValExpr) bool

IsNull returns true if the ValExpr is SQL NULL

func IsSimpleTuple

func IsSimpleTuple(node ValExpr) bool

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

func IsValue

func IsValue(node ValExpr) bool

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

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.

Types

type AliasedTableExpr

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

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

func (*AliasedTableExpr) Format

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

Format formats the node.

type AndExpr

type AndExpr struct {
	Left, Right BoolExpr
}

AndExpr represents an AND expression.

func (*AndExpr) Format

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

Format formats the node.

type BinaryExpr

type BinaryExpr struct {
	Operator    string
	Left, Right Expr
}

BinaryExpr represents a binary value expression.

func (*BinaryExpr) Format

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

Format formats the node.

type BoolExpr

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

BoolExpr represents a boolean expression.

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  ValExpr
	Whens []*When
	Else  ValExpr
}

CaseExpr represents a CASE expression.

func (*CaseExpr) Format

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

Format formats the node.

type ColName

type ColName struct {
	Name      SQLName
	Qualifier SQLName
}

ColName represents a column name.

func (*ColName) Format

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

Format formats the node.

type ColTuple

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

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

type Columns

type Columns []SelectExpr

Columns represents an insert column list. The syntax for Columns is a subset of SelectExprs. So, it's castable to a SelectExprs and can be analyzed as such.

func (Columns) Format

func (node Columns) Format(buf *TrackedBuffer)

Format formats the node.

type Comments

type Comments [][]byte

Comments represents a list of comments.

func (Comments) Format

func (node Comments) Format(buf *TrackedBuffer)

Format formats the node.

type ComparisonExpr

type ComparisonExpr struct {
	Operator    string
	Left, Right ValExpr
}

ComparisonExpr represents a two-value comparison expression.

func (*ComparisonExpr) Format

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

Format formats the node.

type DDL

type DDL struct {
	Action  string
	Table   SQLName
	NewName SQLName
}

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

func (*DDL) Format

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

Format formats the node.

type Delete

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

Delete represents a DELETE statement.

func (*Delete) Format

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

Format formats the node.

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

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

Expr represents an expression.

type FuncExpr

type FuncExpr struct {
	Name     string
	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 []ValExpr

GroupBy represents a GROUP BY clause.

func (GroupBy) Format

func (node GroupBy) Format(buf *TrackedBuffer)

Format formats the node.

type IndexHints

type IndexHints struct {
	Type    string
	Indexes []SQLName
}

IndexHints represents a list of index hints.

func (*IndexHints) Format

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

Format formats the node.

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.

type InsertRows

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

InsertRows represents the rows for an INSERT statement.

type IsExpr

type IsExpr struct {
	Operator string
	Expr     Expr
}

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

func (*IsExpr) Format

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

Format formats the node.

type JoinTableExpr

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

JoinTableExpr represents a TableExpr that's a JOIN operation.

func (*JoinTableExpr) Format

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

Format formats the node.

type KeyrangeExpr

type KeyrangeExpr struct {
	Start, End ValExpr
}

KeyrangeExpr represents a KEYRANGE expression.

func (*KeyrangeExpr) Format

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

Format formats the node.

type Limit

type Limit struct {
	Offset, Rowcount ValExpr
}

Limit represents a LIMIT clause.

func (*Limit) Format

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

Format formats the node.

func (*Limit) Limits

func (node *Limit) Limits() (offset, rowcount interface{}, err error)

Limits returns the values of the LIMIT clause as interfaces. The returned values can be nil for absent field, string for bind variable names, or int64 for an actual number. Otherwise, it's an error.

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 NonStarExpr

type NonStarExpr struct {
	Expr Expr
	As   SQLName
}

NonStarExpr defines a non-'*' select expr.

func (*NonStarExpr) Format

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

Format formats the node.

type NotExpr

type NotExpr struct {
	Expr BoolExpr
}

NotExpr represents a NOT expression.

func (*NotExpr) Format

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

Format formats the node.

type NullVal

type NullVal struct{}

NullVal represents a NULL value.

func (*NullVal) Format

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

Format formats the node.

type NumVal

type NumVal []byte

NumVal represents a number.

func (NumVal) Format

func (node NumVal) 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 OrExpr

type OrExpr struct {
	Left, Right BoolExpr
}

OrExpr represents an OR expression.

func (*OrExpr) Format

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

Format formats the node.

type Order

type Order struct {
	Expr      ValExpr
	Direction string
}

Order represents an ordering expression.

func (*Order) Format

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

Format formats the node.

type OrderBy

type OrderBy []*Order

OrderBy represents an ORDER By clause.

func (OrderBy) Format

func (node OrderBy) Format(buf *TrackedBuffer)

Format formats the node.

type Other

type Other struct{}

Other represents a SHOW, 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.

type ParenBoolExpr

type ParenBoolExpr struct {
	Expr BoolExpr
}

ParenBoolExpr represents a parenthesized boolean expression.

func (*ParenBoolExpr) Format

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

Format formats the node.

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

type RangeCond

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

RangeCond represents a BETWEEN or a NOT BETWEEN expression.

func (*RangeCond) Format

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

Format formats the node.

type RowTuple

type RowTuple interface {
	ValExpr
	// contains filtered or unexported methods
}

RowTuple represents a row of values. It can be ValTuple, Subquery.

type SQLName

type SQLName string

SQLName is an SQL identifier. It will be escaped with backquotes if it matches a keyword.

func (SQLName) Format

func (node SQLName) 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.

type Select

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

Select represents a SELECT statement.

func (*Select) Format

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

Format formats the node.

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

type SimpleTableExpr

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

SimpleTableExpr represents a simple table expression.

type StarExpr

type StarExpr struct {
	TableName SQLName
}

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

func (*StarExpr) Format

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

Format formats the node.

type Statement

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

Statement represents a statement.

func Parse

func Parse(sql string) (Statement, error)

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

type StrVal

type StrVal []byte

StrVal represents a string value.

func (StrVal) Format

func (node StrVal) 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 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 TableName

type TableName struct {
	Name, Qualifier SQLName
}

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

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

Format formats the node.

type Tokenizer

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

	Position int

	LastError string

	ParseTree Statement
	// contains filtered or unexported fields
}

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

func NewStringTokenizer

func NewStringTokenizer(sql string) *Tokenizer

NewStringTokenizer creates a new Tokenizer for the sql string.

func (*Tokenizer) Error

func (tkn *Tokenizer) Error(err string)

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

func (*Tokenizer) Lex

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

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

func (*Tokenizer) Scan

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

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

type TrackedBuffer

type TrackedBuffer struct {
	*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.

type TupleEqualityList

type TupleEqualityList struct {
	Columns []string
	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 byte
	Expr     Expr
}

UnaryExpr represents a unary value expression.

func (*UnaryExpr) Format

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

Format formats the node.

type Union

type Union struct {
	Type        string
	Left, Right SelectStatement
}

Union represents a UNION statement.

func (*Union) Format

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

Format formats the node.

type Update

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

Update represents an UPDATE statement.

func (*Update) Format

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

Format formats the node.

type UpdateExpr

type UpdateExpr struct {
	Name *ColName
	Expr ValExpr
}

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 ValArg

type ValArg []byte

ValArg represents a named bind var argument.

func (ValArg) Format

func (node ValArg) Format(buf *TrackedBuffer)

Format formats the node.

type ValExpr

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

ValExpr represents a value expression.

type ValExprs

type ValExprs []ValExpr

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

func (ValExprs) Format

func (node ValExprs) Format(buf *TrackedBuffer)

Format formats the node.

type ValTuple

type ValTuple ValExprs

ValTuple represents a tuple of actual values.

func (ValTuple) Format

func (node ValTuple) Format(buf *TrackedBuffer)

Format formats the node.

type Values

type Values []RowTuple

Values represents a VALUES clause.

func (Values) Format

func (node Values) Format(buf *TrackedBuffer)

Format formats the node.

type When

type When struct {
	Cond BoolExpr
	Val  ValExpr
}

When represents a WHEN sub-expression.

func (*When) Format

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

Format formats the node.

type Where

type Where struct {
	Type string
	Expr BoolExpr
}

Where represents a WHERE or HAVING clause.

func NewWhere

func NewWhere(typ string, expr BoolExpr) *Where

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

func (*Where) Format

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

Format formats the node.