sqlparser

package
v0.0.0-...-982e07a Latest Latest
Warning

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

 Go to latest Published: Dec 19, 2023 License: Apache-2.0, Apache-2.0 Imports: 16 Imported by: 0

README

sqlparser Build Status Coverage Report card GoDoc

Go package for parsing MySQL SQL queries.

Notice

The backbone of this repo is extracted from vitessio/vitess.

Inside vitessio/vitess there is a very nicely written sql parser. However as it's not a self-contained application, I created this one. It applies the same LICENSE as vitessio/vitess.

Usage

import (
    "github.com/cossacklabs/acra/sqlparser"
)

Then use:

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

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

Alternative to read many queries from a io.Reader:

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

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

See parse_test.go for more examples, or read the godoc.

Porting Instructions

You only need the below if you plan to try and keep this library up to date with vitessio/vitess.

Keeping up to date
shopt -s nullglob
VITESS=${GOPATH?}/src/vitess.io/vitess/go/
XWB1989=${GOPATH?}/src/github.com/cossacklabs/acra/sqlparser/

# Create patches for everything that changed
LASTIMPORT=1b7879cb91f1dfe1a2dfa06fea96e951e3a7aec5
for path in ${VITESS?}/{vt/sqlparser,sqltypes,bytes2,hack}; do
	cd ${path}
	git format-patch ${LASTIMPORT?} .
done;

# Apply patches to the dependencies
cd ${XWB1989?}
git am --directory dependency -p2 ${VITESS?}/{sqltypes,bytes2,hack}/*.patch

# Apply the main patches to the repo
cd ${XWB1989?}
git am -p4 ${VITESS?}/vt/sqlparser/*.patch

# If you encounter diff failures, manually fix them with
patch -p4 < .git/rebase-apply/patch
...
git add name_of_files
git am --continue

# Cleanup
rm ${VITESS?}/{sqltypes,bytes2,hack}/*.patch ${VITESS?}/*.patch

# and Finally update the LASTIMPORT in this README.
Fresh install

TODO: Change these instructions to use git to copy the files, that'll make later patching easier.

VITESS=${GOPATH?}/src/vitess.io/vitess/go/
XWB1989=${GOPATH?}/src/github.com/cossacklabs/acra/sqlparser/

cd ${XWB1989?}

# Copy all the code
cp -pr ${VITESS?}/vt/sqlparser/ .
cp -pr ${VITESS?}/sqltypes dependency
cp -pr ${VITESS?}/bytes2 dependency
cp -pr ${VITESS?}/hack dependency

# Delete some code we haven't ported
rm dependency/sqltypes/arithmetic.go dependency/sqltypes/arithmetic_test.go dependency/sqltypes/event_token.go dependency/sqltypes/event_token_test.go dependency/sqltypes/proto3.go dependency/sqltypes/proto3_test.go dependency/sqltypes/query_response.go dependency/sqltypes/result.go dependency/sqltypes/result_test.go

# Some automated fixes

# Fix imports
sed -i '.bak' 's_vitess.io/vitess/go/vt/proto/query_github.com/cossacklabs/acra/sqlparser/dependency/querypb_g' *.go dependency/sqltypes/*.go
sed -i '.bak' 's_vitess.io/vitess/go/_github.com/cossacklabs/acra/sqlparser/dependency/_g' *.go dependency/sqltypes/*.go

# Copy the proto, but basically drop everything we don't want
cp -pr ${VITESS?}/vt/proto/query dependency/querypb

sed -i '.bak' 's_.*Descriptor.*__g' dependency/querypb/*.go
sed -i '.bak' 's_.*ProtoMessage.*__g' dependency/querypb/*.go

sed -i '.bak' 's/proto.CompactTextString(m)/"TODO"/g' dependency/querypb/*.go
sed -i '.bak' 's/proto.EnumName/EnumName/g' dependency/querypb/*.go

sed -i '.bak' 's/proto.Equal/reflect.DeepEqual/g' dependency/sqltypes/*.go

# Remove the error library
sed -i '.bak' 's/vterrors.Errorf([^,]*, /fmt.Errorf(/g' *.go dependency/sqltypes/*.go
sed -i '.bak' 's/vterrors.New([^,]*, /errors.New(/g' *.go dependency/sqltypes/*.go
Testing
VITESS=${GOPATH?}/src/vitess.io/vitess/go/
XWB1989=${GOPATH?}/src/github.com/cossacklabs/acra/sqlparser/

cd ${XWB1989?}

# Test, fix and repeat
go test ./...

# Finally make some diffs (for later reference)
diff -u ${VITESS?}/sqltypes/        ${XWB1989?}/dependency/sqltypes/ > ${XWB1989?}/patches/sqltypes.patch
diff -u ${VITESS?}/bytes2/          ${XWB1989?}/dependency/bytes2/   > ${XWB1989?}/patches/bytes2.patch
diff -u ${VITESS?}/vt/proto/query/  ${XWB1989?}/dependency/querypb/  > ${XWB1989?}/patches/querypb.patch
diff -u ${VITESS?}/vt/sqlparser/    ${XWB1989?}/                     > ${XWB1989?}/patches/sqlparser.patch

Documentation

Index

Examples

Constants

View Source 
const (
	StmtSelect = iota
	StmtStream
	StmtInsert
	StmtReplace
	StmtUpdate
	StmtDelete
	StmtDDL
	StmtBegin
	StmtCommit
	StmtRollback
	StmtSet
	StmtShow
	StmtUse
	StmtOther
	StmtUnknown
	StmtComment
	StmtDeallocatePrepare
	StmtPrepare
	StmtExecute
)

These constants are used to identify the SQL statement type.

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

Select.Distinct

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

Select.Lock

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

Select.Cache

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

Union.Type

View Source 
const (
	InsertStr  = "insert"
	ReplaceStr = "replace"
)

DDL strings.

View Source 
const (
	SessionStr = "session"
	GlobalStr  = "global"
	LocalStr   = "local"
)

Set.Scope or Show.Scope

View Source 
const (
	CreateStr        = "create"
	AlterStr         = "alter"
	DropStr          = "drop"
	RenameStr        = "rename"
	TruncateStr      = "truncate"
	CreateVindexStr  = "create vindex"
	AddColVindexStr  = "add vindex"
	DropColVindexStr = "drop vindex"

	// Vindex DDL param to specify the owner of a vindex
	VindexOwnerStr = "owner"
)

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"
	ILikeStr             = "ilike"
	NotLikeStr           = "not like"
	NotILikeStr          = "not ilike"
	RegexpStr            = "regexp"
	NotRegexpStr         = "not regexp"
	JSONExtractOp        = "->"
	JSONUnquoteExtractOp = "->>"
)

ComparisonExpr.Operator

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

RangeCond.Operator

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

IsExpr.Operator

View Source 
const (
	StrVal = ValType(iota)
	IntVal
	FloatVal
	HexNum
	HexVal
	ValArg
	BitVal
	PgEscapeString
	PgPlaceholder
	// Use this type for casted values that are different from SQLVal.
	// because we have existing logic of comparison and formatting SQLVal
	// and it easier to extend this one instead of propagating postgresql value conversion
	// to all kinds of Expr. Maybe in a future when we will know more cases when it useful for
	// our data manipulation, we will refactor it. Now it's just to support generic queries and avoid
	// a lot of refactoring of sql.y and SQL grammar
	UnknownVal
)

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

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

BinaryExpr.Operator

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

UnaryExpr.Operator

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

MatchExpr.Option

View Source 
const (
	AscScr            = "asc"
	DescScr           = "desc"
	DescNullsFirstScr = "desc nulls first"
	DescNullsLastScr  = "desc nulls last"
	AscNullsFirstScr  = "asc nulls first"
	AscNullsLastScr   = "asc nulls last"
)

Order.Direction

View Source 
const (
	// DirectiveMultiShardAutocommit is the query comment directive to allow
	// single round trip autocommit with a multi-shard statement.
	DirectiveMultiShardAutocommit = "MULTI_SHARD_AUTOCOMMIT"
	// DirectiveSkipQueryPlanCache skips query plan cache when set.
	DirectiveSkipQueryPlanCache = "SKIP_QUERY_PLAN_CACHE"
	// DirectiveQueryTimeout sets a query timeout in vtgate. Only supported for SELECTS.
	DirectiveQueryTimeout = "QUERY_TIMEOUT_MS"
)
View Source 
const ADD = 57470
View Source 
const AGAINST = 57599
View Source 
const ALL = 57362
View Source 
const ALTER = 57466
View Source 
const ANALYZE = 57469
View Source 
const AND = 57438
View Source 
const APPROXNUM = 57555
View Source 
const AS = 57364
View Source 
const ASC = 57366
View Source 
const AUTO_INCREMENT = 57554
View Source 
const BACK_QUOTE_STRING = 57404
View Source 
const BEGIN = 57505
View Source 
const BETWEEN = 57440
View Source 
const BIGINT = 57519
View Source 
const BINARY = 57461
View Source 
const BIT = 57513
View Source 
const BIT_LITERAL = 57411
View Source 
const BLOB = 57539
View Source 
const BOOL = 57531
View Source 
const BOOLEAN = 57600
View Source 
const BY = 57358
View Source 
const CASE = 57441
View Source 
const CAST = 57593
View Source 
const CHAR = 57529
View Source 
const CHARACTER = 57532
View Source 
const CHARSET = 57569
View Source 
const COLLATE = 57460
View Source 
const COLUMN = 57480
View Source 
const COMMENT = 57409
View Source 
const COMMENT_KEYWORD = 57410
View Source 
const COMMIT = 57508
View Source 
const COMMITTED = 57579
View Source 
const CONSTRAINT = 57481
View Source 
const CONVERT = 57592
View Source 
const CREATE = 57465
View Source 
const CROSS = 57392
View Source 
const CURRENT_DATE = 57584
View Source 
const CURRENT_TIME = 57585
View Source 
const CURRENT_TIMESTAMP = 57582
View Source 
const (
	CharacterSetStr = " character set"
)

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

View Source 
const DATABASE = 57583
View Source 
const DATABASES = 57559
View Source 
const DATE = 57489
View Source 
const DATETIME = 57528
View Source 
const DAY = 57421
View Source 
const DAY_HOUR = 57434
View Source 
const DAY_MICROSECOND = 57431
View Source 
const DAY_MINUTE = 57433
View Source 
const DAY_SECOND = 57432
View Source 
const DEALLOCATE = 57510
View Source 
const DECIMAL = 57524
View Source 
const DEFAULT = 57371
View Source 
const DELETE = 57352
View Source 
const DESC = 57367
View Source 
const DESCRIBE = 57487
View Source 
const DISTINCT = 57363
View Source 
const DIV = 57457
View Source 
const DOLLAR_SIGN = 57412
View Source 
const DOUBLE = 57522
View Source 
const DOUBLE_QUOTE_STRING = 57403
View Source 
const DROP = 57467
View Source 
const DUPLICATE = 57369
View Source 
const ELSE = 57444
View Source 
const END = 57445
View Source 
const ENUM = 57544
View Source 
const ESCAPE = 57490
View Source 
const EXECUTE = 57512
View Source 
const EXISTS = 57365
View Source 
const EXPANSION = 57604
View Source 
const EXPLAIN = 57488
View Source 
const EXTENDED = 57565
View Source 
const FALSE = 57416
View Source 
const FIRST = 57376
View Source 
const FLOAT = 57406
View Source 
const FLOAT_TYPE = 57523
View Source 
const FOR = 57361
View Source 
const FORCE = 57395
View Source 
const FOREIGN = 57484
View Source 
const FROM = 57353
View Source 
const FULL = 57566
View Source 
const FULLTEXT = 57483
View Source 
const GE = 57447
View Source 
const GEOMETRY = 57545
View Source 
const GEOMETRYCOLLECTION = 57549
View Source 
const GLOBAL = 57570
View Source 
const GROUP = 57355
View Source 
const GROUP_CONCAT = 57596
View Source 
const HAVING = 57356
View Source 
const HEX = 57401
View Source 
const HEXNUM = 57407
View Source 
const HOUR = 57420
View Source 
const HOUR_MICROSECOND = 57428
View Source 
const HOUR_MINUTE = 57430
View Source 
const HOUR_SECOND = 57429
View Source 
const ID = 57399
View Source 
const IF = 57477
View Source 
const IGNORE = 57476
View Source 
const ILIKE = 57452
View Source 
const IN = 57454
View Source 
const INDEX = 57473
View Source 
const INNER = 57390
View Source 
const INSERT = 57350
View Source 
const INT = 57517
View Source 
const INTEGER = 57518
View Source 
const INTEGRAL = 57405
View Source 
const INTERVAL = 57398
View Source 
const INTNUM = 57520
View Source 
const INTO = 57368
View Source 
const IS = 57450
View Source 
const ISOLATION = 57573
View Source 
const JOIN = 57386
View Source 
const JSON = 57543
View Source 
const JSON_EXTRACT_OP = 57463
View Source 
const JSON_UNQUOTE_EXTRACT_OP = 57464
View Source 
const KEY = 57370
View Source 
const KEYS = 57374
View Source 
const KEY_BLOCK_SIZE = 57485
View Source 
const LANGUAGE = 57601
View Source 
const LAST = 57377
View Source 
const LAST_INSERT_ID = 57379
View Source 
const LE = 57446
View Source 
const LEFT = 57388
View Source 
const LESS = 57497
View Source 
const LEVEL = 57574
View Source 
const LEX_ERROR = 57346
View Source 
const LIKE = 57451
View Source 
const LIMIT = 57359
View Source 
const LINESTRING = 57547
View Source 
const LIST_ARG = 57413
View Source 
const LOCAL = 57572
View Source 
const LOCALTIME = 57586
View Source 
const LOCALTIMESTAMP = 57587
View Source 
const LOCK = 57373
View Source 
const LONGBLOB = 57542
View Source 
const LONGTEXT = 57538
View Source 
const MATCH = 57598
View Source 
const MAXVALUE = 57494
View Source 
const MEDIUMBLOB = 57541
View Source 
const MEDIUMINT = 57516
View Source 
const MEDIUMTEXT = 57537
View Source 
const MICROSECOND = 57417
View Source 
const MINUTE = 57419
View Source 
const MINUTE_MICROSECOND = 57426
View Source 
const MINUTE_SECOND = 57427
View Source 
const MOD = 57458
View Source 
const MODE = 57383
View Source 
const MONTH = 57423
View Source 
const MULTILINESTRING = 57551
View Source 
const MULTIPOINT = 57550
View Source 
const MULTIPOLYGON = 57552
View Source 
const NAMES = 57568
View Source 
const NATURAL = 57393
View Source 
const NCHAR = 57534
View Source 
const NE = 57448
View Source 
const NEXT = 57380
View Source 
const NOT = 57439
View Source 
const NULL = 57414
View Source 
const NULLS = 57375
View Source 
const NULLX = 57553
View Source 
const NULL_SAFE_EQUAL = 57449
View Source 
const NUMERIC = 57525
View Source 
const OFFSET = 57360
View Source 
const ON = 57396
View Source 
const ONLY = 57577
View Source 
const OPTIMIZE = 57492
View Source 
const OR = 57437
View Source 
const ORDER = 57357
View Source 
const OUTER = 57391
View Source 
const PARTITION = 57495
View Source 
const PG_ESCAPE_STRING = 57400
View Source 
const POINT = 57546
View Source 
const POLYGON = 57548
View Source 
const PREPARE = 57511
View Source 
const PRIMARY = 57479
View Source 
const PROCEDURE = 57499
View Source 
const PROCESSLIST = 57567
View Source 
const QUARTER = 57424
View Source 
const QUERY = 57603
View Source 
const READ = 57575
View Source 
const REAL = 57521
View Source 
const REGEXP = 57453
View Source 
const RENAME = 57468
View Source 
const REORGANIZE = 57496
View Source 
const REPAIR = 57491
View Source 
const REPEATABLE = 57578
View Source 
const REPLACE = 57591
View Source 
const RETURNING = 57606
View Source 
const RIGHT = 57389
View Source 
const ROLLBACK = 57509
View Source 
const (
	ReorganizeStr = "reorganize partition"
)

Partition strings

View Source 
const SCHEMA = 57471
View Source 
const SECOND = 57418
View Source 
const SECOND_MICROSECOND = 57425
View Source 
const SELECT = 57348
View Source 
const SEPARATOR = 57597
View Source 
const SERIALIZABLE = 57581
View Source 
const SESSION = 57571
View Source 
const SET = 57372
View Source 
const SHARE = 57382
View Source 
const SHIFT_LEFT = 57455
View Source 
const SHIFT_RIGHT = 57456
View Source 
const SHOW = 57486
View Source 
const SIGNED = 57556
View Source 
const SINGLE_QUOTE_STRING = 57402
View Source 
const SMALLINT = 57515
View Source 
const SPATIAL = 57482
View Source 
const SQL_CACHE = 57385
View Source 
const SQL_NO_CACHE = 57384
View Source 
const START = 57506
View Source 
const STATUS = 57503
View Source 
const STRAIGHT_JOIN = 57387
View Source 
const STREAM = 57349
View Source 
const SUBSTR = 57594
View Source 
const SUBSTRING = 57595
View Source 
const TABLE = 57472
View Source 
const TABLES = 57560
View Source 
const TEXT = 57535
View Source 
const THAN = 57498
View Source 
const THEN = 57443
View Source 
const TIME = 57526
View Source 
const TIMESTAMP = 57527
View Source 
const TINYBLOB = 57540
View Source 
const TINYINT = 57514
View Source 
const TINYTEXT = 57536
View Source 
const TO = 57475
View Source 
const TRANSACTION = 57507
View Source 
const TRIGGER = 57500
View Source 
const TRUE = 57415
View Source 
const TRUNCATE = 57493
View Source 
const UNARY = 57459
View Source 
const UNCOMMITTED = 57580
View Source 
const UNDERSCORE_BINARY = 57462
View Source 
const UNION = 57347
View Source 
const UNIQUE = 57478
View Source 
const UNSIGNED = 57557
View Source 
const UNUSED = 57605
View Source 
const UPDATE = 57351
View Source 
const USE = 57394
View Source 
const USING = 57397
View Source 
const UTC_DATE = 57588
View Source 
const UTC_TIME = 57589
View Source 
const UTC_TIMESTAMP = 57590
View Source 
const VALUE = 57381
View Source 
const VALUES = 57378
View Source 
const VALUE_ARG = 57408
View Source 
const VARBINARY = 57533
View Source 
const VARCHAR = 57530
View Source 
const VARIABLES = 57504
View Source 
const VIEW = 57474
View Source 
const VINDEX = 57501
View Source 
const VINDEXES = 57502
View Source 
const VITESS_KEYSPACES = 57561
View Source 
const VITESS_SHARDS = 57562
View Source 
const VITESS_TABLETS = 57563
View Source 
const VSCHEMA_TABLES = 57564
View Source 
const ValueMask = "replaced"

ValueMask is used to mask real Values from SQL queries before logging to syslog.

View Source 
const WEEK = 57422
View Source 
const WHEN = 57442
View Source 
const WHERE = 57354
View Source 
const WITH = 57602
View Source 
const WRITE = 57576
View Source 
const YEAR = 57436
View Source 
const YEAR_MONTH = 57435
View Source 
const ZEROFILL = 57558

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.

View Source 
var ErrInvalidStringLiteralQuotes = errors.New("invalid string literal quotes")

ErrInvalidStringLiteralQuotes if used string token as literal with incorrect quotes

View Source 
var ErrQuerySyntaxError = errors.New("fail to parse specified query")

ErrQuerySyntaxError error returned by sqlparser.Parser

Functions

func Append 

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

Append appends the SQLNode to the buffer.

func EncodeValue 

func EncodeValue(buf *bytes.Buffer, value *querypb.BindVariable)

EncodeValue encodes one bind variable value into the query.

func ExtractMysqlComment 

func ExtractMysqlComment(sql string) (version string, innerSQL string)

ExtractMysqlComment extracts the version and SQL from a comment-only query such as /*!50708 sql here */

func ExtractSetValues 

func ExtractSetValues(sql string) (keyValues map[SetKey]interface{}, scope string, err error)

ExtractSetValues returns a map of key-value pairs if the query is a SET statement. Values can be bool, int64 or string. Since set variable names are case insensitive, all keys are returned as lower case.

func FetchBindVar 

func FetchBindVar(name string, bindVariables map[string]*querypb.BindVariable) (val *querypb.BindVariable, isList bool, err error)

FetchBindVar resolves the bind variable by fetching it from bindVariables.

func FormatImpossibleQuery 

func FormatImpossibleQuery(buf *TrackedBuffer, node SQLNode)

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

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

func GetBindvars 

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

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

func IsColName 

func IsColName(node Expr) bool

IsColName returns true if the Expr is a *ColName.

func IsDML 

func IsDML(sql string) bool

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

func IsNull 

func IsNull(node Expr) bool

IsNull returns true if the Expr is SQL NULL

func IsSimpleTuple 

func IsSimpleTuple(node Expr) bool

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

func IsValue 

func IsValue(node Expr) bool

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

func KeywordString 

func KeywordString(id int) string

KeywordString returns the string corresponding to the given keyword

func NewPlanValue 

func NewPlanValue(node Expr) (sqltypes.PlanValue, error)

NewPlanValue builds a sqltypes.PlanValue from an Expr.

func Normalize 

func Normalize(stmt Statement, bindVars map[string]*querypb.BindVariable, prefix string)

Normalize changes the statement to use bind values, and updates the bind vars to those values. The supplied prefix is used to generate the bind var names. The function ensures that there are no collisions with existing bind vars. Within Select constructs, bind vars are deduped. This allows us to identify vindex equality. Otherwise, every value is treated as distinct.

func Preview 

func Preview(sql string) int

Preview analyzes the beginning of the query using a simpler and faster textual comparison to identify the statement type.

func RedactSQLQuery 

func RedactSQLQuery(sql string) (string, error)

RedactSQLQuery returns a sql string with the params stripped out for display

func SetDefaultDialect 

func SetDefaultDialect(dialect dialect.Dialect)

SetDefaultDialect set globally default dialect used in old functions with default dialect

func SetSQLParserErrorVerboseLevel 

func SetSQLParserErrorVerboseLevel(verbose bool)

setErrorVerbose configures format of ErrorMessages from parser. If false then only "syntax error" will be shown. Default is false

func SetTokenizerVerbosity 

func SetTokenizerVerbosity(verbose bool)

SetTokenizerVerbosity turns on/off tokenizer's error messages verbosity

func SkipQueryPlanCacheDirective 

func SkipQueryPlanCacheDirective(stmt Statement) bool

SkipQueryPlanCacheDirective returns true if skip query plan cache directive is set to true in query.

func SplitStatement 

func SplitStatement(blob string) (string, string, error)

SplitStatement returns the first sql statement up to either a ; or EOF and the remainder from the given buffer

func SplitStatementToPieces 

func SplitStatementToPieces(blob string) (pieces []string, err error)

SplitStatementToPieces split raw sql statement that may have multi sql pieces to sql pieces returns the sql pieces blob contains; or error if sql cannot be parsed

func StmtType 

func StmtType(stmtType int) string

StmtType returns the statement type as a string

func String 

func String(node SQLNode) string

String returns a string representation of an SQLNode for default dialect

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 StringWithDialect 

func StringWithDialect(dialect dialect.Dialect, node SQLNode) string

StringWithDialect returns a string representation of an SQLNode for specified dialect

func StripLeadingComments 

func StripLeadingComments(sql string) string

StripLeadingComments trims the SQL string and removes any leading comments

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 AliasedExpr 

type AliasedExpr struct {
	Expr Expr
	As   ColIdent
}

AliasedExpr defines an aliased SELECT expression.

func (*AliasedExpr) Format 

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

Format formats the node.

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

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

Format formats the node.

func (*AliasedTableExpr) RemoveHints 

func (node *AliasedTableExpr) RemoveHints() *AliasedTableExpr

RemoveHints returns a new AliasedTableExpr with the hints removed.

type AndExpr 

type AndExpr struct {
	Left, Right Expr
}

AndExpr represents an AND expression.

func (*AndExpr) Format 

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

Format formats the node.

type Begin 

type Begin struct{}

Begin represents a Begin statement.

func (*Begin) Format 

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

Format formats the node.

type BinaryExpr 

type BinaryExpr struct {
	Operator    string
	Left, Right Expr
}

BinaryExpr represents a binary value expression.

func (*BinaryExpr) Format 

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

Format formats the node.

type BoolVal 

type BoolVal bool

BoolVal is true or false.

func (BoolVal) Format 

func (node BoolVal) Format(buf *TrackedBuffer)

Format formats the node.

type CaseExpr 

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

CaseExpr represents a CASE expression.

func (*CaseExpr) Format 

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

Format formats the node.

type ColIdent 

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

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

func NewColIdent 

func NewColIdent(str string) ColIdent

NewColIdent makes a new ColIdent.

func NewColIdentUnquote 

func NewColIdentUnquote(str string) ColIdent

NewColIdentUnquote makes a new ColIdent.

func NewColIdentWithQuotes 

func NewColIdentWithQuotes(str string, quote byte) ColIdent

NewColIdentWithQuotes create ColIdent with quotes to escape column name in Postgresql style

func (ColIdent) CompliantName 

func (node ColIdent) CompliantName() string

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

func (ColIdent) Equal 

func (node ColIdent) Equal(in ColIdent) bool

Equal performs a case-insensitive compare.

func (ColIdent) EqualString 

func (node ColIdent) EqualString(str string) bool

EqualString performs a case-insensitive compare with str.

func (ColIdent) Format 

func (node ColIdent) Format(buf *TrackedBuffer)

Format formats the node.

func (ColIdent) FormatForDialect 

func (node ColIdent) FormatForDialect(dialect dialect.Dialect, buf *TrackedBuffer)

FormatForDialect formats the node for specified dialect

func (ColIdent) IsEmpty 

func (node ColIdent) IsEmpty() bool

IsEmpty returns true if the name is empty.

func (*ColIdent) Lowered 

func (node *ColIdent) Lowered() string

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

func (ColIdent) MarshalJSON 

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

MarshalJSON marshals into JSON.

func (ColIdent) String 

func (node ColIdent) String() string

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

func (*ColIdent) UnmarshalJSON 

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

UnmarshalJSON unmarshals from JSON.

func (*ColIdent) ValueForConfig 

func (node *ColIdent) ValueForConfig() string

ValueForConfig returns lowercased or non-lowercased value depending on configuration (MySQL only) and which quotes were used to wrap the name in SQL, suitable for usage when checking whether the column should be encrypted.

type ColName 

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

ColName represents a column name.

func (*ColName) Equal 

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

Equal returns true if the column names match.

func (*ColName) Format 

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

Format formats the node.

type ColTuple 

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

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

type CollateExpr 

type CollateExpr struct {
	Expr    Expr
	Charset string
}

CollateExpr represents dynamic collate operator.

func (*CollateExpr) Format 

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

Format formats the node.

type ColumnDefinition 

type ColumnDefinition struct {
	Name ColIdent
	Type ColumnType
}

ColumnDefinition describes a column in a CREATE TABLE statement

func (*ColumnDefinition) Format 

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

Format formats the node.

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
	Default       *SQLVal
	OnUpdate      *SQLVal
	Comment       *SQLVal

	// Numeric field options
	Length   *SQLVal
	Unsigned BoolVal
	Zerofill BoolVal
	Scale    *SQLVal

	// Text field options
	Charset string
	Collate string

	// Enum values
	EnumValues []string

	// Key specification
	KeyOpt ColumnKeyOption
}

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

func (*ColumnType) DescribeType 

func (ct *ColumnType) DescribeType() string

DescribeType returns the abbreviated type information as required for describe table

func (*ColumnType) Format 

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

Format returns a canonical string representation of the type and all relevant options

func (*ColumnType) SQLType 

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

SQLType returns the sqltypes type code for the given column

type ColumnTypes 

type ColumnTypes []ColumnType

ColumnTypes represents list of column types, eg (int, bool, text, numeric) - dictated by Postgres

func (ColumnTypes) Format 

func (node ColumnTypes) Format(buf *TrackedBuffer)

Format formats the node.

type Columns 

type Columns []ColIdent

Columns represents an insert column list.

func (Columns) FindColumn 

func (node Columns) FindColumn(col ColIdent) int

FindColumn finds a column in the column list, returning the index if it exists or -1 otherwise

func (Columns) Format 

func (node Columns) Format(buf *TrackedBuffer)

Format formats the node.

type CommentDirectives 

type CommentDirectives map[string]interface{}

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

func ExtractCommentDirectives 

func ExtractCommentDirectives(comments Comments) CommentDirectives

ExtractCommentDirectives parses the comment list for any execution directives of the form: 

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

It returns the map of the directive values or nil if there aren't any.

func (CommentDirectives) IsSet 

func (d CommentDirectives) IsSet(key string) bool

IsSet checks the directive map for the named directive and returns true if the directive is set and has a true/false or 0/1 value

type Comments 

type Comments [][]byte

Comments represents a list of comments.

func (Comments) Format 

func (node Comments) Format(buf *TrackedBuffer)

Format formats the node.

type Commit 

type Commit struct{}

Commit represents a Commit statement.

func (*Commit) Format 

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

Format formats the node.

type ComparisonExpr 

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

ComparisonExpr represents a two-value comparison expression.

func (*ComparisonExpr) Format 

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

Format formats the node.

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

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

Format formats the node.

type ConvertType 

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

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

func (*ConvertType) Format 

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

Format formats the node.

type ConvertUsingExpr 

type ConvertUsingExpr struct {
	Expr Expr
	Type string
}

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

func (*ConvertUsingExpr) Format 

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

Format formats the node.

type DBDDL 

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

DBDDL represents a CREATE, DROP database statement.

func (*DBDDL) Format 

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

Format formats the node.

type DDL 

type DDL struct {
	Action        string
	Table         TableName
	NewName       TableName
	IfExists      bool
	TableSpec     *TableSpec
	PartitionSpec *PartitionSpec
	VindexSpec    *VindexSpec
	VindexCols    []ColIdent
}

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. VindexSpec is set for CreateVindexStr, DropVindexStr, AddColVindexStr, DropColVindexStr VindexCols is set for AddColVindexStr

func (*DDL) Format 

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

Format formats the node.

type DeallocatePrepare 

type DeallocatePrepare struct {
	PreparedStatementName TableIdent
}

DeallocatePrepare deallocates memory that stores compiled prepared statement

func (*DeallocatePrepare) Format 

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

Format formats the node.

type Default 

type Default struct {
	ColName string
}

Default represents a DEFAULT expression.

func (*Default) Format 

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

Format formats the node.

type Delete 

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

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

func (*Delete) Format 

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

Format formats the node.

type DialectFormat 

type DialectFormat interface {
	FormatForDialect(dialect dialect.Dialect, buf *TrackedBuffer)
}

DialectFormat interface for nodes which can format itself for different dialects

type EmptyStatement 

type EmptyStatement struct{}

EmptyStatement represent empty query passed in Postgresql ExtendedProtocol with empty Query field Should not be used and expected from MySQL. MySQL doesn't allow empty query and returns: error_code=1065 sql_state=42000 error_message="Query was empty"

func (EmptyStatement) Format 

func (EmptyStatement) Format(*TrackedBuffer)

Format actually do nothing

type Encodable 

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

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

type Execute 

type Execute struct {
	PreparedStatementName TableIdent
	Values                ValTuple
	Using                 UsingInExecuteList
}

Execute executes prepared statement

func (*Execute) Format 

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

Format formats the node.

type ExistsExpr 

type ExistsExpr struct {
	Subquery *Subquery
}

ExistsExpr represents an EXISTS expression.

func (*ExistsExpr) Format 

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

Format formats the node.

type Expr 

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

Expr represents an expression.

func ExprFromValue 

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

ExprFromValue converts the given Value into an Expr or returns an error.

func ReplaceExpr 

func ReplaceExpr(root, from, to Expr) Expr

ReplaceExpr finds the from expression from root and replaces it with to. If from matches root, then to is returned.

type Exprs 

type Exprs []Expr

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

func (Exprs) Format 

func (node Exprs) Format(buf *TrackedBuffer)

Format formats the node.

type FuncExpr 

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

FuncExpr represents a function call.

func (*FuncExpr) Format 

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

Format formats the node.

func (*FuncExpr) IsAggregate 

func (node *FuncExpr) IsAggregate() bool

IsAggregate returns true if the function is an aggregate.

type GroupBy 

type GroupBy []Expr

GroupBy represents a GROUP BY clause.

func (GroupBy) Format 

func (node GroupBy) Format(buf *TrackedBuffer)

Format formats the node.

type GroupConcatExpr 

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

GroupConcatExpr represents a call to GROUP_CONCAT

func (*GroupConcatExpr) Format 

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

Format formats the node

type IndexColumn 

type IndexColumn struct {
	Column ColIdent
	Length *SQLVal
}

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

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

Format formats the node.

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.

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

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

Format formats the node.

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 {
	Action     string
	Comments   Comments
	Ignore     string
	Table      TableName
	Default    bool
	Partitions Partitions
	Columns    Columns
	Rows       InsertRows
	OnDup      OnDup
	Returning  Returning
}

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. Replaces are currently disallowed in sharded schemas because of the implications the deletion part may have on vindexes. If you add fields here, consider adding them to calls to validateSubquerySamePlan.

func (*Insert) Format 

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

Format formats the node.

type InsertRows 

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

InsertRows represents the rows for an INSERT statement.

type InsertValues 

type InsertValues [][]sqltypes.Value

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

func (InsertValues) EncodeSQL 

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

EncodeSQL performs the SQL encoding for InsertValues.

type IntervalExpr 

type IntervalExpr struct {
	Expr Expr
	Unit string
}

IntervalExpr represents a date-time INTERVAL expression.

func (*IntervalExpr) Format 

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

Format formats the node.

type IsExpr 

type IsExpr struct {
	Operator string
	Expr     Expr
}

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

func (*IsExpr) Format 

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

Format formats the node.

type JoinCondition 

type JoinCondition struct {
	On    Expr
	Using Columns
}

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

func (JoinCondition) Format 

func (node JoinCondition) Format(buf *TrackedBuffer)

Format formats the node.

type JoinTableExpr 

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

JoinTableExpr represents a TableExpr that's a JOIN operation.

func (*JoinTableExpr) Format 

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

Format formats the node.

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
	Type             LimitType
}

Limit represents a LIMIT clause.

func (*Limit) Format 

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

Format formats the node.

type LimitType 

type LimitType int8

LimitType represents type of statements format 

const (
	// LimitTypeLimitOnly is type of LIMIT row_count format
	LimitTypeLimitOnly LimitType = iota
	//LimitTypeCommaSeparated is type of  LIMIT {[offset,] row_count}, MySQL format
	// https://dev.mysql.com/doc/refman/8.0/en/select.html
	LimitTypeCommaSeparated
	// LimitTypeLimitAndOffset is type of LIMIT row_count OFFSET offset
	LimitTypeLimitAndOffset
	// LimitTypeLimitAll is type of LIMIT ALL, PostgreSQL format
	// https://www.postgresql.org/docs/current/sql-select.html#SQL-LIMIT
	LimitTypeLimitAll
	// LimitTypeLimitAllAndOffset is type of LIMIT ALL OFFSET offset
	LimitTypeLimitAllAndOffset
)

type ListArg 

type ListArg []byte

ListArg represents a named list argument.

func (ListArg) Format 

func (node ListArg) Format(buf *TrackedBuffer)

Format formats the node.

type MarginComments 

type MarginComments struct {
	Leading  string
	Trailing string
}

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

func SplitMarginComments 

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

SplitMarginComments pulls out any leading or trailing comments from a raw sql query. This function also trims leading (if there's a comment) and trailing whitespace.

type MatchExpr 

type MatchExpr struct {
	Columns SelectExprs
	Expr    Expr
	Option  string
}

MatchExpr represents a call to the MATCH function

func (*MatchExpr) Format 

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

Format formats the node

type Mode 

type Mode string

Mode enum type used for sqlparser.Parser mode definition 

const (
	ModeDefault Mode = "default"
	ModeStrict  Mode = "strict"
)

Mode enum consts for sqlparser.Parser

type Nextval 

type Nextval struct {
	Expr Expr
}

Nextval defines the NEXT VALUE expression.

func (Nextval) Format 

func (node Nextval) Format(buf *TrackedBuffer)

Format formats the node.

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

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

Format formats the node.

type NotParsedStatement 

type NotParsedStatement struct{ Query string }

NotParsedStatement represent query that can't be parsed by current sqlparser

func (NotParsedStatement) Format 

func (s NotParsedStatement) Format(buf *TrackedBuffer)

Format format NotParsedStatement method

type NullVal 

type NullVal struct{}

NullVal represents a NULL value.

func (*NullVal) Format 

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

Format formats the node.

type OnDup 

type OnDup UpdateExprs

OnDup represents an ON DUPLICATE KEY clause.

func (OnDup) Format 

func (node OnDup) Format(buf *TrackedBuffer)

Format formats the node.

type OrExpr 

type OrExpr struct {
	Left, Right Expr
}

OrExpr represents an OR expression.

func (*OrExpr) Format 

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

Format formats the node.

type Order 

type Order struct {
	Expr      Expr
	Direction string
}

Order represents an ordering expression.

func (*Order) Format 

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

Format formats the node.

type OrderBy 

type OrderBy []*Order

OrderBy represents an ORDER By clause.

func (OrderBy) Format 

func (node OrderBy) Format(buf *TrackedBuffer)

Format formats the node.

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

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

Format formats the node.

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

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

Format formats the node.

type ParenExpr 

type ParenExpr struct {
	Expr Expr
}

ParenExpr represents a parenthesized boolean expression.

func (*ParenExpr) Format 

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

Format formats the node.

type ParenSelect 

type ParenSelect struct {
	Select SelectStatement
}

ParenSelect is a parenthesized SELECT statement.

func (*ParenSelect) AddOrder 

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

AddOrder adds an order by element

func (*ParenSelect) Format 

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

Format formats the node.

func (*ParenSelect) SetLimit 

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

SetLimit sets the limit clause

type ParenTableExpr 

type ParenTableExpr struct {
	Exprs TableExprs
}

ParenTableExpr represents a parenthesized list of TableExpr.

func (*ParenTableExpr) Format 

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

Format formats the node.

type ParsedQuery 

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

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

func BuildParsedQuery 

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

BuildParsedQuery builds a ParsedQuery from the input.

func NewParsedQuery 

func NewParsedQuery(node SQLNode) *ParsedQuery

NewParsedQuery returns a ParsedQuery of the ast.

func (*ParsedQuery) GenerateQuery 

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

GenerateQuery generates a query by substituting the specified bindVariables. The extras parameter specifies special parameters that can perform custom encoding.

type Parser 

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

Parser object used to handle strict/non-strict flow for any sql parse errors

func New 

func New(mode Mode) *Parser

New sqlparser.Parser constructor

func (Parser) HandleRawSQLQuery 

func (p Parser) HandleRawSQLQuery(sql string) (normalizedQuery, redactedQuery string, parsedQuery Statement, err error)

HandleRawSQLQuery returns a normalized (lowercases SQL commands) SQL string, and redacted SQL string with the params stripped out for display. Taken from sqlparser package

func (Parser) Mode 

func (p Parser) Mode() Mode

Mode return Parser parseQueryErrorMode

func (Parser) Parse 

func (p Parser) Parse(sql string) (Statement, error)

Parse using default dialect MySQl (for backward compatibility)

type PartitionDefinition 

type PartitionDefinition struct {
	Name     ColIdent
	Limit    Expr
	Maxvalue bool
}

PartitionDefinition describes a very minimal partition definition

func (*PartitionDefinition) Format 

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

Format formats the node

type PartitionSpec 

type PartitionSpec struct {
	Action      string
	Name        ColIdent
	Definitions []*PartitionDefinition
}

PartitionSpec describe partition actions (for alter and create)

func (*PartitionSpec) Format 

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

Format formats the node.

type Partitions 

type Partitions Columns

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

func (Partitions) Format 

func (node Partitions) Format(buf *TrackedBuffer)

Format formats the node

type Prepare 

type Prepare struct {
	PreparedStatementName  TableIdent
	ColumnTypes            ColumnTypes
	PreparedStatementQuery PreparedQuery
}

Prepare prepares statement for future execution

func (*Prepare) Format 

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

Format formats the node.

type PreparedQuery 

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

PreparedQuery represents FROM statement in Prepare

func NewPreparedQueryFromString 

func NewPreparedQueryFromString(query string) (PreparedQuery, error)

NewPreparedQueryFromString creates typed statement based on query inside Prepare statement

type RangeCond 

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

RangeCond represents a BETWEEN or a NOT BETWEEN expression.

func (*RangeCond) Format 

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

Format formats the node.

type Returning 

type Returning SelectExprs

Returning represents RETURNING clause from postgresql syntax

func (Returning) Format 

func (node Returning) Format(buf *TrackedBuffer)

Format formats the node.

type Rollback 

type Rollback struct{}

Rollback represents a Rollback statement.

func (*Rollback) Format 

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

Format formats the node.

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
	CastType []byte
	// contains filtered or unexported fields
}

SQLVal represents a single value.

func NewBitVal 

func NewBitVal(in []byte) *SQLVal

NewBitVal builds a new BitVal containing a bit literal.

func NewCastVal 

func NewCastVal(val Expr, castType []byte) *SQLVal

NewCastVal builds new CastVal

func NewDollarExpr 

func NewDollarExpr(value string) (*SQLVal, error)

NewDollarExpr creates new SQLVal from input string

func NewFloatVal 

func NewFloatVal(in []byte) *SQLVal

NewFloatVal builds a new FloatVal.

func NewHexNum 

func NewHexNum(in []byte) *SQLVal

NewHexNum builds a new HexNum.

func NewHexVal 

func NewHexVal(in []byte) *SQLVal

NewHexVal builds a new HexVal.

func NewIntVal 

func NewIntVal(in []byte) *SQLVal

NewIntVal builds a new IntVal.

func NewMySQLDoubleQuotedStrVal 

func NewMySQLDoubleQuotedStrVal(in []byte) (*SQLVal, error)

NewMySQLDoubleQuotedStrVal check that literal may be wrapped with double quotes and return SQLVal if may otherwise error

func NewPgEscapeString 

func NewPgEscapeString(in []byte) *SQLVal

NewPgEscapeString builds a new PgEscapeString

func NewStrVal 

func NewStrVal(in []byte) *SQLVal

NewStrVal builds a new StrVal.

func NewValArg 

func NewValArg(in []byte) *SQLVal

NewValArg builds a new ValArg.

func (*SQLVal) Format 

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

Format formats the node.

func (*SQLVal) HexDecode 

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

HexDecode decodes the hexval into bytes.

type Select 

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

Select represents a SELECT statement.

func (*Select) AddHaving 

func (node *Select) AddHaving(expr Expr)

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

func (*Select) AddOrder 

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

AddOrder adds an order by element

func (*Select) AddWhere 

func (node *Select) AddWhere(expr Expr)

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

func (*Select) Format 

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

Format formats the node.

func (*Select) SetLimit 

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

SetLimit sets the limit clause

type SelectExpr 

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

SelectExpr represents a SELECT expression.

type SelectExprs 

type SelectExprs []SelectExpr

SelectExprs represents SELECT expressions.

func (SelectExprs) Format 

func (node SelectExprs) Format(buf *TrackedBuffer)

Format formats the node.

type SelectStatement 

type SelectStatement interface {
	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 (*Set) Format 

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

Format formats the node.

type SetExpr 

type SetExpr struct {
	Name ColIdent
	Expr Expr
}

SetExpr represents a set expression.

func (*SetExpr) Format 

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

Format formats the node.

type SetExprs 

type SetExprs []*SetExpr

SetExprs represents a list of set expressions.

func (SetExprs) Format 

func (node SetExprs) Format(buf *TrackedBuffer)

Format formats the node.

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

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

Format formats the node.

func (*Show) HasOnTable 

func (node *Show) HasOnTable() bool

HasOnTable returns true if the show statement has an "on" clause

type ShowFilter 

type ShowFilter struct {
	Like   string
	Filter Expr
}

ShowFilter is show tables filter

func (*ShowFilter) Format 

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

Format formats the node.

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

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

Format formats the node.

type Statement 

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

Statement represents a statement.

func ParseNext 

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

ParseNext parses a single SQL statement from the tokenizer returning a Statement which is the AST representation of the query. The tokenizer will always read up to the end of the statement, allowing for the next call to ParseNext to parse any subsequent SQL statements. When there are no more statements to parse, a error of io.EOF is returned.

Example

ExampleParseNext is the second example from the README.md. 

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
}

Output:

func ParseStrictDDL 

func ParseStrictDDL(sql string) (Statement, error)

ParseStrictDDL is the same as Parse except it errors on partially parsed DDL statements.

func ParseWithDialect 

func ParseWithDialect(dialect dialect.Dialect, sql string) (Statement, error)

ParseWithDialect parses the SQL in full withc specified dialect and returns a Statement, which is the AST representation of the query. If a DDL statement is partially parsed but still contains a syntax error, the error is ignored and the DDL is returned anyway.

type Stream 

type Stream struct {
	Comments   Comments
	SelectExpr SelectExpr
	Table      TableName
}

Stream represents a SELECT statement.

func (*Stream) Format 

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

Format formats the node.

type Subquery 

type Subquery struct {
	Select SelectStatement
}

Subquery represents a subquery.

func (*Subquery) Format 

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

Format formats the node.

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

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

Format formats the node.

type TableExpr 

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

TableExpr represents a table expression.

type TableExprs 

type TableExprs []TableExpr

TableExprs represents a list of table expressions.

func (TableExprs) Format 

func (node TableExprs) Format(buf *TrackedBuffer)

Format formats the node.

type TableIdent 

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

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

func GetTableName 

func GetTableName(node SimpleTableExpr) TableIdent

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

func NewTableIdent 

func NewTableIdent(str string) TableIdent

NewTableIdent creates a new TableIdent.

func NewTableIdentWithQuotes 

func NewTableIdentWithQuotes(str string, quote byte) TableIdent

NewTableIdentWithQuotes creates a new TableIdent with flag to escape name

func (TableIdent) CompliantName 

func (node TableIdent) CompliantName() string

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

func (TableIdent) Format 

func (node TableIdent) Format(buf *TrackedBuffer)

Format formats the node.

func (TableIdent) FormatForDialect 

func (node TableIdent) FormatForDialect(dialect dialect.Dialect, buf *TrackedBuffer)

FormatForDialect formats the node for specified dialect

func (TableIdent) IsEmpty 

func (node TableIdent) IsEmpty() bool

IsEmpty returns true if TabIdent is empty.

func (*TableIdent) Lowered 

func (node *TableIdent) Lowered() string

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

func (TableIdent) MarshalJSON 

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

MarshalJSON marshals into JSON.

func (TableIdent) RawValue 

func (node TableIdent) RawValue() string

RawValue returns unescaped value

func (TableIdent) String 

func (node TableIdent) String() string

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

func (*TableIdent) UnmarshalJSON 

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

UnmarshalJSON unmarshals from JSON.

func (*TableIdent) ValueForConfig 

func (node *TableIdent) ValueForConfig() string

ValueForConfig returns lowercased or non-lowercased value depending on configuration (MySQL only) and which quotes were used to wrap the name in SQL, suitable for usage when checking whether the column should be encrypted.

type TableName 

type TableName struct {
	Name, Qualifier TableIdent
}

TableName represents a table name. Qualifier, if specified, represents a database or keyspace. 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 (TableName) Format 

func (node TableName) Format(buf *TrackedBuffer)

Format formats the node.

func (TableName) IsEmpty 

func (node TableName) IsEmpty() bool

IsEmpty returns true if TableName is nil or empty.

func (TableName) ToViewName 

func (node TableName) ToViewName() TableName

ToViewName returns a TableName acceptable for use as a VIEW. VIEW names are always lowercase, so ToViewName lowercasese the name. Databases are case-sensitive so Qualifier is left untouched.

type TableNames 

type TableNames []TableName

TableNames is a list of TableName.

func (TableNames) Format 

func (node TableNames) Format(buf *TrackedBuffer)

Format formats the node.

type TableSpec 

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

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

func (*TableSpec) AddColumn 

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

AddColumn appends the given column to the list in the spec

func (*TableSpec) AddIndex 

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

AddIndex appends the given index to the list in the spec

func (*TableSpec) Format 

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

Format formats the node.

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 NewMySQLStringTokenizer 

func NewMySQLStringTokenizer(sql string) *Tokenizer

NewMySQLStringTokenizer create mysql tokenizer for string

func NewPostgreSQLStringTokenizer 

func NewPostgreSQLStringTokenizer(sql string) *Tokenizer

NewPostgreSQLStringTokenizer create postgresql tokenizer for string

func NewStringTokenizer 

func NewStringTokenizer(sql string) *Tokenizer

NewStringTokenizer creates a new Tokenizer for the sql string. Set dialect MySQL to backward compatibility

func NewStringTokenizerWithDialect 

func NewStringTokenizerWithDialect(dialect dialect.Dialect, sql string) *Tokenizer

NewStringTokenizerWithDialect create Tokenizer for string with specific dialect

func NewTokenizer 

func NewTokenizer(r io.Reader) *Tokenizer

NewTokenizer creates a new Tokenizer reading a sql string from the io.Reader.

func (*Tokenizer) Error 

func (tkn *Tokenizer) Error(err string)

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

func (*Tokenizer) IsMySQL 

func (tkn *Tokenizer) IsMySQL() bool

IsMySQL return true if tokenizer configured with MySQL dialect

func (*Tokenizer) IsPostgreSQL 

func (tkn *Tokenizer) IsPostgreSQL() bool

IsPostgreSQL return true if tokenizer configured with PostgreSQL dialect

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 NodeFormatter) *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) SetDialect 

func (buf *TrackedBuffer) SetDialect(dialect dialect.Dialect)

SetDialect which will be used for formatting

func (*TrackedBuffer) WriteArg 

func (buf *TrackedBuffer) WriteArg(arg string)

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

func (*TrackedBuffer) WriteNode 

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

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

type TupleEqualityList 

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

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

func (*TupleEqualityList) EncodeSQL 

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

EncodeSQL generates the where clause constraints for the tuple equality.

type UnaryExpr 

type UnaryExpr struct {
	Operator string
	Expr     Expr
}

UnaryExpr represents a unary value expression.

func (*UnaryExpr) Format 

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

Format formats the node.

type Union 

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

Union represents a UNION statement.

func (*Union) AddOrder 

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

AddOrder adds an order by element

func (*Union) Format 

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

Format formats the node.

func (*Union) SetLimit 

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

SetLimit sets the limit clause

type Update 

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

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

func (*Update) Format 

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

Format formats the node.

type UpdateExpr 

type UpdateExpr struct {
	Name *ColName
	Expr Expr
}

UpdateExpr represents an update expression.

func (*UpdateExpr) Format 

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

Format formats the node.

type UpdateExprs 

type UpdateExprs []*UpdateExpr

UpdateExprs represents a list of update expressions.

func (UpdateExprs) Format 

func (node UpdateExprs) Format(buf *TrackedBuffer)

Format formats the node.

type Use 

type Use struct {
	DBName TableIdent
}

Use represents a use statement.

func (*Use) Format 

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

Format formats the node.

type UsingInExecuteList 

type UsingInExecuteList []TableIdent

UsingInExecuteList is a set of case sensitive SQL identifiers

func (UsingInExecuteList) Format 

func (node UsingInExecuteList) Format(buf *TrackedBuffer)

Format formats the node

type ValTuple 

type ValTuple Exprs

ValTuple represents a tuple of actual values.

func (ValTuple) Format 

func (node ValTuple) Format(buf *TrackedBuffer)

Format formats the node.

type ValType 

type ValType int

ValType specifies the type for SQLVal.

type Values 

type Values []ValTuple

Values represents a VALUES clause.

func (Values) Format 

func (node Values) Format(buf *TrackedBuffer)

Format formats the node.

type ValuesFuncExpr 

type ValuesFuncExpr struct {
	Name *ColName
}

ValuesFuncExpr represents a function call.

func (*ValuesFuncExpr) Format 

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

Format formats the node.

type VindexParam 

type VindexParam struct {
	Key ColIdent
	Val string
}

VindexParam defines a key/value parameter for a CREATE VINDEX statement

func (VindexParam) Format 

func (node VindexParam) Format(buf *TrackedBuffer)

Format formats the node.

type VindexSpec 

type VindexSpec struct {
	Name   ColIdent
	Type   ColIdent
	Params []VindexParam
}

VindexSpec defines a vindex for a CREATE VINDEX or DROP VINDEX statement

func (*VindexSpec) Format 

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

Format formats the node. The "CREATE VINDEX" preamble was formatted in the containing DDL node Format, so this just prints the type, any parameters, and optionally the owner

func (*VindexSpec) ParseParams 

func (node *VindexSpec) ParseParams() (string, map[string]string)

ParseParams parses the vindex parameter list, pulling out the special-case "owner" parameter

type Visit 

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

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

type When 

type When struct {
	Cond Expr
	Val  Expr
}

When represents a WHEN sub-expression.

func (*When) Format 

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

Format formats the node.

type Where 

type Where struct {
	Type string
	Expr Expr
}

Where represents a WHERE or HAVING clause.

func NewWhere 

func NewWhere(typ string, expr Expr) *Where

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

func (*Where) Format 

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

Format formats the node.

Source Files

View all Source files

Directories

Path Synopsis
dependency
bytes2
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.
querypb
Package query is a generated protocol buffer package.
 Package query is a generated protocol buffer package.
sqltypes
Package sqltypes implements interfaces and types that represent SQL values.
 Package sqltypes implements interfaces and types that represent SQL values.
mysql
postgresql

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.