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 ForceEOF(yylex interface{})
- func GetColName(node Expr) string
- func GetTableName(node SimpleTableExpr) string
- func HasINClause(conditions []BoolExpr) bool
- func IsColName(node ValExpr) bool
- func IsSimpleTuple(node ValExpr) bool
- func IsValue(node ValExpr) bool
- func Rewrite(node SQLNode, rewriter Rewriter)
- func SetAllowComments(yylex interface{}, allow bool)
- func SetParseTree(yylex interface{}, stmt Statement)
- func String(node SQLNode) string
- func StringIn(str string, values ...string) bool
- type AliasedTableExpr
- type AndExpr
- type BinaryExpr
- type BoolExpr
- type CaseExpr
- type ColName
- type ColTuple
- type ColumnAtts
- type ColumnDefinition
- type ColumnDefinitions
- type Columns
- type Comments
- type ComparisonExpr
- type CreateTable
- type DDL
- type Delete
- type EncoderFunc
- type ExistsExpr
- type Expr
- type FuncExpr
- type GroupBy
- type IndexHints
- type Insert
- type InsertRows
- type JoinTableExpr
- type Limit
- type ListArg
- type NonStarExpr
- type NotExpr
- type NullCheck
- type NullVal
- type NumVal
- type OnDup
- type OrExpr
- type Order
- type OrderBy
- type Other
- type ParenBoolExpr
- type ParenTableExpr
- type ParsedQuery
- type RangeCond
- type Rewriter
- type RowTuple
- type SQLNode
- type Select
- type SelectExpr
- type SelectExprs
- type SelectStatement
- type Set
- type SimpleTableExpr
- type StarExpr
- type Statement
- type StrVal
- type Subquery
- type TableExpr
- type TableExprs
- type TableName
- type Tokenizer
- type TrackedBuffer
- type TupleEqualityList
- type UnaryExpr
- type Union
- type Update
- type UpdateExpr
- type UpdateExprs
- type ValArg
- type ValExpr
- type ValExprs
- type ValTuple
- type Values
- type When
- type Where
Constants ¶
const ( AST_FOR_UPDATE = " for update" AST_SHARE_MODE = " lock in share mode" )
Select.Lock
const ( AST_UNION = "union" AST_UNION_ALL = "union all" AST_SET_MINUS = "minus" AST_EXCEPT = "except" AST_INTERSECT = "intersect" )
Union.Type
const ( AST_TABLE = "table" AST_VIEW = "view" )
const ( AST_CREATE = "create" AST_ALTER = "alter" AST_DROP = "drop" AST_RENAME = "rename" )
const ( AST_JOIN = "join" AST_STRAIGHT_JOIN = "straight_join" AST_LEFT_JOIN = "left join" AST_RIGHT_JOIN = "right join" AST_CROSS_JOIN = "cross join" AST_NATURAL_JOIN = "natural join" )
JoinTableExpr.Join
const ( AST_USE = "use" AST_IGNORE = "ignore" AST_FORCE = "force" )
const ( AST_WHERE = "where" AST_HAVING = "having" )
Where.Type
const ( AST_EQ = "=" AST_LT = "<" AST_GT = ">" AST_LE = "<=" AST_GE = ">=" AST_NE = "!=" AST_NSE = "<=>" AST_IN = "in" AST_NOT_IN = "not in" AST_LIKE = "like" AST_NOT_LIKE = "not like" AST_REGEXP = "regexp" AST_NOT_REGEXP = "not regexp" AST_HAS_WORDS = "has_words" AST_HAS_CSV_WORD = "has_csv_word" )
ComparisonExpr.Operator
const ( AST_BETWEEN = "between" AST_NOT_BETWEEN = "not between" )
RangeCond.Operator
const ( AST_IS_NULL = "is null" AST_IS_NOT_NULL = "is not null" )
NullCheck.Operator
const ( AST_BITAND = '&' AST_BITOR = '|' AST_BITXOR = '^' AST_PLUS = '+' AST_MINUS = '-' AST_MULT = '*' AST_DIV = '/' AST_MOD = '%' )
BinaryExpr.Operator
const ( AST_UPLUS = '+' AST_UMINUS = '-' AST_TILDA = '~' )
UnaryExpr.Operator
const ( AST_ASC = "asc" AST_DESC = "desc" )
Order.Direction
const ( //other keywords AST_UNSIGNED = "unsigned" AST_ZEROFILL = "zerofill" //datatypes AST_BIT = "bit" AST_TINYINT = "tinyint" AST_SMALLINT = "smallint" AST_MEDIUMINT = "mediumint" AST_INT = "int" AST_INTEGER = "integer" AST_BIGINT = "bigint" AST_REAL = "real" AST_DOUBLE = "double" AST_FLOAT = "float" AST_DECIMAL = "decimal" AST_NUMERIC = "numeric" AST_CHAR = "char" AST_VARCHAR = "varchar" AST_TEXT = "text" AST_DATE = "date" AST_TIME = "time" AST_TIMESTAMP = "timestamp" AST_DATETIME = "datetime" AST_YEAR = "year" AST_PRIMARY_KEY = "primary key" AST_UNIQUE_KEY = "unique key" AST_AUTO_INCREMENT = "auto_increment" AST_NOT_NULL = "not null" AST_DEFAULT = "default" AST_KEY = "key" )
const ALL = 57359
const ALTER = 57417
const ANALYZE = 57420
const AND = 57408
const APPROXNUM = 57456
const AS = 57361
const ASC = 57369
const (
AST_DISTINCT = "distinct "
)
Select.Distinct
const AUTO_INCREMENT = 57454
const BETWEEN = 57367
const BIGINT = 57437
const BIT = 57431
const BOOL = 57455
const BY = 57356
const CASE = 57411
const CHAR = 57451
const COMMENT = 57385
const CREATE = 57416
const CROSS = 57402
const DATE = 57445
const DATETIME = 57448
const DECIMAL = 57443
const DEFAULT = 57375
const DELETE = 57350
const DESC = 57370
const DESCRIBE = 57429
const DISTINCT = 57360
const DOUBLE = 57439
const DROP = 57418
const DUPLICATE = 57373
const ELSE = 57414
const END = 57415
const EOFCHAR = 0x100
const EXCEPT = 57394
const EXISTS = 57362
const EXPLAIN = 57430
const FLOAT = 57440
const FOR = 57358
const FORCE = 57405
const FROM = 57351
const GE = 57387
const GROUP = 57353
const HAS_CSV_WORD = 57379
const HAS_WORDS = 57378
const HAVING = 57354
const ID = 57380
const IF = 57426
const IGNORE = 57425
const IN = 57363
const INDEX = 57422
const INNER = 57400
const INSERT = 57348
const INT = 57435
const INTEGER = 57436
const INTERSECT = 57395
const INTNUM = 57457
const INTO = 57372
const IS = 57364
const JOIN = 57396
const KEY = 57374
const LE = 57386
const LEFT = 57398
const LEX_ERROR = 57346
const LIKE = 57365
const LIMIT = 57357
const LIST_ARG = 57384
const LOCK = 57377
const MEDIUMINT = 57434
const MINUS = 57393
const NATURAL = 57403
const NE = 57388
const NOT = 57409
const NULL = 57368
const NULLX = 57453
const NULL_SAFE_EQUAL = 57389
const NUMBER = 57382
const NUMERIC = 57444
const ON = 57406
const OR = 57407
const ORDER = 57355
const OUTER = 57401
const PRIMARY = 57390
const REAL = 57438
const REGEXP = 57366
const RENAME = 57419
const RIGHT = 57399
const SELECT = 57347
const SET = 57376
const SHOW = 57428
const SMALLINT = 57433
const STRAIGHT_JOIN = 57397
const STRING = 57381
const TABLE = 57421
const TEXT = 57450
const THEN = 57413
const TIME = 57446
const TIMESTAMP = 57447
const TINYINT = 57432
const TO = 57424
const UNARY = 57410
const UNION = 57392
const UNIQUE = 57391
const UNSIGNED = 57441
const UPDATE = 57349
const USE = 57404
const USING = 57427
const VALUES = 57371
const VALUE_ARG = 57383
const VARCHAR = 57452
const VIEW = 57423
const WHEN = 57412
const WHERE = 57352
const YEAR = 57449
const ZEROFILL = 57442
Variables ¶
var ( SHARE = []byte("share") MODE = []byte("mode") IF_BYTES = []byte("if") VALUES_BYTES = []byte("values") )
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 ¶
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 FetchBindVar ¶
func GetColName ¶
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 ¶
HasINCaluse returns true if any of the conditions has an IN clause.
func IsSimpleTuple ¶
IsSimpleTuple returns true if the ValExpr is a ValTuple that contains simple values or if it's a list arg.
func IsValue ¶
IsValue returns true if the ValExpr is a string, number or value arg. NULL is not considered to be a value.
func SetAllowComments ¶
func SetAllowComments(yylex interface{}, allow bool)
func SetParseTree ¶
func SetParseTree(yylex interface{}, stmt Statement)
Types ¶
type AliasedTableExpr ¶
type AliasedTableExpr struct { Expr SimpleTableExpr As []byte Hints *IndexHints }
AliasedTableExpr represents a table expression coupled with an optional alias or index hint.
func (*AliasedTableExpr) Format ¶
func (node *AliasedTableExpr) Format(buf *TrackedBuffer)
func (*AliasedTableExpr) ITableExpr ¶
func (*AliasedTableExpr) ITableExpr()
type AndExpr ¶
type AndExpr struct {
Left, Right BoolExpr
}
AndExpr represents an AND expression.
func (*AndExpr) Format ¶
func (node *AndExpr) Format(buf *TrackedBuffer)
type BinaryExpr ¶
BinaryExpr represents a binary value expression.
func (*BinaryExpr) Format ¶
func (node *BinaryExpr) Format(buf *TrackedBuffer)
func (*BinaryExpr) IExpr ¶
func (*BinaryExpr) IExpr()
func (*BinaryExpr) IValExpr ¶
func (*BinaryExpr) IValExpr()
type BoolExpr ¶
type BoolExpr interface { IBoolExpr() Expr }
BoolExpr represents a boolean expression.
type CaseExpr ¶
CaseExpr represents a CASE expression.
func (*CaseExpr) Format ¶
func (node *CaseExpr) Format(buf *TrackedBuffer)
type ColName ¶
type ColName struct {
Name, Qualifier []byte
}
ColName represents a column name.
func (*ColName) Format ¶
func (node *ColName) Format(buf *TrackedBuffer)
type ColTuple ¶
type ColTuple interface { IColTuple() ValExpr }
ColTuple represents a list of column values. It can be ValTuple, Subquery, ListArg.
type ColumnAtts ¶
type ColumnAtts []string
func (ColumnAtts) Format ¶
func (node ColumnAtts) Format(buf *TrackedBuffer)
type ColumnDefinition ¶
type ColumnDefinition struct { ColName string ColType string ColumnAtts ColumnAtts }
func GetColumnByName ¶
func GetColumnByName(sqlNode SQLNode, name string) (*ColumnDefinition, error)
Get ColumnDefinition by name, sqlNode must be a CreateTable struct
func GetPrimaryKey ¶
func GetPrimaryKey(sqlNode SQLNode) (*ColumnDefinition, error)
Get the primary key ColumnDefinition of the table, sqlNode must be a CreateTable struct
func (ColumnDefinition) Format ¶
func (node ColumnDefinition) Format(buf *TrackedBuffer)
type ColumnDefinitions ¶
type ColumnDefinitions []*ColumnDefinition
func (ColumnDefinitions) Format ¶
func (node ColumnDefinitions) Format(buf *TrackedBuffer)
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)
type Comments ¶
type Comments [][]byte
Comments represents a list of comments.
func (Comments) Format ¶
func (node Comments) Format(buf *TrackedBuffer)
type ComparisonExpr ¶
ComparisonExpr represents a two-value comparison expression.
func (*ComparisonExpr) Format ¶
func (node *ComparisonExpr) Format(buf *TrackedBuffer)
func (*ComparisonExpr) IBoolExpr ¶
func (*ComparisonExpr) IBoolExpr()
func (*ComparisonExpr) IExpr ¶
func (*ComparisonExpr) IExpr()
type CreateTable ¶
type CreateTable struct { Name []byte ColumnDefinitions ColumnDefinitions }
func (*CreateTable) Format ¶
func (node *CreateTable) Format(buf *TrackedBuffer)
func (*CreateTable) IStatement ¶
func (node *CreateTable) IStatement()
type DDL ¶
DDL represents a CREATE, ALTER, DROP or RENAME statement. Table is set for AST_ALTER, AST_DROP, AST_RENAME. NewName is set for AST_ALTER, AST_CREATE, AST_RENAME.
func (*DDL) Format ¶
func (node *DDL) Format(buf *TrackedBuffer)
func (*DDL) IStatement ¶
func (*DDL) IStatement()
type Delete ¶
Delete represents a DELETE statement.
func (*Delete) Format ¶
func (node *Delete) Format(buf *TrackedBuffer)
func (*Delete) IStatement ¶
func (*Delete) IStatement()
type EncoderFunc ¶
type ExistsExpr ¶
type ExistsExpr struct {
Subquery *Subquery
}
ExistsExpr represents an EXISTS expression.
func (*ExistsExpr) Format ¶
func (node *ExistsExpr) Format(buf *TrackedBuffer)
func (*ExistsExpr) IBoolExpr ¶
func (*ExistsExpr) IBoolExpr()
func (*ExistsExpr) IExpr ¶
func (*ExistsExpr) IExpr()
type FuncExpr ¶
type FuncExpr struct { Name []byte Distinct bool Exprs SelectExprs }
FuncExpr represents a function call.
func (*FuncExpr) Format ¶
func (node *FuncExpr) Format(buf *TrackedBuffer)
func (*FuncExpr) IsAggregate ¶
type GroupBy ¶
type GroupBy []ValExpr
GroupBy represents a GROUP BY clause.
func (GroupBy) Format ¶
func (node GroupBy) Format(buf *TrackedBuffer)
type IndexHints ¶
IndexHints represents a list of index hints.
func (*IndexHints) Format ¶
func (node *IndexHints) Format(buf *TrackedBuffer)
type Insert ¶
type Insert struct { Comments Comments Table *TableName Columns Columns Rows InsertRows OnDup OnDup }
Insert represents an INSERT statement.
func (*Insert) Format ¶
func (node *Insert) Format(buf *TrackedBuffer)
func (*Insert) IStatement ¶
func (*Insert) IStatement()
type InsertRows ¶
type InsertRows interface { IInsertRows() SQLNode }
InsertRows represents the rows for an INSERT statement.
type JoinTableExpr ¶
JoinTableExpr represents a TableExpr that's a JOIN operation.
func (*JoinTableExpr) Format ¶
func (node *JoinTableExpr) Format(buf *TrackedBuffer)
func (*JoinTableExpr) ITableExpr ¶
func (*JoinTableExpr) ITableExpr()
type Limit ¶
type Limit struct {
Offset, Rowcount ValExpr
}
Limit represents a LIMIT clause.
func (*Limit) Format ¶
func (node *Limit) Format(buf *TrackedBuffer)
type ListArg ¶
type ListArg []byte
ListArg represents a named list argument.
func (ListArg) Format ¶
func (node ListArg) Format(buf *TrackedBuffer)
type NonStarExpr ¶
NonStarExpr defines a non-'*' select expr.
func (*NonStarExpr) Format ¶
func (node *NonStarExpr) Format(buf *TrackedBuffer)
func (*NonStarExpr) ISelectExpr ¶
func (*NonStarExpr) ISelectExpr()
type NotExpr ¶
type NotExpr struct {
Expr BoolExpr
}
NotExpr represents a NOT expression.
func (*NotExpr) Format ¶
func (node *NotExpr) Format(buf *TrackedBuffer)
type NullCheck ¶
NullCheck represents an IS NULL or an IS NOT NULL expression.
func (*NullCheck) Format ¶
func (node *NullCheck) Format(buf *TrackedBuffer)
type NullVal ¶
type NullVal struct{}
NullVal represents a NULL value.
func (*NullVal) Format ¶
func (node *NullVal) Format(buf *TrackedBuffer)
type NumVal ¶
type NumVal []byte
NumVal represents a number.
func (NumVal) Format ¶
func (node NumVal) Format(buf *TrackedBuffer)
type OnDup ¶
type OnDup UpdateExprs
OnDup represents an ON DUPLICATE KEY clause.
func (OnDup) Format ¶
func (node OnDup) Format(buf *TrackedBuffer)
type OrExpr ¶
type OrExpr struct {
Left, Right BoolExpr
}
OrExpr represents an OR expression.
func (*OrExpr) Format ¶
func (node *OrExpr) Format(buf *TrackedBuffer)
type Order ¶
Order represents an ordering expression.
func (*Order) Format ¶
func (node *Order) Format(buf *TrackedBuffer)
type OrderBy ¶
type OrderBy []*Order
OrderBy represents an ORDER By clause.
func (OrderBy) Format ¶
func (node OrderBy) Format(buf *TrackedBuffer)
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)
func (*Other) IStatement ¶
func (*Other) IStatement()
type ParenBoolExpr ¶
type ParenBoolExpr struct {
Expr BoolExpr
}
ParenBoolExpr represents a parenthesized boolean expression.
func (*ParenBoolExpr) Format ¶
func (node *ParenBoolExpr) Format(buf *TrackedBuffer)
func (*ParenBoolExpr) IBoolExpr ¶
func (*ParenBoolExpr) IBoolExpr()
func (*ParenBoolExpr) IExpr ¶
func (*ParenBoolExpr) IExpr()
type ParenTableExpr ¶
type ParenTableExpr struct {
Expr TableExpr
}
ParenTableExpr represents a parenthesized TableExpr.
func (*ParenTableExpr) Format ¶
func (node *ParenTableExpr) Format(buf *TrackedBuffer)
func (*ParenTableExpr) ITableExpr ¶
func (*ParenTableExpr) ITableExpr()
type ParsedQuery ¶
type ParsedQuery struct { Query string // contains filtered or unexported fields }
func (*ParsedQuery) GenerateQuery ¶
func (pq *ParsedQuery) GenerateQuery(bindVariables map[string]interface{}) ([]byte, error)
func (*ParsedQuery) MarshalJSON ¶
func (pq *ParsedQuery) MarshalJSON() ([]byte, error)
type RangeCond ¶
RangeCond represents a BETWEEN or a NOT BETWEEN expression.
func (*RangeCond) Format ¶
func (node *RangeCond) Format(buf *TrackedBuffer)
type RowTuple ¶
type RowTuple interface { IRowTuple() ValExpr }
RowTuple represents a row of values. It can be ValTuple, Subquery.
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)
func (*Select) IInsertRows ¶
func (*Select) IInsertRows()
func (*Select) ISelectStatement ¶
func (*Select) ISelectStatement()
func (*Select) IStatement ¶
func (*Select) IStatement()
type SelectExpr ¶
type SelectExpr interface { ISelectExpr() SQLNode }
SelectExpr represents a SELECT expression.
type SelectExprs ¶
type SelectExprs []SelectExpr
SelectExprs represents SELECT expressions.
func (SelectExprs) Format ¶
func (node SelectExprs) Format(buf *TrackedBuffer)
type SelectStatement ¶
type SelectStatement interface { ISelectStatement() IStatement() IInsertRows() SQLNode }
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)
func (*Set) IStatement ¶
func (*Set) IStatement()
type SimpleTableExpr ¶
type SimpleTableExpr interface { ISimpleTableExpr() SQLNode }
SimpleTableExpr represents a simple table expression.
type StarExpr ¶
type StarExpr struct {
TableName []byte
}
StarExpr defines a '*' or 'table.*' expression.
func (*StarExpr) Format ¶
func (node *StarExpr) Format(buf *TrackedBuffer)
func (*StarExpr) ISelectExpr ¶
func (*StarExpr) ISelectExpr()
type Statement ¶
type Statement interface { IStatement() SQLNode }
Statement represents a statement.
type StrVal ¶
type StrVal []byte
StrVal represents a string value.
func (StrVal) Format ¶
func (node StrVal) Format(buf *TrackedBuffer)
type Subquery ¶
type Subquery struct {
Select SelectStatement
}
Subquery represents a subquery.
func (*Subquery) Format ¶
func (node *Subquery) Format(buf *TrackedBuffer)
func (*Subquery) ISimpleTableExpr ¶
func (*Subquery) ISimpleTableExpr()
type TableExpr ¶
type TableExpr interface { ITableExpr() SQLNode }
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)
type TableName ¶
type TableName struct {
Name, Qualifier []byte
}
TableName represents a table name.
func (*TableName) Format ¶
func (node *TableName) Format(buf *TrackedBuffer)
func (*TableName) ISimpleTableExpr ¶
func (*TableName) ISimpleTableExpr()
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 ¶
NewStringTokenizer creates a new Tokenizer for the sql string.
func (*Tokenizer) ConsumeNext ¶
type TrackedBuffer ¶
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
func (*TrackedBuffer) HasBindVars ¶
func (buf *TrackedBuffer) HasBindVars() bool
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
func (*TrackedBuffer) WriteArg ¶
func (buf *TrackedBuffer) WriteArg(arg string)
WriteArg writes a value argument into the buffer. arg should not contain the ':' prefix. It also adds tracking info for future substitutions.
type TupleEqualityList ¶
type UnaryExpr ¶
UnaryExpr represents a unary value expression.
func (*UnaryExpr) Format ¶
func (node *UnaryExpr) Format(buf *TrackedBuffer)
type Union ¶
type Union struct { Type string Left, Right SelectStatement }
Union represents a UNION statement.
func (*Union) Format ¶
func (node *Union) Format(buf *TrackedBuffer)
func (*Union) IInsertRows ¶
func (*Union) IInsertRows()
func (*Union) ISelectStatement ¶
func (*Union) ISelectStatement()
func (*Union) IStatement ¶
func (*Union) IStatement()
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)
func (*Update) IStatement ¶
func (*Update) IStatement()
type UpdateExpr ¶
UpdateExpr represents an update expression.
func (*UpdateExpr) Format ¶
func (node *UpdateExpr) Format(buf *TrackedBuffer)
type UpdateExprs ¶
type UpdateExprs []*UpdateExpr
UpdateExprs represents a list of update expressions.
func (UpdateExprs) Format ¶
func (node UpdateExprs) Format(buf *TrackedBuffer)
type ValArg ¶
type ValArg []byte
ValArg represents a named bind var argument.
func (ValArg) Format ¶
func (node ValArg) Format(buf *TrackedBuffer)
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)
type ValTuple ¶
type ValTuple ValExprs
ValTuple represents a tuple of actual values.
func (ValTuple) Format ¶
func (node ValTuple) Format(buf *TrackedBuffer)
type Values ¶
type Values []RowTuple
Values represents a VALUES clause.
func (Values) Format ¶
func (node Values) Format(buf *TrackedBuffer)
func (Values) IInsertRows ¶
func (Values) IInsertRows()
type When ¶
When represents a WHEN sub-expression.
func (*When) Format ¶
func (node *When) Format(buf *TrackedBuffer)
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
dependency
|
|
bson
Package bson implements encoding and decoding of BSON objects.
|
Package bson implements encoding and decoding of BSON objects. |
bytes2
Package bytes2 provides alternate implementations of functionality similar to go's bytes package.
|
Package bytes2 provides alternate implementations of functionality similar to go's bytes package. |
hack
Package hack gives you some efficient functionality at the cost of breaking some Go rules.
|
Package hack gives you some efficient functionality at the cost of breaking some Go rules. |
sqltypes
Package sqltypes implements interfaces and types that represent SQL values.
|
Package sqltypes implements interfaces and types that represent SQL values. |