evalengine

package
v0.15.10 Latest Latest
Warning

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

 Go to latest Published: Jul 31, 2024 License: Apache-2.0 Imports: 48 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrEvaluatedExprNotSupported = "expr cannot be evaluated, not supported"
View Source 
var ErrHashCoercionIsNotExact = vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "cannot coerce into target type without losing precision")
View Source 
var ErrTranslateExprNotSupported = "expr cannot be translated, not supported"
View Source 
var NullExpr = &Literal{}

NullExpr is just what you are lead to believe

View Source 
var SystemTime = time.Now
View Source 
var UnsupportedCollationHashError = vterrors.Errorf(vtrpcpb.Code_INTERNAL, "text type with an unknown/unsupported collation cannot be hashed")

UnsupportedCollationHashError is returned when we try to get the hash value and are missing the collation to use

Functions

func CoerceTo 

func CoerceTo(value sqltypes.Value, typ Type, sqlmode SQLMode) (sqltypes.Value, error)

func NullsafeCompare 

func NullsafeCompare(v1, v2 sqltypes.Value, collationEnv *collations.Environment, collationID collations.ID, values *EnumSetValues) (int, error)

NullsafeCompare returns 0 if v1==v2, -1 if v1<v2, and 1 if v1>v2. NULL is the lowest value. If any value is numeric, then a numeric comparison is performed after necessary conversions. If none are numeric, then it's a simple binary comparison. Uncomparable values return an error.

func NullsafeHashcode128 

func NullsafeHashcode128(hash *vthash.Hasher, v sqltypes.Value, collation collations.ID, coerceTo sqltypes.Type, sqlmode SQLMode, values *EnumSetValues) error

NullsafeHashcode128 returns a 128-bit hashcode that is guaranteed to be the same for two values that are considered equal by `NullsafeCompare`. This can be used to avoid having to do comparison checks after a hash, since we consider the 128 bits of entropy enough to guarantee uniqueness.

func PanicHandler 

func PanicHandler(err *error)

func TinyWeighter 

func TinyWeighter(f *querypb.Field, collation collations.ID) func(v *sqltypes.Value)

TinyWeighter returns a callback to apply a Tiny Weight string to a sqltypes.Value. A tiny weight string is a compressed 4-byte representation of the value's full weight string that sorts identically to its full weight. Obviously, the tiny weight string can collide because it's represented in fewer bytes than the full one. Hence, for any 2 instances of sqltypes.Value: if both instances have a Tiny Weight string, and the weight strings are **different**, the two values will sort accordingly to the 32-bit numerical sort of their tiny weight strings. Otherwise, the relative sorting of the two values will not be known, and they will require a full sort using e.g. NullsafeCompare.

func WeightString 

func WeightString(dst []byte, v sqltypes.Value, coerceTo sqltypes.Type, col collations.ID, length, precision int, values *EnumSetValues, sqlmode SQLMode) ([]byte, bool, error)

WeightString returns the weight string for a value. It appends to dst if an existing slice is given, otherwise it returns a new one. The returned boolean indicates whether the weight string is a fixed-width weight string, such as for fixed size integer values. Our WeightString implementation supports more types that MySQL externally communicates with the `WEIGHT_STRING` function, so that we can also use this to order / sort other types like Float and Decimal as well.

Types

type Arena 

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

Arena is an arena memory allocator for eval types. It allocates the types from reusable slices to prevent heap allocations. After each evaluation execution, (*Arena).reset() should be called to reset the arena.

type ArithmeticExpr 

type ArithmeticExpr struct {
	BinaryExpr
	Op opArith
}

func (*ArithmeticExpr) CachedSize 

func (cached *ArithmeticExpr) CachedSize(alloc bool) int64

type BinaryExpr 

type BinaryExpr struct {
	Left, Right IR
}

func (*BinaryExpr) CachedSize 

func (cached *BinaryExpr) CachedSize(alloc bool) int64

type BindVariable 

type BindVariable struct {
	Key       string
	Type      sqltypes.Type
	Collation collations.ID
	// contains filtered or unexported fields
}

func NewBindVar 

func NewBindVar(key string, typ Type) *BindVariable

NewBindVar returns a bind variable

func NewBindVarTuple 

func NewBindVarTuple(key string, coll collations.ID) *BindVariable

NewBindVarTuple returns a bind variable containing a tuple

func (*BindVariable) CachedSize 

func (cached *BindVariable) CachedSize(alloc bool) int64

func (*BindVariable) Format 

func (bv *BindVariable) Format(buf *sqlparser.TrackedBuffer)

func (*BindVariable) FormatFast 

func (bv *BindVariable) FormatFast(buf *sqlparser.TrackedBuffer)

func (*BindVariable) IR 

func (bv *BindVariable) IR() IR

func (*BindVariable) IsExpr 

func (bv *BindVariable) IsExpr()

type BitwiseExpr 

type BitwiseExpr struct {
	BinaryExpr
	Op opBit
}

func (*BitwiseExpr) CachedSize 

func (cached *BitwiseExpr) CachedSize(alloc bool) int64

type BitwiseNotExpr 

type BitwiseNotExpr struct {
	UnaryExpr
}

func (*BitwiseNotExpr) CachedSize 

func (cached *BitwiseNotExpr) CachedSize(alloc bool) int64

type CallExpr 

type CallExpr struct {
	Arguments TupleExpr
	Method    string
}

func (*CallExpr) CachedSize 

func (cached *CallExpr) CachedSize(alloc bool) int64

type CaseExpr 

type CaseExpr struct {
	Else IR
	// contains filtered or unexported fields
}

func (*CaseExpr) CachedSize 

func (cached *CaseExpr) CachedSize(alloc bool) int64

type CollateExpr 

type CollateExpr struct {
	UnaryExpr
	TypedCollation collations.TypedCollation
	CollationEnv   *collations.Environment
}

func (*CollateExpr) CachedSize 

func (cached *CollateExpr) CachedSize(alloc bool) int64

type Column 

type Column struct {
	Offset    int
	Type      sqltypes.Type
	Size      int32
	Scale     int32
	Collation collations.TypedCollation
	Original  sqlparser.Expr
	Nullable  bool
	Values    *EnumSetValues // For ENUM and SET types
	// contains filtered or unexported fields
}

func NewColumn 

func NewColumn(offset int, typ Type, original sqlparser.Expr) *Column

NewColumn returns a column expression

func (*Column) CachedSize 

func (cached *Column) CachedSize(alloc bool) int64

func (*Column) Format 

func (c *Column) Format(buf *sqlparser.TrackedBuffer)

func (*Column) FormatFast 

func (c *Column) FormatFast(buf *sqlparser.TrackedBuffer)

func (*Column) IR 

func (c *Column) IR() IR

func (*Column) IsExpr 

func (c *Column) IsExpr()

type ColumnResolver 

type ColumnResolver func(name *sqlparser.ColName) (int, error)

type Comparison 

type Comparison []OrderByParams

OrderByParams specifies the parameters for ordering. This is used for merge-sorting scatter queries.

func (Comparison) ApplyTinyWeights 

func (cmp Comparison) ApplyTinyWeights(out *sqltypes.Result)

func (Comparison) Compare 

func (cmp Comparison) Compare(a, b sqltypes.Row) int

func (Comparison) Less 

func (cmp Comparison) Less(a, b sqltypes.Row) bool

func (Comparison) More 

func (cmp Comparison) More(a, b sqltypes.Row) bool

func (Comparison) Sort 

func (cmp Comparison) Sort(out []sqltypes.Row)

func (Comparison) SortResult 

func (cmp Comparison) SortResult(out *sqltypes.Result) (err error)

type ComparisonExpr 

type ComparisonExpr struct {
	BinaryExpr
	Op ComparisonOp
}

func (*ComparisonExpr) CachedSize 

func (cached *ComparisonExpr) CachedSize(alloc bool) int64

type ComparisonOp 

type ComparisonOp interface {
	String() string
	// contains filtered or unexported methods
}

type CompiledExpr 

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

func (*CompiledExpr) CachedSize 

func (cached *CompiledExpr) CachedSize(alloc bool) int64

func (*CompiledExpr) Format 

func (p *CompiledExpr) Format(buf *sqlparser.TrackedBuffer)

func (*CompiledExpr) FormatFast 

func (p *CompiledExpr) FormatFast(buf *sqlparser.TrackedBuffer)

func (*CompiledExpr) IR 

func (c *CompiledExpr) IR() IR

func (*CompiledExpr) IsExpr 

func (c *CompiledExpr) IsExpr()

type CompilerLog 

type CompilerLog interface {
	Instruction(ins string, args ...any)
	Stack(old, new int)
}

type Config 

type Config struct {
	ResolveColumn ColumnResolver
	ResolveType   TypeResolver

	Collation         collations.ID
	NoConstantFolding bool
	NoCompilation     bool
	SQLMode           SQLMode
	Environment       *vtenv.Environment
}

type ConvertExpr 

type ConvertExpr struct {
	UnaryExpr
	Type          string
	Length, Scale *int
	Collation     collations.ID
	CollationEnv  *collations.Environment
}

func (*ConvertExpr) CachedSize 

func (cached *ConvertExpr) CachedSize(alloc bool) int64

type ConvertUsingExpr 

type ConvertUsingExpr struct {
	UnaryExpr
	Collation    collations.ID
	CollationEnv *collations.Environment
}

func (*ConvertUsingExpr) CachedSize 

func (cached *ConvertUsingExpr) CachedSize(alloc bool) int64

type EnumSetValues 

type EnumSetValues []string

func (*EnumSetValues) Equal 

func (v *EnumSetValues) Equal(other *EnumSetValues) bool

type EvalResult 

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

func (EvalResult) Collation 

func (er EvalResult) Collation() collations.ID

func (EvalResult) MustBoolean 

func (er EvalResult) MustBoolean() bool

func (EvalResult) String 

func (er EvalResult) String() string

func (EvalResult) ToBoolean 

func (er EvalResult) ToBoolean() bool

func (EvalResult) ToBooleanStrict 

func (er EvalResult) ToBooleanStrict() (bool, error)

ToBooleanStrict is used when the casting to a boolean has to be minimally forgiving, such as when assigning to a system variable that is expected to be a boolean

func (EvalResult) TupleValues 

func (er EvalResult) TupleValues() []sqltypes.Value

TupleValues allows for retrieval of the value we expose for public consumption

func (EvalResult) Value 

func (er EvalResult) Value(id collations.ID) sqltypes.Value

Value allows for retrieval of the value we expose for public consumption. It will be converted to the passed in collation which is the connection collation and what the client expects the result to be in.

type Expr 

type Expr interface {
	sqlparser.Expr
	IR() IR
	// contains filtered or unexported methods
}

Expr is a compiled expression that can be evaluated and serialized back to SQL.

func Translate 

func Translate(e sqlparser.Expr, cfg *Config) (Expr, error)

type ExpressionEnv 

type ExpressionEnv struct {
	BindVars map[string]*querypb.BindVariable
	Row      []sqltypes.Value
	Fields   []*querypb.Field
	// contains filtered or unexported fields
}

ExpressionEnv contains the environment that the expression evaluates in, such as the current row and bindvars

func EmptyExpressionEnv 

func EmptyExpressionEnv(env *vtenv.Environment) *ExpressionEnv

EmptyExpressionEnv returns a new ExpressionEnv with no bind vars or row

func NewExpressionEnv 

func NewExpressionEnv(ctx context.Context, bindVars map[string]*querypb.BindVariable, vc VCursor) *ExpressionEnv

NewExpressionEnv returns an expression environment with no current row, but with bindvars

func (*ExpressionEnv) Evaluate 

func (env *ExpressionEnv) Evaluate(expr Expr) (EvalResult, error)

func (*ExpressionEnv) EvaluateAST 

func (env *ExpressionEnv) EvaluateAST(expr Expr) (EvalResult, error)

func (*ExpressionEnv) EvaluateVM 

func (env *ExpressionEnv) EvaluateVM(p *CompiledExpr) (EvalResult, error)

func (*ExpressionEnv) SetTime 

func (env *ExpressionEnv) SetTime(now time.Time)

func (*ExpressionEnv) TypeOf 

func (env *ExpressionEnv) TypeOf(expr Expr) (Type, error)

func (*ExpressionEnv) VCursor 

func (env *ExpressionEnv) VCursor() VCursor

type FieldResolver 

type FieldResolver []*querypb.Field

func (FieldResolver) Column 

func (fields FieldResolver) Column(col *sqlparser.ColName) (int, error)

func (FieldResolver) Type 

func (fields FieldResolver) Type(expr sqlparser.Expr) (Type, bool)

type FilterExpr 

type FilterExpr interface {
	BinaryExpr
	// contains filtered or unexported methods
}

type HashCode 

type HashCode = uint64

HashCode is a type alias to the code easier to read

func NullsafeHashcode 

func NullsafeHashcode(v sqltypes.Value, collation collations.ID, coerceType sqltypes.Type, sqlmode SQLMode, values *EnumSetValues) (HashCode, error)

NullsafeHashcode returns an int64 hashcode that is guaranteed to be the same for two values that are considered equal by `NullsafeCompare`.

type IR 

type IR interface {
	// contains filtered or unexported methods
}

IR is the interface that all evaluation nodes must implement. It can only be used to match the AST of the compiled expression for planning purposes. IR objects cannot be evaluated directly.

type InExpr 

type InExpr struct {
	BinaryExpr
	Negate bool
}

func (*InExpr) CachedSize 

func (cached *InExpr) CachedSize(alloc bool) int64

type IntervalExpr 

type IntervalExpr struct {
	CallExpr
}

func (*IntervalExpr) CachedSize 

func (cached *IntervalExpr) CachedSize(alloc bool) int64

type IntroducerExpr 

type IntroducerExpr struct {
	UnaryExpr
	TypedCollation collations.TypedCollation
	CollationEnv   *collations.Environment
}

func (*IntroducerExpr) CachedSize 

func (cached *IntroducerExpr) CachedSize(alloc bool) int64

type IsExpr 

type IsExpr struct {
	UnaryExpr
	Op    sqlparser.IsExprOperator
	Check func(eval) bool
}

IsExpr represents the IS expression in MySQL. boolean_primary IS [NOT] {TRUE | FALSE | NULL}

func (*IsExpr) CachedSize 

func (cached *IsExpr) CachedSize(alloc bool) int64

type LikeExpr 

type LikeExpr struct {
	BinaryExpr
	Negate         bool
	Match          colldata.WildcardPattern
	MatchCollation collations.ID
}

func (*LikeExpr) CachedSize 

func (cached *LikeExpr) CachedSize(alloc bool) int64

type Literal 

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

func NewLiteralBinary 

func NewLiteralBinary(val []byte) *Literal

func NewLiteralBinaryFromBit 

func NewLiteralBinaryFromBit(val []byte) (*Literal, error)

func NewLiteralBinaryFromHex 

func NewLiteralBinaryFromHex(val []byte) (*Literal, error)

func NewLiteralBinaryFromHexNum 

func NewLiteralBinaryFromHexNum(val []byte) (*Literal, error)

func NewLiteralBool 

func NewLiteralBool(b bool) *Literal

func NewLiteralDateFromBytes 

func NewLiteralDateFromBytes(val []byte) (*Literal, error)

NewLiteralDateFromBytes returns a literal expression.

func NewLiteralDatetimeFromBytes 

func NewLiteralDatetimeFromBytes(val []byte) (*Literal, error)

NewLiteralDatetimeFromBytes returns a literal expression. it validates the datetime by parsing it and checking the error.

func NewLiteralDecimalFromBytes 

func NewLiteralDecimalFromBytes(val []byte) (*Literal, error)

func NewLiteralFloat 

func NewLiteralFloat(val float64) *Literal

NewLiteralFloat returns a literal expression

func NewLiteralFloatFromBytes 

func NewLiteralFloatFromBytes(val []byte) (*Literal, error)

NewLiteralFloatFromBytes returns a float literal expression from a slice of bytes

func NewLiteralInt 

func NewLiteralInt(i int64) *Literal

NewLiteralInt returns a literal expression

func NewLiteralIntegralFromBytes 

func NewLiteralIntegralFromBytes(val []byte) (*Literal, error)

NewLiteralIntegralFromBytes returns a literal expression. It tries to return an int64, but if the value is too large, it tries with an uint64

func NewLiteralString 

func NewLiteralString(val []byte, collation collations.TypedCollation) *Literal

NewLiteralString returns a literal expression

func NewLiteralTimeFromBytes 

func NewLiteralTimeFromBytes(val []byte) (*Literal, error)

NewLiteralTimeFromBytes returns a literal expression. it validates the time by parsing it and checking the error.

func NewLiteralUint 

func NewLiteralUint(i uint64) *Literal

NewLiteralUint returns a literal expression

func (*Literal) CachedSize 

func (cached *Literal) CachedSize(alloc bool) int64

func (*Literal) Format 

func (l *Literal) Format(buf *sqlparser.TrackedBuffer)

func (*Literal) FormatFast 

func (l *Literal) FormatFast(buf *sqlparser.TrackedBuffer)

func (*Literal) IR 

func (l *Literal) IR() IR

func (*Literal) IsExpr 

func (l *Literal) IsExpr()

type LogicalExpr 

type LogicalExpr struct {
	BinaryExpr
	// contains filtered or unexported fields
}

func (*LogicalExpr) CachedSize 

func (cached *LogicalExpr) CachedSize(alloc bool) int64

type Merger 

type Merger struct {
	Compare Comparison
	// contains filtered or unexported fields
}

func (*Merger) Init 

func (m *Merger) Init()

func (*Merger) Len 

func (m *Merger) Len() int

func (*Merger) Pop 

func (m *Merger) Pop() (sqltypes.Row, int)

func (*Merger) Push 

func (m *Merger) Push(row sqltypes.Row, source int)

type MinMax 

type MinMax interface {
	Min(value sqltypes.Value) error
	Max(value sqltypes.Value) error
	Result() sqltypes.Value
	Reset()
}

MinMax implements a MIN() or MAX() aggregation

func NewAggregationMinMax 

func NewAggregationMinMax(typ sqltypes.Type, collationEnv *collations.Environment, collation collations.ID, values *EnumSetValues) MinMax

type NegateExpr 

type NegateExpr struct {
	UnaryExpr
}

func (*NegateExpr) CachedSize 

func (cached *NegateExpr) CachedSize(alloc bool) int64

type NotExpr 

type NotExpr struct {
	UnaryExpr
}

func (*NotExpr) CachedSize 

func (cached *NotExpr) CachedSize(alloc bool) int64

type OrderByParams 

type OrderByParams struct {
	Col int
	// WeightStringCol is the weight_string column that will be used for sorting.
	// It is set to -1 if such a column is not added to the query
	WeightStringCol int
	Desc            bool

	// Type for knowing if the collation is relevant
	Type Type

	CollationEnv *collations.Environment
}

OrderByParams specifies the parameters for ordering. This is used for merge-sorting scatter queries.

func (*OrderByParams) CachedSize 

func (cached *OrderByParams) CachedSize(alloc bool) int64

func (*OrderByParams) Compare 

func (obp *OrderByParams) Compare(r1, r2 []sqltypes.Value) int

func (*OrderByParams) String 

func (obp *OrderByParams) String() string

String returns a string. Used for plan descriptions

type SQLMode 

type SQLMode uint32

func ParseSQLMode 

func ParseSQLMode(sqlmode string) SQLMode

func (SQLMode) AllowZeroDate 

func (mode SQLMode) AllowZeroDate() bool

type Sorter 

type Sorter struct {
	Compare Comparison
	Limit   int
	// contains filtered or unexported fields
}

func (*Sorter) Len 

func (s *Sorter) Len() int

func (*Sorter) Push 

func (s *Sorter) Push(row sqltypes.Row)

func (*Sorter) Sorted 

func (s *Sorter) Sorted() []sqltypes.Row

type Sum 

type Sum interface {
	Add(value sqltypes.Value) error
	Result() sqltypes.Value
	Reset()
}

Sum implements a SUM() aggregation

func NewAggregationSum 

func NewAggregationSum(type_ sqltypes.Type) Sum

func NewSumOfCounts 

func NewSumOfCounts() Sum

type TupleBindVariable 

type TupleBindVariable struct {
	Key string

	Index     int
	Type      sqltypes.Type
	Collation collations.ID
}

func (*TupleBindVariable) CachedSize 

func (cached *TupleBindVariable) CachedSize(alloc bool) int64

func (*TupleBindVariable) Format 

func (bv *TupleBindVariable) Format(buf *sqlparser.TrackedBuffer)

func (*TupleBindVariable) FormatFast 

func (bv *TupleBindVariable) FormatFast(buf *sqlparser.TrackedBuffer)

func (*TupleBindVariable) IR 

func (bv *TupleBindVariable) IR() IR

func (*TupleBindVariable) IsExpr 

func (bv *TupleBindVariable) IsExpr()

type TupleExpr 

type TupleExpr []IR

func NewTupleExpr 

func NewTupleExpr(exprs ...IR) TupleExpr

NewTupleExpr returns a tuple expression

func (TupleExpr) Format 

func (tuple TupleExpr) Format(buf *sqlparser.TrackedBuffer)

func (TupleExpr) FormatFast 

func (tuple TupleExpr) FormatFast(buf *sqlparser.TrackedBuffer)

func (TupleExpr) IR 

func (tuple TupleExpr) IR() IR

func (TupleExpr) IsExpr 

func (tuple TupleExpr) IsExpr()

type Type 

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

func CoerceTypes 

func CoerceTypes(v1, v2 Type, collationEnv *collations.Environment) (out Type, err error)

CoerceTypes takes two input types, and decides how they should be coerced before compared

func NewType 

func NewType(t sqltypes.Type, collation collations.ID) Type

func NewTypeEx 

func NewTypeEx(t sqltypes.Type, collation collations.ID, nullable bool, size, scale int32, values *EnumSetValues) Type

func NewTypeFromField 

func NewTypeFromField(f *querypb.Field) Type

func (*Type) CachedSize 

func (cached *Type) CachedSize(alloc bool) int64

func (*Type) Collation 

func (t *Type) Collation() collations.ID

func (*Type) Equal 

func (t *Type) Equal(other *Type) bool

func (*Type) Nullable 

func (t *Type) Nullable() bool

func (*Type) Scale 

func (t *Type) Scale() int32

func (*Type) SetNullability 

func (t *Type) SetNullability(n bool)

func (*Type) Size 

func (t *Type) Size() int32

func (*Type) ToField 

func (t *Type) ToField(name string) *querypb.Field

func (*Type) Type 

func (t *Type) Type() sqltypes.Type

func (*Type) Valid 

func (t *Type) Valid() bool

func (*Type) Values 

func (t *Type) Values() *EnumSetValues

type TypeAggregator 

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

func (*TypeAggregator) Add 

func (ta *TypeAggregator) Add(typ Type, env *collations.Environment) error

func (*TypeAggregator) AddField 

func (ta *TypeAggregator) AddField(f *query.Field, env *collations.Environment) error

func (*TypeAggregator) Field 

func (ta *TypeAggregator) Field(name string) *query.Field

func (*TypeAggregator) Type 

func (ta *TypeAggregator) Type() Type

type TypeResolver 

type TypeResolver func(expr sqlparser.Expr) (Type, bool)

type UnaryExpr 

type UnaryExpr struct {
	Inner IR
}

func (*UnaryExpr) CachedSize 

func (cached *UnaryExpr) CachedSize(alloc bool) int64

type UnsupportedCollationError 

type UnsupportedCollationError struct {
	ID collations.ID
}

UnsupportedCollationError represents the error where the comparison using provided collation is unsupported on vitess

func (UnsupportedCollationError) Error 

func (err UnsupportedCollationError) Error() string

Error function implements the error interface

type UntypedExpr 

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

UntypedExpr is a translated expression that cannot be compiled ahead of time because it contains dynamic types.

func (*UntypedExpr) CachedSize 

func (cached *UntypedExpr) CachedSize(alloc bool) int64

func (*UntypedExpr) Compile 

func (u *UntypedExpr) Compile(env *ExpressionEnv) (*CompiledExpr, error)

func (*UntypedExpr) Format 

func (u *UntypedExpr) Format(buf *sqlparser.TrackedBuffer)

func (*UntypedExpr) FormatFast 

func (u *UntypedExpr) FormatFast(buf *sqlparser.TrackedBuffer)

func (*UntypedExpr) IR 

func (u *UntypedExpr) IR() IR

func (*UntypedExpr) IsExpr 

func (u *UntypedExpr) IsExpr()

type VCursor 

type VCursor interface {
	TimeZone() *time.Location
	GetKeyspace() string
	SQLMode() string
	Environment() *vtenv.Environment
}

func NewEmptyVCursor 

func NewEmptyVCursor(env *vtenv.Environment, tz *time.Location) VCursor

type WhenThen 

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

func (*WhenThen) CachedSize 

func (cached *WhenThen) CachedSize(alloc bool) int64

Source Files

View all Source files

Directories

Path Synopsis

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.