sqlparser

type AccountName ¶ added in v0.1.0

type AccountName struct {
	User *SQLVal
	Host *SQLVal
}

AccountName is a user target in GRANT/REVOKE.

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

type AccountNames ¶ added in v0.1.0

type AccountNames []*AccountName

AccountNames represents a list of GRANT/REVOKE targets.

func (node AccountNames) Format(buf *TrackedBuffer)

type AliasedExpr ¶

type AliasedExpr struct {
	Expr Expr
	As   ColIdent
}

AliasedExpr defines an aliased SELECT expression.

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

type AliasedTableExpr ¶

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

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

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

func (node *AliasedTableExpr) RemoveHints() *AliasedTableExpr

type AndExpr ¶

type AndExpr struct {
	Left, Right Expr
}

AndExpr represents an AND expression.

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

type Begin ¶

type Begin struct{}

Begin represents a Begin statement.

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

type BinaryExpr ¶

type BinaryExpr struct {
	Operator    string
	Left, Right Expr
}

BinaryExpr represents a binary value expression.

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

type BoolVal ¶

type BoolVal bool

BoolVal is true or false.

func (node BoolVal) Format(buf *TrackedBuffer)

type CaseExpr ¶

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

CaseExpr represents a CASE expression.

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

type ColIdent ¶

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

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

func NewColIdent(str string) ColIdent

func (node ColIdent) CompliantName() string

func (node ColIdent) Equal(in ColIdent) bool

func (node ColIdent) EqualString(str string) bool

func (node ColIdent) Format(buf *TrackedBuffer)

func (node ColIdent) IsEmpty() bool

func (node ColIdent) Lowered() string

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

func (node ColIdent) String() string

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

type ColName ¶

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

ColName represents a column name.

func (node *ColName) Equal(c *ColName) bool

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

type ColTuple ¶

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

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

type CollateExpr ¶

type CollateExpr struct {
	Expr    Expr
	Charset string
}

CollateExpr represents dynamic collate operator.

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

type ColumnDefinition ¶

type ColumnDefinition struct {
	Name ColIdent
	Type ColumnType
}

ColumnDefinition describes a column in a CREATE TABLE statement

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

type ColumnKeyOption ¶

type ColumnKeyOption int

ColumnKeyOption indicates whether or not the given column is defined as an index element and contains the type of the option

type ColumnType ¶

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

	// Generic field options.
	NotNull       BoolVal
	Autoincrement BoolVal
	// Visibility is either "visible" or "invisible" when specified.
	Visibility    string
	Default       Expr
	OnUpdate      *SQLVal
	Comment       *SQLVal
	GeneratedExpr Expr
	// GeneratedStorage is either "virtual" or "stored" when specified.
	GeneratedStorage string

	// Numeric field options
	Length   *SQLVal
	Unsigned BoolVal
	Zerofill BoolVal
	Scale    *SQLVal
	// SRID is an optional spatial reference identifier for spatial column types.
	SRID *SQLVal

	// Text field options
	Charset string
	Collate string

	// Enum values
	EnumValues []string

	// Key specification
	KeyOpt ColumnKeyOption

	// Inline CHECK constraints for column-level checks.
	Checks []*ConstraintDefinition

	// Inline foreign key reference definition for column-level REFERENCES.
	Reference *ReferenceDefinition
}

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

func (ct *ColumnType) DescribeType() string

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

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

type Columns ¶

type Columns []ColIdent

Columns represents an insert column list.

func (node Columns) FindColumn(col ColIdent) int

func (node Columns) Format(buf *TrackedBuffer)

type CommentDirectives ¶

type CommentDirectives map[string]interface{}

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

func ExtractCommentDirectives(comments Comments) CommentDirectives

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

func (d CommentDirectives) IsSet(key string) bool

type Comments ¶

type Comments [][]byte

Comments represents a list of comments.

func (node Comments) Format(buf *TrackedBuffer)

type Commit ¶

type Commit struct{}

Commit represents a Commit statement.

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

type CommonTableExpr ¶ added in v0.1.0

type CommonTableExpr struct {
	ID       TableIdent
	Columns  Columns
	Subquery *Subquery
}

CommonTableExpr represents one common table expression.

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

type CommonTableExprs ¶ added in v0.1.0

type CommonTableExprs []*CommonTableExpr

CommonTableExprs is a list of common table expressions.

func (node CommonTableExprs) Format(buf *TrackedBuffer)

type ComparisonExpr ¶

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

ComparisonExpr represents a two-value comparison expression.

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

type ConstraintDefinition ¶ added in v0.1.0

type ConstraintDefinition struct {
	Name              ColIdent
	Expr              Expr
	ForeignKeyColumns Columns
	ReferencedTable   TableName
	ReferencedColumns Columns
	OnDeleteAction    string
	OnUpdateAction    string
}

ConstraintDefinition describes a table constraint in a CREATE TABLE statement.

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

type ConvertExpr ¶

type ConvertExpr struct {
	Expr Expr
	Type *ConvertType
}

ConvertExpr represents a call to CONVERT(expr, type) or it's equivalent CAST(expr AS type). Both are rewritten to the former.

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

type ConvertType ¶

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

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

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

type ConvertUsingExpr ¶

type ConvertUsingExpr struct {
	Expr Expr
	Type string
}

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

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

type DBDDL ¶

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

DBDDL represents a CREATE, DROP database statement.

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

type DDL ¶

type DDL struct {
	Action              string
	Temporary           bool
	IfNotExists         bool
	Table               TableName
	Tables              TableNames
	NewName             TableName
	IfExists            bool
	TableSpec           *TableSpec
	LikeTable           TableName
	OptSelect           SelectStatement
	PartitionSpec       *PartitionSpec
	AlterConstraint     *ConstraintDefinition
	AlterDropForeignKey ColIdent
	AlterIndex          *IndexDefinition
}

DDL represents a CREATE, ALTER, DROP, RENAME or TRUNCATE statement. Table is set for AlterStr, DropStr, RenameStr, TruncateStr NewName is set for AlterStr, CreateStr, RenameStr. Temporary is true for CREATE TEMPORARY TABLE statements. IfNotExists is true for CREATE TABLE IF NOT EXISTS statements. LikeTable is set for CREATE TABLE ... LIKE statements. OptSelect is set for CREATE TABLE ... AS SELECT statements. TableSpec is set for CREATE TABLE statements, and ALTER TABLE ... ADD (...) statements. AlterConstraint is set for ALTER TABLE ... ADD [CONSTRAINT name] CHECK (...) and ALTER TABLE ... ADD [CONSTRAINT name] FOREIGN KEY (...) REFERENCES ... statements. AlterDropForeignKey is set for ALTER TABLE ... DROP FOREIGN KEY <name> statements. AlterIndex is set for ALTER TABLE ... ADD UNIQUE [KEY|INDEX] [name] (...) statements.

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

type Default ¶

type Default struct {
	ColName string
}

Default represents a DEFAULT expression.

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

type Delete ¶

type Delete struct {
	With       *With
	Comments   Comments
	Targets    TableNames
	TableExprs TableExprs
	Partitions Partitions
	Where      *Where
	OrderBy    OrderBy
	Limit      *Limit
}

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

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

type DropRole ¶ added in v0.1.0

type DropRole struct {
	IfExists bool
	Roles    AccountNames
}

DropRole represents a DROP ROLE statement.

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

type DropUser ¶ added in v0.1.0

type DropUser struct {
	IfExists bool
	Users    AccountNames
}

DropUser represents a DROP USER statement.

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

type Encodable ¶

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

Encodable defines the interface for types that can be custom-encoded into SQL.

type Execute ¶ added in v0.1.0

type Execute struct {
	Name      TableIdent
	UsingVars ExecuteUsingVars
}

Execute represents an EXECUTE statement.

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

type ExecuteUsingVars ¶ added in v0.1.0

type ExecuteUsingVars []ColIdent

ExecuteUsingVars represents EXECUTE ... USING variable list.

func (node ExecuteUsingVars) Format(buf *TrackedBuffer)

type ExistsExpr ¶

type ExistsExpr struct {
	Subquery *Subquery
}

ExistsExpr represents an EXISTS expression.

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

type Expr ¶

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

Expr represents an expression.

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

func ReplaceExpr(root, from, to Expr) Expr

type Exprs ¶

type Exprs []Expr

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

func (node Exprs) Format(buf *TrackedBuffer)

type FuncExpr ¶

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

FuncExpr represents a function call.

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

func (node *FuncExpr) IsAggregate() bool

type Grant ¶ added in v0.1.0

type Grant struct {
	Privileges      Privileges
	PrivilegeObject *PrivilegeObject
	Targets         AccountNames
	WithGrantOption bool
}

Grant represents a GRANT statement.

Supported syntax is intentionally minimal: - GRANT <privileges> ON *.*|db.*|db.table TO <user targets> [WITH GRANT OPTION]

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

type GroupBy ¶

type GroupBy []Expr

GroupBy represents a GROUP BY clause.

func (node GroupBy) Format(buf *TrackedBuffer)

type GroupConcatExpr ¶

type GroupConcatExpr struct {
	Distinct  string
	Exprs     SelectExprs
	OrderBy   OrderBy
	Separator string
	Over      *OverClause
}

GroupConcatExpr represents a call to GROUP_CONCAT

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

type IndexColumn ¶

type IndexColumn struct {
	Column    ColIdent
	Length    *SQLVal
	Direction string
}

IndexColumn describes a column in an index definition with optional length

type IndexDefinition ¶

type IndexDefinition struct {
	Info    *IndexInfo
	Columns []*IndexColumn
	Options []*IndexOption
}

IndexDefinition describes an index in a CREATE TABLE statement

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

type IndexHints ¶

type IndexHints struct {
	Type    string
	Indexes []ColIdent
}

IndexHints represents a list of index hints.

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

type IndexInfo ¶

type IndexInfo struct {
	Type    string
	Name    ColIdent
	Primary bool
	Spatial bool
	Unique  bool
}

IndexInfo describes the name and type of an index in a CREATE TABLE statement

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

type IndexOption ¶

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

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

type Insert ¶

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

Insert represents an INSERT or REPLACE statement. Per the MySQL docs, http://dev.mysql.com/doc/refman/5.7/en/replace.html Replace is the counterpart to `INSERT IGNORE`, and works exactly like a normal INSERT except if the row exists. In that case it first deletes the row and re-inserts with new values. For that reason we keep it as an Insert struct. If you add fields here, consider adding them to calls to validateSubquerySamePlan.

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

type InsertRows ¶

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

InsertRows represents the rows for an INSERT statement.

type InsertValues ¶

type InsertValues [][]sqltypes.Value

InsertValues is a custom SQL encoder for the values of an insert statement.

func (iv InsertValues) EncodeSQL(buf *bytes.Buffer)

type IntervalExpr ¶

type IntervalExpr struct {
	Expr Expr
	Unit string
}

IntervalExpr represents a date-time INTERVAL expression.

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

type IsExpr ¶

type IsExpr struct {
	Operator string
	Expr     Expr
}

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

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

type JSONTableColumn ¶ added in v0.1.0

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

JSONTableColumn represents a JSON_TABLE COLUMNS(...) entry.

type JSONTableColumns ¶ added in v0.1.0

type JSONTableColumns []JSONTableColumn

JSONTableColumns represents the list of JSON_TABLE column definitions.

func (node JSONTableColumns) Format(buf *TrackedBuffer)

type JSONTableExpr ¶ added in v0.1.0

type JSONTableExpr struct {
	Expr    Expr
	Path    *SQLVal
	Columns JSONTableColumns
}

JSONTableExpr represents a JSON_TABLE table-valued function in FROM clauses. Supported column forms are intentionally limited to: - name FOR ORDINALITY - name <type> PATH '<jsonpath>' - name <type> EXISTS PATH '<jsonpath>' - NESTED PATH '<jsonpath>' COLUMNS (...)

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

type JSONTableNestedPathColumn ¶ added in v0.1.0

type JSONTableNestedPathColumn struct {
	Path    *SQLVal
	Columns JSONTableColumns
}

JSONTableNestedPathColumn represents `NESTED PATH ... COLUMNS (...)`.

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

type JSONTableOrdinalityColumn ¶ added in v0.1.0

type JSONTableOrdinalityColumn struct {
	Name ColIdent
}

JSONTableOrdinalityColumn represents `name FOR ORDINALITY`.

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

type JSONTablePathColumn ¶ added in v0.1.0

type JSONTablePathColumn struct {
	Name   ColIdent
	Type   ColumnType
	Exists bool
	Path   *SQLVal
}

JSONTablePathColumn represents typed PATH and EXISTS PATH columns.

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

type JoinCondition ¶

type JoinCondition struct {
	On    Expr
	Using Columns
}

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

func (node JoinCondition) Format(buf *TrackedBuffer)

type JoinTableExpr ¶

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

JoinTableExpr represents a TableExpr that's a JOIN operation.

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

type LengthScaleOption ¶

type LengthScaleOption struct {
	Length *SQLVal
	Scale  *SQLVal
}

LengthScaleOption is used for types that have an optional length and scale

type Limit ¶

type Limit struct {
	Offset, Rowcount Expr
}

Limit represents a LIMIT clause.

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

type ListArg ¶

type ListArg []byte

ListArg represents a named list argument.

func (node ListArg) Format(buf *TrackedBuffer)

type LockTables ¶ added in v0.1.0

type LockTables struct {
	Tables TableLocks
}

LockTables represents a LOCK TABLE[S] statement.

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

type MarginComments ¶

type MarginComments struct {
	Leading  string
	Trailing string
}

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

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

type MatchExpr ¶

type MatchExpr struct {
	Columns SelectExprs
	Expr    Expr
	Option  string
}

MatchExpr represents a call to the MATCH function

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

type NodeFormatter ¶

type NodeFormatter func(buf *TrackedBuffer, node SQLNode)

NodeFormatter defines the signature of a custom node formatter function that can be given to TrackedBuffer for code generation.

type NotExpr ¶

type NotExpr struct {
	Expr Expr
}

NotExpr represents a NOT expression.

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

type NullVal ¶

type NullVal struct{}

NullVal represents a NULL value.

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

type OnDup ¶

type OnDup UpdateExprs

OnDup represents an ON DUPLICATE KEY clause.

func (node OnDup) Format(buf *TrackedBuffer)

type OrExpr ¶

type OrExpr struct {
	Left, Right Expr
}

OrExpr represents an OR expression.

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

type Order ¶

type Order struct {
	Expr      Expr
	Direction string
}

Order represents an ordering expression.

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

type OrderBy ¶

type OrderBy []*Order

OrderBy represents an ORDER By clause.

func (node OrderBy) Format(buf *TrackedBuffer)

type OtherAdmin ¶

type OtherAdmin struct{}

OtherAdmin represents a misc statement that relies on ADMIN privileges, such as REPAIR, OPTIMIZE, or TRUNCATE statement. It should be used only as an indicator. It does not contain the full AST for the statement.

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

type OtherRead ¶

type OtherRead struct{}

OtherRead represents a DESCRIBE, or EXPLAIN statement. It should be used only as an indicator. It does not contain the full AST for the statement.

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

type OverClause ¶ added in v0.1.0

type OverClause struct {
	Name ColIdent
	Spec *WindowSpec
}

OverClause describes an OVER clause attached to a function expression.

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

type ParenExpr ¶

type ParenExpr struct {
	Expr Expr
}

ParenExpr represents a parenthesized boolean expression.

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

type ParenSelect ¶

type ParenSelect struct {
	Select SelectStatement
}

ParenSelect is a parenthesized SELECT statement.

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

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

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

type ParenTableExpr ¶

type ParenTableExpr struct {
	Exprs TableExprs
}

ParenTableExpr represents a parenthesized list of TableExpr.

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

type ParsedQuery ¶

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

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

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

func NewParsedQuery(node SQLNode) *ParsedQuery

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

type PartitionDefinition ¶

type PartitionDefinition struct {
	Name     ColIdent
	Limit    Expr
	Maxvalue bool
	Engine   ColIdent
}

PartitionDefinition describes a very minimal partition definition

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

type PartitionSpec ¶

type PartitionSpec struct {
	Action      string
	Name        ColIdent
	Names       Partitions
	All         bool
	Number      string
	Table       TableName
	Validation  string
	Expr        Expr
	IsLinear    bool
	IsColumns   bool
	ColumnList  Columns
	Definitions []*PartitionDefinition
}

PartitionSpec describe partition actions (for alter and create)

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

type Partitions ¶

type Partitions Columns

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

func (node Partitions) Format(buf *TrackedBuffer)

type Prepare ¶ added in v0.1.0

type Prepare struct {
	Name   TableIdent
	Source Expr
}

Prepare represents a PREPARE statement.

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

type Privilege ¶ added in v0.1.0

type Privilege string

Privilege represents a privilege keyword in GRANT/REVOKE.

func (node Privilege) Format(buf *TrackedBuffer)

type PrivilegeObject ¶ added in v0.1.0

type PrivilegeObject struct {
	Global    bool
	DBName    TableIdent
	TableName TableName
}

PrivilegeObject is the ON target in GRANT/REVOKE.

Exactly one variant is expected: - Global: *.* - DBName: db.* - TableName: db.table or table

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

type Privileges ¶ added in v0.1.0

type Privileges []Privilege

Privileges represents a list of privileges.

func (node Privileges) Format(buf *TrackedBuffer)

type RangeCond ¶

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

RangeCond represents a BETWEEN or a NOT BETWEEN expression.

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

type ReferenceDefinition ¶ added in v0.1.0

type ReferenceDefinition struct {
	ReferencedTable   TableName
	ReferencedColumns Columns
	OnDeleteAction    string
	OnUpdateAction    string
}

ReferenceDefinition describes a REFERENCES clause.

func (rd *ReferenceDefinition) Format(buf *TrackedBuffer)

type Revoke ¶ added in v0.1.0

type Revoke struct {
	GrantOptionFor  bool
	Privileges      Privileges
	PrivilegeObject *PrivilegeObject
	Targets         AccountNames
}

Revoke represents a REVOKE statement.

Supported syntax is intentionally minimal: - REVOKE [GRANT OPTION FOR] <privileges> ON *.*|db.*|db.table FROM <user targets>

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

type Rollback ¶

type Rollback struct{}

Rollback represents a Rollback statement.

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

type SQLNode ¶

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

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

type SQLVal ¶

type SQLVal struct {
	Type ValType
	Val  []byte
}

SQLVal represents a single value.

func NewBitVal(in []byte) *SQLVal

func NewBoolVal(in bool) *SQLVal

func NewFloatVal(in []byte) *SQLVal

func NewHexNum(in []byte) *SQLVal

func NewHexVal(in []byte) *SQLVal

func NewIntVal(in []byte) *SQLVal

func NewStrVal(in []byte) *SQLVal

func NewValArg(in []byte) *SQLVal

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

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

type Select ¶

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

Select represents a SELECT statement.

func (node *Select) AddHaving(expr Expr)

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

func (node *Select) AddWhere(expr Expr)

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

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

type SelectExpr ¶

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

SelectExpr represents a SELECT expression.

type SelectExprs ¶

type SelectExprs []SelectExpr

SelectExprs represents SELECT expressions.

func (node SelectExprs) Format(buf *TrackedBuffer)

type SelectIntoVars ¶ added in v0.1.0

type SelectIntoVars []ColIdent

SelectIntoVars represents a SELECT ... INTO user variable target list.

func (node SelectIntoVars) Format(buf *TrackedBuffer)

type SelectStatement ¶

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

SelectStatement any SELECT statement.

type Set ¶

type Set struct {
	Comments Comments
	Exprs    SetExprs
	Scope    string
}

Set represents a SET statement.

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

type SetExpr ¶

type SetExpr struct {
	Name ColIdent
	Expr Expr
}

SetExpr represents a set expression.

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

type SetExprs ¶

type SetExprs []*SetExpr

SetExprs represents a list of set expressions.

func (node SetExprs) Format(buf *TrackedBuffer)

type SetKey ¶

type SetKey struct {
	Key   string
	Scope string
}

SetKey is the extracted key from one SetExpr

type Show ¶

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

Show represents a show statement.

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

func (node *Show) HasOnTable() bool

type ShowFilter ¶

type ShowFilter struct {
	Like   string
	Filter Expr
}

ShowFilter is show tables filter

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

type ShowTablesOpt ¶

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

ShowTablesOpt is show tables option

type SimpleTableExpr ¶

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

SimpleTableExpr represents a simple table expression.

type StarExpr ¶

type StarExpr struct {
	TableName TableName
}

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

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

type Statement ¶

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

Statement represents a statement.

func Parse(sql string) (Statement, error)

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

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

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

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

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

type Subquery ¶

type Subquery struct {
	Select SelectStatement
}

Subquery represents a subquery.

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

type SubstrExpr ¶

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

SubstrExpr represents a call to SubstrExpr(column, value_expression) or SubstrExpr(column, value_expression,value_expression) also supported syntax SubstrExpr(column from value_expression for value_expression)

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

type TableExpr ¶

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

TableExpr represents a table expression.

type TableExprs ¶

type TableExprs []TableExpr

TableExprs represents a list of table expressions.

func (node TableExprs) Format(buf *TrackedBuffer)

type TableIdent ¶

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

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

func GetTableName(node SimpleTableExpr) TableIdent

func NewTableIdent(str string) TableIdent

func (node TableIdent) CompliantName() string

func (node TableIdent) Format(buf *TrackedBuffer)

func (node TableIdent) IsEmpty() bool

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

func (node TableIdent) String() string

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

type TableLock ¶ added in v0.1.0

type TableLock struct {
	Table TableName
	Alias TableIdent
	Lock  string
}

TableLock represents one table lock target and lock mode.

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

type TableLocks ¶ added in v0.1.0

type TableLocks []*TableLock

TableLocks is a list of table locks in a LOCK TABLES statement.

func (node TableLocks) Format(buf *TrackedBuffer)

type TableName ¶

type TableName struct {
	Name, Qualifier TableIdent
}

TableName represents a table name. Qualifier, if specified, represents a database. TableName is a value struct whose fields are case sensitive. This means two TableName vars can be compared for equality and a TableName can also be used as key in a map.

func (node TableName) Format(buf *TrackedBuffer)

func (node TableName) IsEmpty() bool

func (node TableName) ToViewName() TableName

type TableNames ¶

type TableNames []TableName

TableNames is a list of TableName.

func (node TableNames) Format(buf *TrackedBuffer)

type TableSpec ¶

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

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

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

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

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

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

type Tokenizer ¶

type Tokenizer struct {
	InStream      io.Reader
	AllowComments bool
	ForceEOF      bool

	Position int

	LastError error

	ParseTree Statement
	// contains filtered or unexported fields
}

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

func NewStringTokenizer(sql string) *Tokenizer

func NewTokenizer(r io.Reader) *Tokenizer

func (tkn *Tokenizer) Error(err string)

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

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

type TrackedBuffer ¶

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

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

func NewTrackedBuffer(nodeFormatter NodeFormatter) *TrackedBuffer

func (buf *TrackedBuffer) HasBindVars() bool

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

func (buf *TrackedBuffer) ParsedQuery() *ParsedQuery

func (buf *TrackedBuffer) WriteArg(arg string)

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

type TriggerDDL ¶ added in v0.1.2

type TriggerDDL struct {
	Action   string
	Name     TableName
	IfExists bool
}

TriggerDDL represents a CREATE or DROP trigger statement.

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

type TupleEqualityList ¶

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

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

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

type UnaryExpr ¶

type UnaryExpr struct {
	Operator string
	Expr     Expr
}

UnaryExpr represents a unary value expression.

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

type Union ¶

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

Union represents a set operation query expression.

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

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

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

type UnlockTables ¶ added in v0.1.0

type UnlockTables struct{}

UnlockTables represents an UNLOCK TABLE[S] statement.

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

type Update ¶

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

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

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

type UpdateExpr ¶

type UpdateExpr struct {
	Name *ColName
	Expr Expr
}

UpdateExpr represents an update expression.

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

type UpdateExprs ¶

type UpdateExprs []*UpdateExpr

UpdateExprs represents a list of update expressions.

func (node UpdateExprs) Format(buf *TrackedBuffer)

type Use ¶

type Use struct {
	DBName TableIdent
}

Use represents a use statement.

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

type ValTuple ¶

type ValTuple Exprs

ValTuple represents a tuple of actual values.

func (node ValTuple) Format(buf *TrackedBuffer)

type ValType ¶

type ValType int

ValType specifies the type for SQLVal.

type Values ¶

type Values []ValTuple

Values represents a VALUES clause.

func (node Values) Format(buf *TrackedBuffer)

type ValuesFuncExpr ¶

type ValuesFuncExpr struct {
	Name *ColName
}

ValuesFuncExpr represents a function call.

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

type ValuesStatement ¶ added in v0.1.0

type ValuesStatement struct {
	Rows Values
}

ValuesStatement represents a top-level VALUES statement.

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

type Visit ¶

type Visit func(node SQLNode) (kontinue bool, err error)

Visit defines the signature of a function that can be used to visit all nodes of a parse tree.

type When ¶

type When struct {
	Cond Expr
	Val  Expr
}

When represents a WHEN sub-expression.

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

type Where ¶

type Where struct {
	Type string
	Expr Expr
}

Where represents a WHERE or HAVING clause.

func NewWhere(typ string, expr Expr) *Where

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

type WindowDefinition ¶ added in v0.1.0

type WindowDefinition struct {
	Name ColIdent
	Spec *WindowSpec
}

WindowDefinition describes a named window in a WINDOW clause.

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

type WindowDefinitions ¶ added in v0.1.0

type WindowDefinitions []*WindowDefinition

WindowDefinitions represents the WINDOW clause in a SELECT statement.

func (node WindowDefinitions) Format(buf *TrackedBuffer)

type WindowFrame ¶ added in v0.1.0

type WindowFrame struct {
	Unit  string
	Start *WindowFrameBound
	End   *WindowFrameBound
}

WindowFrame describes a frame clause in a window specification.

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

type WindowFrameBound ¶ added in v0.1.0

type WindowFrameBound struct {
	Type string
	Expr Expr
}

WindowFrameBound describes one frame bound in a frame clause.

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

type WindowSpec ¶ added in v0.1.0

type WindowSpec struct {
	Name        ColIdent
	PartitionBy Exprs
	OrderBy     OrderBy
	Frame       *WindowFrame
}

WindowSpec describes a window specification used by OVER(...) or WINDOW.

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

type With ¶ added in v0.1.0

type With struct {
	Recursive bool
	Ctes      CommonTableExprs
}

With represents a WITH clause.

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