sqlparser

package
v2.0.0-rc.1+incompatible Latest Latest
Warning

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

 Go to latest Published: Jun 7, 2016 License: BSD-3-Clause Imports: 7 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 (
	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 (
	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"
)

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

BinaryExpr.Operator

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

UnaryExpr.Operator

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

Order.Direction

View Source 
const ALL = 57360
View Source 
const ALTER = 57418
View Source 
const ANALYZE = 57421
View Source 
const AND = 57397
View Source 
const AS = 57362
View Source 
const ASC = 57364
View Source 
const BETWEEN = 57399
View Source 
const BY = 57357
View Source 
const CASE = 57400
View Source 
const COMMENT = 57392
View Source 
const CREATE = 57417
View Source 
const CROSS = 57382
View Source 
const DEFAULT = 57369
View Source 
const DELETE = 57351
View Source 
const DESC = 57365
View Source 
const DESCRIBE = 57431
View Source 
const DISTINCT = 57361
View Source 
const DROP = 57419
View Source 
const DUPLICATE = 57367
View Source 
const ELSE = 57403
View Source 
const END = 57416
View Source 
const EXISTS = 57363
View Source 
const EXPLAIN = 57432
View Source 
const FALSE = 57395
View Source 
const FOR = 57359
View Source 
const FORCE = 57385
View Source 
const FROM = 57352
View Source 
const GE = 57405
View Source 
const GROUP = 57354
View Source 
const HAVING = 57355
View Source 
const ID = 57387
View Source 
const IF = 57427
View Source 
const IGNORE = 57426
View Source 
const IN = 57411
View Source 
const INDEX = 57423
View Source 
const INNER = 57380
View Source 
const INSERT = 57349
View Source 
const INTERVAL = 57415
View Source 
const INTO = 57366
View Source 
const IS = 57408
View Source 
const JOIN = 57376
View Source 
const KEY = 57368
View Source 
const LAST_INSERT_ID = 57373
View Source 
const LE = 57404
View Source 
const LEFT = 57378
View Source 
const LEX_ERROR = 57346
View Source 
const LIKE = 57409
View Source 
const LIMIT = 57358
View Source 
const LIST_ARG = 57391
View Source 
const LOCK = 57371
View Source 
const NATURAL = 57383
View Source 
const NE = 57406
View Source 
const NEXT = 57374
View Source 
const NOT = 57398
View Source 
const NULL = 57393
View Source 
const NULL_SAFE_EQUAL = 57407
View Source 
const NUMBER = 57389
View Source 
const ON = 57386
View Source 
const OR = 57396
View Source 
const ORDER = 57356
View Source 
const OUTER = 57381
View Source 
const REGEXP = 57410
View Source 
const RENAME = 57420
View Source 
const RIGHT = 57379
View Source 
const SELECT = 57348
View Source 
const SET = 57370
View Source 
const SHIFT_LEFT = 57412
View Source 
const SHIFT_RIGHT = 57413
View Source 
const SHOW = 57430
View Source 
const STRAIGHT_JOIN = 57377
View Source 
const STRING = 57388
View Source 
const TABLE = 57422
View Source 
const THEN = 57402
View Source 
const TO = 57425
View Source 
const TRUE = 57394
View Source 
const UNARY = 57414
View Source 
const UNION = 57347
View Source 
const UNIQUE = 57428
View Source 
const UNUSED = 57433
View Source 
const UPDATE = 57350
View Source 
const USE = 57384
View Source 
const USING = 57429
View Source 
const VALUE = 57375
View Source 
const VALUES = 57372
View Source 
const VALUE_ARG = 57390
View Source 
const VIEW = 57424
View Source 
const WHEN = 57401
View Source 
const WHERE = 57353

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

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

func (BoolVal) WalkSubtree 

func (node BoolVal) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree

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.

func (*CaseExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree

type ColIdent 

type ColIdent cistring.CIString

ColIdent is a case insensitive SQL identifier. It will be escaped with backquotes if it matches a keyword.

func NewColIdent 

func NewColIdent(str string) ColIdent

NewColIdent makes a new ColIdent.

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

func (node ColIdent) Original() string

Original returns the case-preserved column name.

func (ColIdent) String 

func (node ColIdent) String() string

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) 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 {
	ValExpr
	// contains filtered or unexported methods
}

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

type Columns 

type Columns []ColIdent

Columns represents an insert column list.

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

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 DDL 

type DDL struct {
	Action  string
	Table   TableIdent
	NewName TableIdent
}

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

func (*FuncExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree

type GroupBy 

type GroupBy []ValExpr

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

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

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 Nextval 

type Nextval struct{}

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

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 NumVal 

type NumVal []byte

NumVal represents a number.

func (NumVal) Format 

func (node NumVal) Format(buf *TrackedBuffer)

Format formats the node.

func (NumVal) WalkSubtree 

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

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

func (*Other) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree

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.

func (*ParenBoolExpr) WalkSubtree 

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

func (*RangeCond) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree

type RowTuple 

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

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

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 Select 

type Select struct {
	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 BoolExpr)

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

func (node *Select) AddWhere(expr BoolExpr)

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) 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 {
	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 SimpleTableExpr 

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

SimpleTableExpr represents a simple table expression.

type StarExpr 

type StarExpr struct {
	TableName TableIdent
}

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 StrVal 

type StrVal []byte

StrVal represents a string value.

func (StrVal) Format 

func (node StrVal) Format(buf *TrackedBuffer)

Format formats the node.

func (StrVal) WalkSubtree 

func (node StrVal) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree

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 string

TableIdent is a case sensitive SQL identifier. It will be escaped with backquotes if it matches a keyword.

func (TableIdent) Format 

func (node TableIdent) Format(buf *TrackedBuffer)

Format formats the node.

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

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.

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
}

Union represents a UNION statement.

func (*Union) Format 

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

Format formats the node.

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

func (*Update) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree

type UpdateExpr 

type UpdateExpr struct {
	Name ColIdent
	Expr ValExpr
}

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 ValArg 

type ValArg []byte

ValArg represents a named bind var argument.

func (ValArg) Format 

func (node ValArg) Format(buf *TrackedBuffer)

Format formats the node.

func (ValArg) WalkSubtree 

func (node ValArg) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree

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.

func (ValExprs) WalkSubtree 

func (node ValExprs) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree

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.

func (ValTuple) WalkSubtree 

func (node ValTuple) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree

type Values 

type Values []RowTuple

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 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 BoolExpr
	Val  ValExpr
}

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

func (*Where) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.