dataset_sql

package module
v0.0.0-...-6dd5906 Latest Latest
Warning

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

 Go to latest Published: Dec 30, 2017 License: MIT Imports: 23 Imported by: 0

README

dataset_sql

Qri GoDoc License Codecov CI

dataset_sql is the package that makes qri do it's sql trick. for more info check https://qri.io

Getting Involved

We would love involvement from more people! If you notice any errors or would like to submit changes, please see our Contributing Guidelines.

Developing

We've set up a separate document for developer guildlines!

Documentation

Index

Constants

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

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 (
	CreateStr = "create"
	AlterStr  = "alter"
	DropStr   = "drop"
	RenameStr = "rename"
)

DDL strings.

View Source 
const (
	ShowDatabasesStr     = "databases"
	ShowKeyspacesStr     = "vitess_keyspaces"
	ShowShardsStr        = "vitess_shards"
	ShowTablesStr        = "tables"
	ShowVSchemaTablesStr = "vschema_tables"
	ShowUnsupportedStr   = "unsupported"
)

The frollowing constants represent SHOW statements.

View Source 
const (
	JoinStr             = "join"
	StraightJoinStr     = "straight_join"
	LeftJoinStr         = "left join"
	RightJoinStr        = "right join"
	NaturalJoinStr      = "natural join"
	NaturalLeftJoinStr  = "natural left join"
	NaturalRightJoinStr = "natural right join"
)

JoinTableExpr.Join

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

Index hints.

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

Where.Type

View Source 
const (
	EqualStr             = "="
	LessThanStr          = "<"
	GreaterThanStr       = ">"
	LessEqualStr         = "<="
	GreaterEqualStr      = ">="
	NotEqualStr          = "!="
	NullSafeEqualStr     = "<=>"
	InStr                = "in"
	NotInStr             = "not in"
	LikeStr              = "like"
	NotLikeStr           = "not like"
	RegexpStr            = "regexp"
	NotRegexpStr         = "not regexp"
	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
)

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

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

Order.Direction

View Source 
const AGAINST = 57474
View Source 
const ALL = 57361
View Source 
const ALTER = 57432
View Source 
const ANALYZE = 57435
View Source 
const AND = 57405
View Source 
const AS = 57363
View Source 
const ASC = 57365
View Source 
const BETWEEN = 57407
View Source 
const BINARY = 57427
View Source 
const BOOLEAN = 57475
View Source 
const BY = 57357
View Source 
const CASE = 57408
View Source 
const CAST = 57470
View Source 
const CHARACTER = 57458
View Source 
const COLLATE = 57426
View Source 
const COMMENT = 57400
View Source 
const CONVERT = 57469
View Source 
const CREATE = 57431
View Source 
const CROSS = 57387
View Source 
const CURRENT_DATE = 57461
View Source 
const CURRENT_TIME = 57462
View Source 
const CURRENT_TIMESTAMP = 57459
View Source 
const (
	CharacterSetStr = " character set"
)

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

View Source 
const DATABASE = 57460
View Source 
const DATABASES = 57452
View Source 
const DATE = 57447
View Source 
const DEFAULT = 57370
View Source 
const DELETE = 57351
View Source 
const DESC = 57366
View Source 
const DESCRIBE = 57445
View Source 
const DISTINCT = 57362
View Source 
const DIV = 57423
View Source 
const DROP = 57433
View Source 
const DUPLICATE = 57368
View Source 
const ELSE = 57411
View Source 
const END = 57412
View Source 
const ESCAPE = 57448
View Source 
const EXISTS = 57364
View Source 
const EXPANSION = 57479
View Source 
const EXPLAIN = 57446
View Source 
const FALSE = 57403
View Source 
const FLOAT = 57396
View Source 
const FOR = 57360
View Source 
const FORCE = 57390
View Source 
const FROM = 57352
View Source 
const GE = 57414
View Source 
const GROUP = 57354
View Source 
const GROUP_CONCAT = 57471
View Source 
const HAVING = 57355
View Source 
const HEX = 57393
View Source 
const HEXNUM = 57397
View Source 
const ID = 57392
View Source 
const IF = 57441
View Source 
const IGNORE = 57440
View Source 
const IN = 57420
View Source 
const INDEX = 57437
View Source 
const INNER = 57385
View Source 
const INSERT = 57349
View Source 
const INTEGER = 57457
View Source 
const INTEGRAL = 57395
View Source 
const INTERVAL = 57428
View Source 
const INTO = 57367
View Source 
const IS = 57417
View Source 
const JOIN = 57381
View Source 
const JSON_EXTRACT_OP = 57429
View Source 
const JSON_UNQUOTE_EXTRACT_OP = 57430
View Source 
const KEY = 57369
View Source 
const LANGUAGE = 57476
View Source 
const LAST_INSERT_ID = 57374
View Source 
const LE = 57413
View Source 
const LEFT = 57383
View Source 
const LEX_ERROR = 57346
View Source 
const LIKE = 57418
View Source 
const LIMIT = 57358
View Source 
const LIST_ARG = 57399
View Source 
const LOCALTIME = 57463
View Source 
const LOCALTIMESTAMP = 57464
View Source 
const LOCK = 57372
View Source 
const MATCH = 57473
View Source 
const MOD = 57424
View Source 
const MODE = 57378
View Source 
const NATURAL = 57388
View Source 
const NE = 57415
View Source 
const NEXT = 57375
View Source 
const NOT = 57406
View Source 
const NULL = 57401
View Source 
const NULL_SAFE_EQUAL = 57416
View Source 
const OFFSET = 57359
View Source 
const ON = 57391
View Source 
const OPTIMIZE = 57450
View Source 
const OR = 57404
View Source 
const ORDER = 57356
View Source 
const OUTER = 57386
View Source 
const QUERY = 57478
View Source 
const QueryBoolType = q.Type_UINT8

map bool to a unsigned 8 bit int

View Source 
const REGEXP = 57419
View Source 
const RENAME = 57434
View Source 
const REPAIR = 57449
View Source 
const REPLACE = 57468
View Source 
const RIGHT = 57384
View Source 
const SELECT = 57348
View Source 
const SEPARATOR = 57472
View Source 
const SET = 57371
View Source 
const SHARE = 57377
View Source 
const SHIFT_LEFT = 57421
View Source 
const SHIFT_RIGHT = 57422
View Source 
const SHOW = 57444
View Source 
const SQL_CACHE = 57380
View Source 
const SQL_NO_CACHE = 57379
View Source 
const STRAIGHT_JOIN = 57382
View Source 
const STRING = 57394
View Source 
const TABLE = 57436
View Source 
const TABLES = 57453
View Source 
const THEN = 57410
View Source 
const TO = 57439
View Source 
const TRUE = 57402
View Source 
const TRUNCATE = 57451
View Source 
const UNARY = 57425
View Source 
const UNION = 57347
View Source 
const UNIQUE = 57442
View Source 
const UNUSED = 57480
View Source 
const UPDATE = 57350
View Source 
const USE = 57389
View Source 
const USING = 57443
View Source 
const UTC_DATE = 57465
View Source 
const UTC_TIME = 57466
View Source 
const UTC_TIMESTAMP = 57467
View Source 
const VALUE = 57376
View Source 
const VALUES = 57373
View Source 
const VALUE_ARG = 57398
View Source 
const VIEW = 57438
View Source 
const VITESS_KEYSPACES = 57454
View Source 
const VITESS_SHARDS = 57455
View Source 
const VSCHEMA_TABLES = 57456
View Source 
const WHEN = 57409
View Source 
const WHERE = 57353
View Source 
const WITH = 57477

Variables

View Source 
var (
	ErrAggStmt   = fmt.Errorf("this statement only generates an aggregate result row")
	ErrTableStmt = fmt.Errorf("this statement doesn't generate an aggregate result row")
)
View Source 
var (
	// Maximum length for a query in a sqlerror string. 0 means unlimited.
	TruncateUILen  = flag.Int("sql-max-length-ui", 512, "truncate queries in debug UIs to the given length (default 512)")
	TruncateErrLen = flag.Int("sql-max-length-errors", 0, "truncate queries in error logs to the given length (default unlimited)")
)
View Source 
var Aggregates = map[string]bool{
	"avg":          true,
	"bit_and":      true,
	"bit_or":       true,
	"bit_xor":      true,
	"count":        true,
	"group_concat": true,
	"max":          true,
	"min":          true,
	"std":          true,
	"stddev_pop":   true,
	"stddev_samp":  true,
	"stddev":       true,
	"sum":          true,
	"var_pop":      true,
	"var_samp":     true,
	"variance":     true,
}

Aggregates is a map of all aggregate functions.

Functions

func Append 

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

Append appends the SQLNode to the buffer.

func Backtick 

func Backtick(in string) string

Backtick produces a backticked literal given an input string.

func CompareLike 

func CompareLike(str, expr sqltypes.Value) (bool, error)

func EncodeValue 

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

EncodeValue encodes one bind variable value into the query.

func ErrAmbiguousReference 

func ErrAmbiguousReference(ref string) error

func ErrUnrecognizedReference 

func ErrUnrecognizedReference(ref string) error

func Exec 

func Exec(store cafs.Filestore, query *dataset.Transform, options ...func(o *ExecOpt)) (result *dataset.Transform, resultBytes []byte, err error)

func ExtractSetValues 

func ExtractSetValues(sql string) (map[string]interface{}, error)

ExtractSetValues returns a map of key-value pairs if the query is a SET statement. Values can be 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 NewPlanValue 

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

NewPlanValue builds a sqltypes.PlanValue from an Expr.

func NewResultBuffer 

func NewResultBuffer(stmt Statement, aq *dataset.Transform) (dsio.RowReadWriter, error)

NewResultBuffer returns either a *RowBuffer or *dsio.Buffer depending on which is required. RowBuffer is (much) more expensive but supports introspection into already-written rows

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.

func NotYetImplemented 

func NotYetImplemented(feature string) error

NotYetImplemented reports missing features. it'd be lovely to not need this ;)

func PrepareStatement 

func PrepareStatement(stmt Statement, resources map[string]*dataset.Dataset) (err error)

PrepareStatement sets up a statement for exectution. It modifies the passed-in statement making optimizations, associating type information from resources, etc.

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 QueryRecordPath 

func QueryRecordPath(store cafs.Filestore, q *dataset.Transform, opts ...func(o *ExecOpt)) (datastore.Key, error)

QueryRecordPath returns the hash of an abstracted query to be excectuted with a given set of resources. the returned key can be used to see if a a given query has been run before

func RemoveUnusedReferences 

func RemoveUnusedReferences(stmt Statement, q *dataset.Transform) error

RemoveUnusedReferences sets ds.Resources to a new map that that contains only datasets refrerenced in the provided select statement, it errors if it cannot find a named dataset from the provided ds.Resources map.

func ResultStructure 

func ResultStructure(stmt Statement, resources map[string]*dataset.Dataset, opts *ExecOpt) (*dataset.Structure, error)

ResultStructure determines the structure of the output for a select statement and a provided resource table map

func SetSourceRow 

func SetSourceRow(cols []*ColName, sr SourceRow) error

SetSourceRow sets ColName values to the current SourceRow value for evaluation

func SplitTrailingComments 

func SplitTrailingComments(sql string) (query, comments string)

SplitTrailingComments splits the query trailing comments from the query.

func StatementTableNames 

func StatementTableNames(sql string) ([]string, error)

StatementTableNames extracts the names of all referenced tables from a given statement

func String 

func String(node SQLNode) string

String returns a string representation of an SQLNode.

func StringIn 

func StringIn(str string, values ...string) bool

StringIn is a convenience function that returns true if str matches any of the values.

func StripLeadingComments 

func StripLeadingComments(sql string) string

StripLeadingComments trims the SQL string and removes any leading comments

func TruncateForLog 

func TruncateForLog(query string) string

TruncateForLog is used when displaying queries as part of error logs to avoid overwhelming logging systems with potentially long queries and bind value data.

func TruncateForUI 

func TruncateForUI(query string) string

TruncateForUI is used when displaying queries on various Vitess status pages to keep the pages small enough to load and render properly

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 AggFunc 

type AggFunc interface {
	Eval() (q.Type, []byte, error)
	Value() []byte
}

func AggregateFuncs 

func AggregateFuncs(root Statement) (funcs []AggFunc, err error)

AggregateFuncs extracts a slice of any aggregate functions from an AST, while also writing pointers to newly-generated funcs to the AST

type AliasedExpr 

type AliasedExpr struct {
	Expr Expr
	As   ColIdent
}

AliasedExpr defines an aliased SELECT expression.

func (*AliasedExpr) Eval 

func (node *AliasedExpr) Eval() (q.Type, []byte, error)

func (*AliasedExpr) FieldType 

func (node *AliasedExpr) FieldType(from map[string]*dataset.Structure) datatypes.Type

FieldType returns a string representation of the type of field where datatype is one of: "", "string", "integer", "float", "boolean", "date" TODO - this may need rethinking.

func (*AliasedExpr) Format 

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

Format formats the node.

func (*AliasedExpr) ResultName 

func (node *AliasedExpr) ResultName() (name string)

Field returns a name & datatype for the select expr

func (*AliasedExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type AliasedTableExpr 

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

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

func (*AliasedTableExpr) Eval 

func (node *AliasedTableExpr) Eval() (q.Type, []byte, error)

func (*AliasedTableExpr) Format 

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

Format formats the node.

func (*AliasedTableExpr) TableName 

func (node *AliasedTableExpr) TableName() string

func (*AliasedTableExpr) TableNames 

func (node *AliasedTableExpr) TableNames() []string

func (*AliasedTableExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type AndExpr 

type AndExpr struct {
	Left, Right Expr
}

AndExpr represents an AND expression.

func (*AndExpr) Eval 

func (node *AndExpr) Eval() (q.Type, []byte, error)

func (*AndExpr) Format 

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

Format formats the node.

func (*AndExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type BinaryExpr 

type BinaryExpr struct {
	Operator    string
	Left, Right Expr
}

BinaryExpr represents a binary value expression.

func (*BinaryExpr) Eval 

func (node *BinaryExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*BinaryExpr) Format 

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

Format formats the node.

func (*BinaryExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type BoolVal 

type BoolVal bool

BoolVal is true or false.

func (BoolVal) Eval 

func (node BoolVal) Eval() (q.Type, []byte, error)

func (BoolVal) Format 

func (node BoolVal) Format(buf *TrackedBuffer)

Format formats the node.

func (BoolVal) WalkSubtree 

func (node BoolVal) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type CaseExpr 

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

CaseExpr represents a CASE expression.

func (*CaseExpr) Eval 

func (node *CaseExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*CaseExpr) Format 

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

Format formats the node.

func (*CaseExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type ColIdent 

type ColIdent 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 (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) Eval 

func (node ColIdent) Eval() (q.Type, []byte, error)

func (ColIdent) Format 

func (node ColIdent) Format(buf *TrackedBuffer)

Format formats the node.

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

func (node ColIdent) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ColName 

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

ColName represents a column name.

func CollectColNames 

func CollectColNames(stmt Statement) (cols []*ColName)

CollectColNames grabs a slice of pointers to all columns in a given SQL statement, used to avoid re-traversing the tree to find all the places column pointers live

func (*ColName) Equal 

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

Equal returns true if the column names match.

func (*ColName) Eval 

func (node *ColName) Eval() (q.Type, []byte, error)

Eval evaluates the node against a row of data

func (*ColName) Format 

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

Format formats the node.

func (*ColName) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type ColTuple 

type ColTuple interface {
	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) Eval 

func (node *CollateExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*CollateExpr) Format 

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

Format formats the node.

func (*CollateExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Columns 

type Columns []ColIdent

Columns represents an insert column list.

func (Columns) Eval 

func (node Columns) Eval() (q.Type, []byte, error)

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.

func (Columns) WalkSubtree 

func (node Columns) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Comments 

type Comments [][]byte

Comments represents a list of comments.

func (Comments) Eval 

func (node Comments) Eval() (q.Type, []byte, error)

func (Comments) Format 

func (node Comments) Format(buf *TrackedBuffer)

Format formats the node.

func (Comments) WalkSubtree 

func (node Comments) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ComparisonExpr 

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

ComparisonExpr represents a two-value comparison expression.

func (*ComparisonExpr) Compare 

func (node *ComparisonExpr) Compare() (bool, error)

func (*ComparisonExpr) Eval 

func (node *ComparisonExpr) Eval() (q.Type, []byte, error)

func (*ComparisonExpr) Format 

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

Format formats the node.

func (*ComparisonExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type 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) Eval 

func (node *ConvertExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*ConvertExpr) Format 

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

Format formats the node.

func (*ConvertExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

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

func (node *ConvertType) Eval() (q.Type, []byte, error)

func (*ConvertType) Format 

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

Format formats the node.

func (*ConvertType) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type ConvertUsingExpr 

type ConvertUsingExpr struct {
	Expr Expr
	Type string
}

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

func (*ConvertUsingExpr) Eval 

func (node *ConvertUsingExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*ConvertUsingExpr) Format 

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

Format formats the node.

func (*ConvertUsingExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type DDL 

type DDL struct {
	Action   string
	Table    TableName
	NewName  TableName
	IfExists bool
}

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

func (*DDL) Eval 

func (node *DDL) Eval() (q.Type, []byte, error)

func (*DDL) Format 

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

Format formats the node.

func (*DDL) References 

func (node *DDL) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else TODO - finish this

func (*DDL) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Delete 

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

Delete represents a DELETE statement.

func (*Delete) Eval 

func (node *Delete) Eval() (q.Type, []byte, error)

func (*Delete) Format 

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

Format formats the node.

func (*Delete) References 

func (node *Delete) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else TODO - finish this

func (*Delete) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Encodable 

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

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

type ExecOpt 

type ExecOpt struct {
	Format dataset.DataFormat
}

func DefaultExecOpts 

func DefaultExecOpts() *ExecOpt

type ExistsExpr 

type ExistsExpr struct {
	Subquery *Subquery
}

ExistsExpr represents an EXISTS expression.

func (*ExistsExpr) Eval 

func (node *ExistsExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*ExistsExpr) Format 

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

Format formats the node.

func (*ExistsExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Expr 

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

Expr represents an expression.

type Exprs 

type Exprs []Expr

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

func (Exprs) Eval 

func (node Exprs) Eval() (q.Type, []byte, error)

func (Exprs) Format 

func (node Exprs) Format(buf *TrackedBuffer)

Format formats the node.

func (Exprs) WalkSubtree 

func (node Exprs) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type FuncExpr 

type FuncExpr struct {
	Qualifier TableIdent
	Name      ColIdent
	Distinct  bool
	Exprs     SelectExprs
	// contains filtered or unexported fields
}

FuncExpr represents a function call.

func (*FuncExpr) Datatype 

func (node *FuncExpr) Datatype() datatypes.Type

func (*FuncExpr) Eval 

func (node *FuncExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*FuncExpr) Format 

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

Format formats the node.

func (*FuncExpr) Function 

func (node *FuncExpr) Function() (fn AggFunc, err error)

Function gives the backing function to perform

func (*FuncExpr) IsAggregate 

func (node *FuncExpr) IsAggregate() bool

IsAggregate returns true if the function is an aggregate.

func (*FuncExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type GroupBy 

type GroupBy []Expr

GroupBy represents a GROUP BY clause.

func (GroupBy) Eval 

func (node GroupBy) Eval() (q.Type, []byte, error)

func (GroupBy) Format 

func (node GroupBy) Format(buf *TrackedBuffer)

Format formats the node.

func (GroupBy) WalkSubtree 

func (node GroupBy) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type GroupConcatExpr 

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

GroupConcatExpr represents a call to GROUP_CONCAT

func (*GroupConcatExpr) Eval 

func (node *GroupConcatExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*GroupConcatExpr) Format 

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

Format formats the node

func (*GroupConcatExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type IndexHints 

type IndexHints struct {
	Type    string
	Indexes []ColIdent
}

IndexHints represents a list of index hints.

func (IndexHints) Eval 

func (node IndexHints) Eval() (q.Type, []byte, error)

func (*IndexHints) Format 

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

Format formats the node.

func (*IndexHints) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Insert 

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

Insert represents an INSERT or REPLACE statement. Per the MySQL docs, http://dev.mysql.com/doc/refman/5.7/en/replace.html Replace is the counterpart to `INSERT IGNORE`, and works exactly like a normal INSERT except if the row exists. In that case it first deletes the row and re-inserts with new values. For that reason we keep it as an Insert struct. Replaces are currently disallowed in sharded schemas because of the implications the deletion part may have on vindexes.

func (*Insert) Eval 

func (node *Insert) Eval() (q.Type, []byte, error)

func (*Insert) Format 

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

Format formats the node.

func (*Insert) References 

func (node *Insert) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else TODO - add test coverage

func (*Insert) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type InsertRows 

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

InsertRows represents the rows for an INSERT statement.

type 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 ColIdent
}

IntervalExpr represents a date-time INTERVAL expression.

func (*IntervalExpr) Eval 

func (node *IntervalExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*IntervalExpr) Format 

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

Format formats the node.

func (*IntervalExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type IsExpr 

type IsExpr struct {
	Operator string
	Expr     Expr
}

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

func (*IsExpr) Eval 

func (node *IsExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*IsExpr) Format 

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

Format formats the node.

func (*IsExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type JoinTableExpr 

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

JoinTableExpr represents a TableExpr that's a JOIN operation.

func (*JoinTableExpr) Eval 

func (node *JoinTableExpr) Eval() (q.Type, []byte, error)

func (*JoinTableExpr) Format 

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

Format formats the node.

func (*JoinTableExpr) TableNames 

func (node *JoinTableExpr) TableNames() (adrs []string)

func (*JoinTableExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Limit 

type Limit struct {
	Offset, Rowcount Expr
}

Limit represents a LIMIT clause.

func (*Limit) Counts 

func (node *Limit) Counts() (limit, offset int64, err error)

func (*Limit) Eval 

func (node *Limit) Eval() (q.Type, []byte, error)

func (*Limit) Format 

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

Format formats the node.

func (*Limit) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type ListArg 

type ListArg []byte

ListArg represents a named list argument.

func (ListArg) Eval 

func (node ListArg) Eval() (q.Type, []byte, error)

func (ListArg) Format 

func (node ListArg) Format(buf *TrackedBuffer)

Format formats the node.

func (ListArg) WalkSubtree 

func (node ListArg) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type MatchExpr 

type MatchExpr struct {
	Columns SelectExprs
	Expr    Expr
	Option  string
}

MatchExpr represents a call to the MATCH function

func (*MatchExpr) Eval 

func (node *MatchExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*MatchExpr) Format 

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

Format formats the node

func (*MatchExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Nextval 

type Nextval struct {
	Expr Expr
}

Nextval defines the NEXT VALUE expression.

func (Nextval) Eval 

func (node Nextval) Eval() (q.Type, []byte, error)

func (Nextval) FieldType 

func (node Nextval) FieldType(from map[string]*dataset.Structure) datatypes.Type

func (Nextval) Format 

func (node Nextval) Format(buf *TrackedBuffer)

Format formats the node.

func (*Nextval) Value 

func (node *Nextval) Value() (q.Type, []byte, error)

func (Nextval) WalkSubtree 

func (node Nextval) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type NotExpr 

type NotExpr struct {
	Expr Expr
}

NotExpr represents a NOT expression.

func (*NotExpr) Eval 

func (node *NotExpr) Eval() (q.Type, []byte, error)

func (*NotExpr) Format 

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

Format formats the node.

func (*NotExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type NullVal 

type NullVal struct{}

NullVal represents a NULL value.

func (*NullVal) Eval 

func (node *NullVal) Eval() (q.Type, []byte, error)

func (*NullVal) Format 

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

Format formats the node.

func (*NullVal) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type OnDup 

type OnDup UpdateExprs

OnDup represents an ON DUPLICATE KEY clause.

func (OnDup) Eval 

func (node OnDup) Eval() (q.Type, []byte, error)

func (OnDup) Format 

func (node OnDup) Format(buf *TrackedBuffer)

Format formats the node.

func (OnDup) WalkSubtree 

func (node OnDup) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type OrExpr 

type OrExpr struct {
	Left, Right Expr
}

OrExpr represents an OR expression.

func (*OrExpr) Eval 

func (node *OrExpr) Eval() (q.Type, []byte, error)

func (*OrExpr) Format 

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

Format formats the node.

func (*OrExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Order 

type Order struct {
	Expr      Expr
	Direction string
}

Order represents an ordering expression.

func (*Order) Eval 

func (node *Order) Eval() (q.Type, []byte, error)

func (*Order) Format 

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

Format formats the node.

func (*Order) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type OrderBy 

type OrderBy []*Order

OrderBy represents an ORDER By clause.

func (OrderBy) Eval 

func (node OrderBy) Eval() (q.Type, []byte, error)

func (OrderBy) Format 

func (node OrderBy) Format(buf *TrackedBuffer)

Format formats the node.

func (OrderBy) WalkSubtree 

func (node OrderBy) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type 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) Eval 

func (node *OtherAdmin) Eval() (q.Type, []byte, error)

func (*OtherAdmin) Format 

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

Format formats the node.

func (*OtherAdmin) References 

func (node *OtherAdmin) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else TODO - finish this

func (*OtherAdmin) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

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

func (node *OtherRead) Eval() (q.Type, []byte, error)

func (*OtherRead) Format 

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

Format formats the node.

func (*OtherRead) References 

func (node *OtherRead) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else TODO - finish this

func (*OtherRead) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type ParenExpr 

type ParenExpr struct {
	Expr Expr
}

ParenExpr represents a parenthesized boolean expression.

func (*ParenExpr) Eval 

func (node *ParenExpr) Eval() (q.Type, []byte, error)

TODO - finish

func (*ParenExpr) Format 

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

Format formats the node.

func (*ParenExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

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

func (node *ParenSelect) Eval() (q.Type, []byte, error)

func (*ParenSelect) Format 

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

Format formats the node.

func (*ParenSelect) References 

func (node *ParenSelect) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else

func (*ParenSelect) SetLimit 

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

SetLimit sets the limit clause

func (*ParenSelect) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type ParenTableExpr 

type ParenTableExpr struct {
	Exprs TableExprs
}

ParenTableExpr represents a parenthesized list of TableExpr.

func (*ParenTableExpr) Eval 

func (node *ParenTableExpr) Eval() (q.Type, []byte, error)

func (*ParenTableExpr) Format 

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

Format formats the node.

func (*ParenTableExpr) TableNames 

func (node *ParenTableExpr) TableNames() (addrs []string)

func (*ParenTableExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type ParsedQuery 

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

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

func BuildParsedQuery 

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

BuildParsedQuery builds a ParsedQuery from the input.

func GenerateParsedQuery 

func GenerateParsedQuery(node SQLNode) *ParsedQuery

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

func (*ParsedQuery) MarshalJSON 

func (pq *ParsedQuery) MarshalJSON() ([]byte, error)

MarshalJSON is a custom JSON marshaler for ParsedQuery. Note that any queries longer that 512 bytes will be truncated.

type RangeCond 

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

RangeCond represents a BETWEEN or a NOT BETWEEN expression.

func (*RangeCond) Eval 

func (node *RangeCond) Eval() (q.Type, []byte, error)

TODO - finish

func (*RangeCond) Format 

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

Format formats the node.

func (*RangeCond) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type ResultRowGenerator 

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

ResultRowGenerator makes rows from SourceRows calling eval on a set of select expressions from a given SourceRow

func NewResultRowGenerator 

func NewResultRowGenerator(sel *Select, result *dataset.Structure) (rg *ResultRowGenerator, err error)

func (*ResultRowGenerator) GenerateAggregateRow 

func (rg *ResultRowGenerator) GenerateAggregateRow() ([][]byte, error)

func (*ResultRowGenerator) GenerateRow 

func (rg *ResultRowGenerator) GenerateRow() ([][]byte, error)

GenerateRow generates a row

func (*ResultRowGenerator) HasAggregates 

func (rg *ResultRowGenerator) HasAggregates() bool

func (*ResultRowGenerator) Structure 

func (rg *ResultRowGenerator) Structure() *dataset.Structure

type SQLNode 

type SQLNode interface {
	Format(buf *TrackedBuffer)
	// WalkSubtree calls visit on all underlying nodes
	// of the subtree, but not the current one. Walking
	// must be interrupted if visit returns an error.
	WalkSubtree(visit Visit) error
	Eval() (pbquery.Type, []byte, error)
}

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

type SQLVal 

type SQLVal struct {
	Type ValType
	Val  []byte
}

SQLVal represents a single value.

func 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 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) Bytes 

func (node *SQLVal) Bytes() []byte

Bytes returns the node values TODO - alter output based on value type? eg: do Hex Values need to change their output?

func (*SQLVal) Eval 

func (node *SQLVal) Eval() (q.Type, []byte, error)

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.

func (*SQLVal) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

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

func (node *Select) Eval() (q.Type, []byte, error)

func (*Select) Format 

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

Format formats the node.

func (*Select) References 

func (node *Select) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else

func (*Select) SetLimit 

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

SetLimit sets the limit clause

func (*Select) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type SelectExpr 

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

SelectExpr represents a SELECT expression.

type SelectExprs 

type SelectExprs []SelectExpr

SelectExprs represents SELECT expressions.

func (SelectExprs) Eval 

func (node SelectExprs) Eval() (q.Type, []byte, error)

func (SelectExprs) FieldTypes 

func (nodes SelectExprs) FieldTypes(from map[string]*dataset.Structure) (types []datatypes.Type)

func (SelectExprs) Format 

func (node SelectExprs) Format(buf *TrackedBuffer)

Format formats the node.

func (SelectExprs) Values 

func (nodes SelectExprs) Values() (types []q.Type, vals [][]byte, err error)

func (SelectExprs) WalkSubtree 

func (node SelectExprs) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type SelectStatement 

type SelectStatement interface {
	AddOrder(*Order)
	SetLimit(*Limit)

	References() []string
	SQLNode
	// contains filtered or unexported methods
}

SelectStatement any SELECT statement.

type Set 

type Set struct {
	Comments Comments
	Exprs    UpdateExprs
}

Set represents a SET statement.

func (*Set) Eval 

func (node *Set) Eval() (q.Type, []byte, error)

func (*Set) Format 

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

Format formats the node.

func (*Set) References 

func (node *Set) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else TODO - finish this

func (*Set) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Show 

type Show struct {
	Type string
}

Show represents a show statement.

func (*Show) Eval 

func (node *Show) Eval() (q.Type, []byte, error)

func (*Show) Format 

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

Format formats the node.

func (*Show) References 

func (node *Show) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else TODO - finish this

func (*Show) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type SimpleTableExpr 

type SimpleTableExpr interface {
	TableName() string
	// SetTableName(string)
	SQLNode
	// contains filtered or unexported methods
}

SimpleTableExpr represents a simple table expression.

type SourceRow 

type SourceRow map[string][][]byte

SourceRow is a row of data from a number of different tables identitifed by a string

func (SourceRow) String 

func (sr SourceRow) String() string

String implements the stringer interface for SourceRow

type SourceRowFilter 

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

SourceRowFilter uses type-populated AST to evaluate candidate SourceRows to see if they should be added to the resulting dataset internal state for example, things like current status in a LIMIT / OFFSET

func NewSourceRowFilter 

func NewSourceRowFilter(ast Statement, buf dsio.RowReadWriter) (srf *SourceRowFilter, err error)

func (*SourceRowFilter) Done 

func (srf *SourceRowFilter) Done() bool

Done indicates we don't need to iterate anymore

func (*SourceRowFilter) Match 

func (srf *SourceRowFilter) Match() bool

Match returns weather the row should be allowed to pass through to the table

func (*SourceRowFilter) ShouldWriteRow 

func (srf *SourceRowFilter) ShouldWriteRow(row [][]byte) bool

ShouldWriteRow checks to see if a row should be written to a destination

type SourceRowGenerator 

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

SourcRowGenerator consumes dataset data readers generating SourceRows. It's main job is to generate the exhastive set of candidate row combinations for comparison

func NewSourceRowGenerator 

func NewSourceRowGenerator(store cafs.Filestore, resources map[string]*dataset.Dataset) (*SourceRowGenerator, error)

NewSourceRowGenerator initializes a source row generator

func (*SourceRowGenerator) Next 

func (srg *SourceRowGenerator) Next() bool

func (*SourceRowGenerator) Row 

func (srg *SourceRowGenerator) Row() (SourceRow, error)

type StarExpr 

type StarExpr struct {
	TableName TableName
}

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

func (*StarExpr) Eval 

func (node *StarExpr) Eval() (q.Type, []byte, error)

func (*StarExpr) FieldTypes 

func (node *StarExpr) FieldTypes(from map[string]*dataset.Structure) (types []datatypes.Type)

func (*StarExpr) Format 

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

Format formats the node.

func (*StarExpr) Values 

func (node *StarExpr) Values() ([]q.Type, [][]byte, error)

func (*StarExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Statement 

type Statement interface {
	References() []string
	SQLNode
	// contains filtered or unexported methods
}

Statement represents a statement.

func Format 

func Format(q *dataset.Transform, opts ...func(o *ExecOpt)) (stmt Statement, abst *dataset.Transform, err error)

Format places an sql statement in it's standard form. This will be *heavily* refined, improved, and moved into a separate package TODO - ^^ It's expected that the query to be exectuted will be a string in the given datset.Data value Format will modify the incoming

func Parse 

func Parse(sql string) (Statement, error)

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

func RemapReferences 

func RemapReferences(stmt *Select, remap map[string]string, a, b map[string]*dataset.Structure) (Statement, error)

RemapReferences re-writes all table and table column references from remap key to remap value Remap will destroy any table-aliasing ("as" statements) TODO - generalize to apply to Statement instead of *Select TODO - need to finish support for remapping column refs

type StructureRef 

type StructureRef struct {
	TableName string
	ColIndex  int
	Field     *dataset.Field
	QueryType q.Type
}

StructureRef is placed on ColName SQLNodes to connect typing & data lookup information

type Subquery 

type Subquery struct {
	Select SelectStatement
}

Subquery represents a subquery.

func (*Subquery) Bytes 

func (node *Subquery) Bytes() []byte

func (*Subquery) Eval 

func (node *Subquery) Eval() (q.Type, []byte, error)

TODO - finish

func (*Subquery) Format 

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

Format formats the node.

func (*Subquery) TableName 

func (node *Subquery) TableName() string

func (*Subquery) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type TableExpr 

type TableExpr interface {
	TableNames() []string
	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) Eval 

func (node TableExprs) Eval() (q.Type, []byte, error)

func (TableExprs) Format 

func (node TableExprs) Format(buf *TrackedBuffer)

Format formats the node.

func (TableExprs) TableNames 

func (node TableExprs) TableNames() (names []string)

func (TableExprs) WalkSubtree 

func (node TableExprs) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

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. TODO - this might not be needed?

func (TableIdent) CompliantName 

func (node TableIdent) CompliantName() string

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

func (TableIdent) Eval 

func (node TableIdent) Eval() (q.Type, []byte, error)

func (TableIdent) Format 

func (node TableIdent) Format(buf *TrackedBuffer)

Format formats the node.

func (TableIdent) IsEmpty 

func (node TableIdent) IsEmpty() bool

IsEmpty returns true if TabIdent is empty.

func (TableIdent) MarshalJSON 

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

MarshalJSON marshals into JSON.

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

func (node TableIdent) TableName() string

func (*TableIdent) UnmarshalJSON 

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

UnmarshalJSON unmarshals from JSON.

func (TableIdent) WalkSubtree 

func (node TableIdent) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type TableName 

type TableName struct {
	Name, Qualifier TableIdent
}

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

func (node TableName) Eval() (q.Type, []byte, error)

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

func (node TableName) String() string

func (TableName) TableName 

func (node TableName) TableName() string

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.

func (TableName) WalkSubtree 

func (node TableName) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type TableNames 

type TableNames []TableName

TableNames is a list of TableName.

func (TableNames) Eval 

func (node TableNames) Eval() (q.Type, []byte, error)

func (TableNames) Format 

func (node TableNames) Format(buf *TrackedBuffer)

Format formats the node.

func (TableNames) TableNames 

func (node TableNames) TableNames() []string

func (TableNames) WalkSubtree 

func (node TableNames) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Tokenizer 

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

	Position int

	LastError string

	ParseTree Statement
	// contains filtered or unexported fields
}

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

func NewStringTokenizer 

func NewStringTokenizer(sql string) *Tokenizer

NewStringTokenizer creates a new Tokenizer for the sql string.

func (*Tokenizer) Error 

func (tkn *Tokenizer) Error(err string)

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

func (*Tokenizer) Lex 

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

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

func (*Tokenizer) Scan 

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

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

type TrackedBuffer 

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

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

func NewTrackedBuffer 

func NewTrackedBuffer(nodeFormatter func(buf *TrackedBuffer, node SQLNode)) *TrackedBuffer

NewTrackedBuffer creates a new TrackedBuffer.

func (*TrackedBuffer) HasBindVars 

func (buf *TrackedBuffer) HasBindVars() bool

HasBindVars returns true if the parsed query uses bind vars.

func (*TrackedBuffer) Myprintf 

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

Myprintf mimics fmt.Fprintf(buf, ...), but limited to Node(%v), Node.Value(%s) and string(%s). It also allows a %a for a value argument, in which case it adds tracking info for future substitutions.

The name must be something other than the usual Printf() to avoid "go vet" warnings due to our custom format specifiers.

func (*TrackedBuffer) ParsedQuery 

func (buf *TrackedBuffer) ParsedQuery() *ParsedQuery

ParsedQuery returns a ParsedQuery that contains bind locations for easy substitution.

func (*TrackedBuffer) WriteArg 

func (buf *TrackedBuffer) WriteArg(arg string)

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

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

func (node *UnaryExpr) Eval() (q.Type, []byte, error)

func (*UnaryExpr) Format 

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

Format formats the node.

func (*UnaryExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Union 

type Union struct {
	Type        string
	Left, Right SelectStatement
	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) Eval 

func (node *Union) Eval() (q.Type, []byte, error)

func (*Union) Format 

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

Format formats the node.

func (*Union) References 

func (node *Union) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else TODO - write tests to confirm this works, for instance, do we need to deduplicate between left & right references? would that be an err?

func (*Union) SetLimit 

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

SetLimit sets the limit clause

func (*Union) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Update 

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

Update represents an UPDATE statement.

func (*Update) Eval 

func (node *Update) Eval() (q.Type, []byte, error)

func (*Update) Format 

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

Format formats the node.

func (*Update) References 

func (node *Update) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else TODO - finish this

func (*Update) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type UpdateExpr 

type UpdateExpr struct {
	Name *ColName
	Expr Expr
}

UpdateExpr represents an update expression.

func (*UpdateExpr) Eval 

func (node *UpdateExpr) Eval() (q.Type, []byte, error)

func (*UpdateExpr) Format 

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

Format formats the node.

func (*UpdateExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type UpdateExprs 

type UpdateExprs []*UpdateExpr

UpdateExprs represents a list of update expressions.

func (UpdateExprs) Eval 

func (node UpdateExprs) Eval() (q.Type, []byte, error)

func (UpdateExprs) Format 

func (node UpdateExprs) Format(buf *TrackedBuffer)

Format formats the node.

func (UpdateExprs) WalkSubtree 

func (node UpdateExprs) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type Use 

type Use struct {
	DBName TableIdent
}

Use represents a use statement.

func (*Use) Eval 

func (node *Use) Eval() (q.Type, []byte, error)

func (*Use) Format 

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

Format formats the node.

func (*Use) References 

func (node *Use) References() []string

References returns a slice of the table names this statement refers to This was added by b5. TODO - determine weather this can be removed in favour of something else TODO - finish this

func (*Use) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type ValTuple 

type ValTuple Exprs

ValTuple represents a tuple of actual values.

func (ValTuple) Eval 

func (node ValTuple) Eval() (q.Type, []byte, error)

func (ValTuple) Format 

func (node ValTuple) Format(buf *TrackedBuffer)

Format formats the node.

func (ValTuple) WalkSubtree 

func (node ValTuple) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ValType 

type ValType int

ValType specifies the type for SQLVal.

type Values 

type Values []ValTuple

Values represents a VALUES clause.

func (Values) Eval 

func (node Values) Eval() (q.Type, []byte, error)

func (Values) Format 

func (node Values) Format(buf *TrackedBuffer)

Format formats the node.

func (Values) WalkSubtree 

func (node Values) WalkSubtree(visit Visit) error

WalkSubtree walks the nodes of the subtree.

type ValuesFuncExpr 

type ValuesFuncExpr struct {
	Name     ColIdent
	Resolved Expr
}

ValuesFuncExpr represents a function call.

func (*ValuesFuncExpr) Eval 

func (node *ValuesFuncExpr) Eval() (q.Type, []byte, error)

func (*ValuesFuncExpr) Format 

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

Format formats the node.

func (*ValuesFuncExpr) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Visit 

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

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

type When 

type When struct {
	Cond Expr
	Val  Expr
}

When represents a WHEN sub-expression.

func (*When) Eval 

func (node *When) Eval() (q.Type, []byte, error)

func (*When) Format 

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

Format formats the node.

func (*When) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

type Where 

type Where struct {
	Type string
	Expr 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) Eval 

func (node *Where) Eval() (q.Type, []byte, error)

func (*Where) Format 

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

Format formats the node.

func (*Where) WalkSubtree 

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

WalkSubtree walks the nodes of the subtree.

Source Files

View all Source files

Directories

Path Synopsis
deps
cistring
Package cistring implements a case-insensitive string type.
 Package cistring implements a case-insensitive string type.
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.
proto/query
Package query is a generated protocol buffer package.
 Package query is a generated protocol buffer package.
proto/topodata
Package topodata is a generated protocol buffer package.
 Package topodata is a generated protocol buffer package.
proto/vtrpc
Package vtrpc is a generated protocol buffer package.
 Package vtrpc 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.
Package event provides a reflect-based framework for low-frequency global dispatching of events, which are values of any arbitrary type, to a set of listener functions, which are usually registered by plugin packages during init().
 Package event provides a reflect-based framework for low-frequency global dispatching of events, which are values of any arbitrary type, to a set of listener functions, which are usually registered by plugin packages during init().
syslogger
Package syslogger uses the event package to listen for any event that implements the Syslogger interface.
 Package syslogger uses the event package to listen for any event that implements the Syslogger interface.
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.
Package sqltypes implements interfaces and types that represent SQL values.
 Package sqltypes implements interfaces and types that represent SQL values.
Package tb exposes some handy traceback functionality buried in the runtime.
 Package tb exposes some handy traceback functionality buried in the runtime.
vt
logutil
proto/logutil
Package logutil is a generated protocol buffer package.
 Package logutil is a generated protocol buffer package.
proto/query
Package query is a generated protocol buffer package.
 Package query is a generated protocol buffer package.
proto/topodata
Package topodata is a generated protocol buffer package.
 Package topodata is a generated protocol buffer package.
proto/vtgate
Package vtgate is a generated protocol buffer package.
 Package vtgate is a generated protocol buffer package.
proto/vtgateservice
Package vtgateservice is a generated protocol buffer package.
 Package vtgateservice is a generated protocol buffer package.
proto/vtrpc
Package vtrpc is a generated protocol buffer package.
 Package vtrpc is a generated protocol buffer package.
vterrors
Package vterrors provides helpers for propagating internal errors through the Vitess system (including across RPC boundaries) in a structured way.
 Package vterrors provides helpers for propagating internal errors through the Vitess system (including across RPC boundaries) in a structured way.

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.