expression

package
v7.0.4 Latest Latest
Warning

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

Go to latest
Published: Jan 30, 2023 License: Apache-2.0 Imports: 80 Imported by: 0

Documentation

Index

Constants

View Source
const (
	SHA0   = 0
	SHA224 = 224
	SHA256 = 256
	SHA384 = 384
	SHA512 = 512
)

Supported hash length of SHA-2 family

View Source
const (
	// ASCII is pure ASCII U+0000..U+007F.
	ASCII Repertoire = 0x01
	// EXTENDED is extended characters: U+0080..U+FFFF
	EXTENDED = ASCII << 1
	// UNICODE is ASCII | EXTENDED
	UNICODE = ASCII | EXTENDED
)
View Source
const InternalFuncFromBinary = "from_binary"

InternalFuncFromBinary accepts a string and returns another string decode in a given charset.

View Source
const InternalFuncToBinary = "to_binary"

InternalFuncToBinary accepts a string and returns another string encoded in a given charset.

Variables

View Source
var (
	// CollationStrictnessGroup group collation by strictness
	CollationStrictnessGroup = map[string]int{
		"utf8_general_ci":        1,
		"utf8mb4_general_ci":     1,
		"utf8_unicode_ci":        2,
		"utf8mb4_unicode_ci":     2,
		charset.CollationASCII:   3,
		charset.CollationLatin1:  3,
		charset.CollationUTF8:    3,
		charset.CollationUTF8MB4: 3,
		charset.CollationBin:     4,
	}

	// CollationStrictness indicates the strictness of comparison of the collation. The unequal order in a weak collation also holds in a strict collation.
	// For example, if a != b in a weak collation(e.g. general_ci), then there must be a != b in a strict collation(e.g. _bin).
	// collation group id in value is stricter than collation group id in key
	CollationStrictness = map[int][]int{
		1: {3, 4},
		2: {3, 4},
		3: {4},
		4: {},
	}
)
View Source
var (
	// All the exported errors are defined here:
	ErrIncorrectParameterCount     = dbterror.ClassExpression.NewStd(mysql.ErrWrongParamcountToNativeFct)
	ErrDivisionByZero              = dbterror.ClassExpression.NewStd(mysql.ErrDivisionByZero)
	ErrRegexp                      = dbterror.ClassExpression.NewStd(mysql.ErrRegexp)
	ErrOperandColumns              = dbterror.ClassExpression.NewStd(mysql.ErrOperandColumns)
	ErrCutValueGroupConcat         = dbterror.ClassExpression.NewStd(mysql.ErrCutValueGroupConcat)
	ErrFunctionsNoopImpl           = dbterror.ClassExpression.NewStdErr(mysql.ErrNotSupportedYet, pmysql.Message("function %s has only noop implementation in tidb now, use tidb_enable_noop_functions to enable these functions", nil))
	ErrInvalidArgumentForLogarithm = dbterror.ClassExpression.NewStd(mysql.ErrInvalidArgumentForLogarithm)
	ErrIncorrectType               = dbterror.ClassExpression.NewStd(mysql.ErrIncorrectType)
	ErrInvalidTypeForJSON          = dbterror.ClassExpression.NewStd(mysql.ErrInvalidTypeForJSON)
	ErrInvalidTableSample          = dbterror.ClassExpression.NewStd(mysql.ErrInvalidTableSample)
	ErrInternal                    = dbterror.ClassOptimizer.NewStd(mysql.ErrInternal)
	ErrNoDB                        = dbterror.ClassOptimizer.NewStd(mysql.ErrNoDB)
	ErrNotSupportedYet             = dbterror.ClassExpression.NewStd(mysql.ErrNotSupportedYet)
	ErrInvalidJSONForFuncIndex     = dbterror.ClassExpression.NewStd(mysql.ErrInvalidJSONValueForFuncIndex)
	ErrDataOutOfRangeFuncIndex     = dbterror.ClassExpression.NewStd(mysql.ErrDataOutOfRangeFunctionalIndex)
	ErrFuncIndexDataIsTooLong      = dbterror.ClassExpression.NewStd(mysql.ErrFunctionalIndexDataIsTooLong)
)

Error instances.

View Source
var AllowedPartition4BinaryOpMap = map[opcode.Op]struct{}{
	opcode.Plus:   {},
	opcode.Minus:  {},
	opcode.Mul:    {},
	opcode.IntDiv: {},
	opcode.Mod:    {},
}

AllowedPartition4BinaryOpMap store the operator for Binary Expr See https://dev.mysql.com/doc/refman/5.7/en/partitioning-limitations.html for more details

View Source
var AllowedPartition4UnaryOpMap = map[opcode.Op]struct{}{
	opcode.Plus:  {},
	opcode.Minus: {},
}

AllowedPartition4UnaryOpMap store the operator for Unary Expr

View Source
var AllowedPartitionFuncMap = map[string]struct{}{
	ast.ToDays:        {},
	ast.ToSeconds:     {},
	ast.DayOfMonth:    {},
	ast.Month:         {},
	ast.DayOfYear:     {},
	ast.Quarter:       {},
	ast.YearWeek:      {},
	ast.Year:          {},
	ast.Weekday:       {},
	ast.DayOfWeek:     {},
	ast.Day:           {},
	ast.Hour:          {},
	ast.Minute:        {},
	ast.Second:        {},
	ast.TimeToSec:     {},
	ast.MicroSecond:   {},
	ast.UnixTimestamp: {},
	ast.FromDays:      {},
	ast.Extract:       {},
	ast.Abs:           {},
	ast.Ceiling:       {},
	ast.DateDiff:      {},
	ast.Floor:         {},
	ast.Mod:           {},
}

AllowedPartitionFuncMap stores functions which can be used in the partition expression.

View Source
var DefaultExprPushDownBlacklist *atomic.Value

DefaultExprPushDownBlacklist indicates the expressions which can not be pushed down to TiKV.

View Source
var DeferredFunctions = map[string]struct{}{
	ast.Now:              {},
	ast.RandomBytes:      {},
	ast.CurrentTimestamp: {},
	ast.UTCTime:          {},
	ast.Curtime:          {},
	ast.CurrentTime:      {},
	ast.UTCTimestamp:     {},
	ast.UnixTimestamp:    {},
	ast.Curdate:          {},
	ast.CurrentDate:      {},
	ast.UTCDate:          {},
}

DeferredFunctions stores functions which are foldable but should be deferred as well when plan cache is enabled. Note that, these functions must be foldable at first place, i.e, they are not in `unFoldableFunctions`.

View Source
var DisableFoldFunctions = map[string]struct{}{
	ast.Benchmark: {},
}

DisableFoldFunctions stores functions which prevent child scope functions from being constant folded. Typically, these functions shall also exist in unFoldableFunctions, to stop from being folded when they themselves are in child scope of an outer function, and the outer function is recursively folding its children.

View Source
var EvalAstExpr func(sctx sessionctx.Context, expr ast.ExprNode) (types.Datum, error)

EvalAstExpr evaluates ast expression directly. Note: initialized in planner/core import expression and planner/core together to use EvalAstExpr

View Source
var IllegalFunctions4GeneratedColumns = map[string]struct{}{
	ast.ConnectionID:     {},
	ast.LoadFile:         {},
	ast.LastInsertId:     {},
	ast.Rand:             {},
	ast.UUID:             {},
	ast.UUIDShort:        {},
	ast.Curdate:          {},
	ast.CurrentDate:      {},
	ast.Curtime:          {},
	ast.CurrentTime:      {},
	ast.CurrentTimestamp: {},
	ast.LocalTime:        {},
	ast.LocalTimestamp:   {},
	ast.Now:              {},
	ast.UnixTimestamp:    {},
	ast.UTCDate:          {},
	ast.UTCTime:          {},
	ast.UTCTimestamp:     {},
	ast.Benchmark:        {},
	ast.CurrentUser:      {},
	ast.Database:         {},
	ast.FoundRows:        {},
	ast.GetLock:          {},
	ast.IsFreeLock:       {},
	ast.IsUsedLock:       {},
	ast.MasterPosWait:    {},
	ast.NameConst:        {},
	ast.ReleaseLock:      {},
	ast.RowFunc:          {},
	ast.RowCount:         {},
	ast.Schema:           {},
	ast.SessionUser:      {},
	ast.Sleep:            {},
	ast.Sysdate:          {},
	ast.SystemUser:       {},
	ast.User:             {},
	ast.Values:           {},
	ast.Encrypt:          {},
	ast.Version:          {},
	ast.JSONMerge:        {},
	ast.SetVar:           {},
	ast.GetVar:           {},
	ast.ReleaseAllLocks:  {},
}

IllegalFunctions4GeneratedColumns stores functions that is illegal for generated columns. See https://github.com/mysql/mysql-server/blob/5.7/mysql-test/suite/gcol/inc/gcol_blocked_sql_funcs_main.inc for details

View Source
var MaxPropagateColsCnt = 100

MaxPropagateColsCnt means the max number of columns that can participate propagation.

View Source
var NonPreparedPlanCacheableOp = map[string]struct{}{
	ast.LogicAnd: {},
	ast.LogicOr:  {},
	ast.GE:       {},
	ast.LE:       {},
	ast.EQ:       {},
	ast.LT:       {},
	ast.GT:       {},
}

NonPreparedPlanCacheableOp stores function which can be cached to non-prepared plan cache.

View Source
var RewriteAstExpr func(sctx sessionctx.Context, expr ast.ExprNode, schema *Schema, names types.NameSlice, allowCastArray bool) (Expression, error)

RewriteAstExpr rewrites ast expression directly. Note: initialized in planner/core import expression and planner/core together to use EvalAstExpr

View Source
var TryFoldFunctions = map[string]struct{}{
	ast.If:       {},
	ast.Ifnull:   {},
	ast.Case:     {},
	ast.LogicAnd: {},
	ast.LogicOr:  {},
	ast.Coalesce: {},
	ast.Interval: {},
}

TryFoldFunctions stores functions which try to fold constant in child scope functions if without errors/warnings, otherwise, the child functions do not fold constant. Note: the function itself should fold constant.

View Source
var UnCacheableFunctions = map[string]struct{}{
	ast.Database:     {},
	ast.CurrentUser:  {},
	ast.CurrentRole:  {},
	ast.User:         {},
	ast.ConnectionID: {},
	ast.LastInsertId: {},
	ast.RowCount:     {},
	ast.Version:      {},
	ast.Like:         {},
}

UnCacheableFunctions stores functions which can not be cached to plan cache.

Functions

func CalAppropriateTime

func CalAppropriateTime(minTime, maxTime, minSafeTime time.Time) time.Time

CalAppropriateTime directly calls calAppropriateTime

func CanExprsPushDown

func CanExprsPushDown(sc *stmtctx.StatementContext, exprs []Expression, client kv.Client, storeType kv.StoreType) bool

CanExprsPushDown return true if all the expr in exprs can be pushed down

func CanExprsPushDownWithExtraInfo

func CanExprsPushDownWithExtraInfo(sc *stmtctx.StatementContext, exprs []Expression, client kv.Client, storeType kv.StoreType, canEnumPush bool) bool

CanExprsPushDownWithExtraInfo return true if all the expr in exprs can be pushed down

func CanImplicitEvalInt

func CanImplicitEvalInt(expr Expression) bool

CanImplicitEvalInt represents the builtin functions that have an implicit path to evaluate as integer, regardless of the type that type inference decides it to be. This is a nasty way to match the weird behavior of MySQL functions like `dayname()` being implicitly evaluated as integer. See https://github.com/mysql/mysql-server/blob/ee4455a33b10f1b1886044322e4893f587b319ed/sql/item_timefunc.h#L423 for details.

func CanImplicitEvalReal

func CanImplicitEvalReal(expr Expression) bool

CanImplicitEvalReal represents the builtin functions that have an implicit path to evaluate as real, regardless of the type that type inference decides it to be. This is a nasty way to match the weird behavior of MySQL functions like `dayname()` being implicitly evaluated as real. See https://github.com/mysql/mysql-server/blob/ee4455a33b10f1b1886044322e4893f587b319ed/sql/item_timefunc.h#L423 for details.

func CheckArgsNotMultiColumnRow

func CheckArgsNotMultiColumnRow(args ...Expression) error

CheckArgsNotMultiColumnRow checks the args are not multi-column row.

func CheckFuncInExpr

func CheckFuncInExpr(e Expression, funcName string) bool

CheckFuncInExpr checks whether there's a given function in the expression.

func CheckNonDeterministic

func CheckNonDeterministic(e Expression) bool

CheckNonDeterministic checks whether the current expression contains a non-deterministic func.

func CompareDecimal

func CompareDecimal(sctx sessionctx.Context, lhsArg, rhsArg Expression, lhsRow, rhsRow chunk.Row) (int64, bool, error)

CompareDecimal compares two decimals.

func CompareDuration

func CompareDuration(sctx sessionctx.Context, lhsArg, rhsArg Expression, lhsRow, rhsRow chunk.Row) (int64, bool, error)

CompareDuration compares two durations.

func CompareInt

func CompareInt(sctx sessionctx.Context, lhsArg, rhsArg Expression, lhsRow, rhsRow chunk.Row) (int64, bool, error)

CompareInt compares two integers.

func CompareJSON

func CompareJSON(sctx sessionctx.Context, lhsArg, rhsArg Expression, lhsRow, rhsRow chunk.Row) (int64, bool, error)

CompareJSON compares two JSONs.

func CompareReal

func CompareReal(sctx sessionctx.Context, lhsArg, rhsArg Expression, lhsRow, rhsRow chunk.Row) (int64, bool, error)

CompareReal compares two float-point values.

func CompareStringWithCollationInfo

func CompareStringWithCollationInfo(sctx sessionctx.Context, lhsArg, rhsArg Expression, lhsRow, rhsRow chunk.Row, collation string) (int64, bool, error)

CompareStringWithCollationInfo compares two strings with the specified collation information.

func CompareTime

func CompareTime(sctx sessionctx.Context, lhsArg, rhsArg Expression, lhsRow, rhsRow chunk.Row) (int64, bool, error)

CompareTime compares two datetime or timestamps.

func ConstructPositionExpr

func ConstructPositionExpr(p *driver.ParamMarkerExpr) *ast.PositionExpr

ConstructPositionExpr constructs PositionExpr with the given ParamMarkerExpr.

func ContainCorrelatedColumn

func ContainCorrelatedColumn(exprs []Expression) bool

ContainCorrelatedColumn checks if the expressions contain a correlated column

func ContainOuterNot

func ContainOuterNot(expr Expression) bool

ContainOuterNot checks if there is an outer `not`.

func ContainVirtualColumn

func ContainVirtualColumn(exprs []Expression) bool

ContainVirtualColumn checks if the expressions contain a virtual column

func Contains

func Contains(exprs []Expression, e Expression) bool

Contains tests if `exprs` contains `e`.

func ConvertJSON2Tp

func ConvertJSON2Tp(v types.BinaryJSON, targetType *types.FieldType) (any, error)

ConvertJSON2Tp returns a function that can convert JSON to the specified type.

func DeriveCollationFromExprs

func DeriveCollationFromExprs(ctx sessionctx.Context, exprs ...Expression) (dstCharset, dstCollation string)

DeriveCollationFromExprs derives collation information from these expressions. Deprecated, use CheckAndDeriveCollationFromExprs instead. TODO: remove this function after the all usage is replaced by CheckAndDeriveCollationFromExprs

func DisableParseJSONFlag4Expr

func DisableParseJSONFlag4Expr(expr Expression)

DisableParseJSONFlag4Expr disables ParseToJSONFlag for `expr` except Column. We should not *PARSE* a string as JSON under some scenarios. ParseToJSONFlag is 0 for JSON column yet(as well as JSON correlated column), so we can skip it. Moreover, Column.RetType refers to the infoschema, if we modify it, data race may happen if another goroutine read from the infoschema at the same time.

func EvalBool

func EvalBool(ctx sessionctx.Context, exprList CNFExprs, row chunk.Row) (bool, bool, error)

EvalBool evaluates expression list to a boolean value. The first returned value indicates bool result of the expression list, the second returned value indicates whether the result of the expression list is null, it can only be true when the first returned values is false.

func EvalExpr

func EvalExpr(ctx sessionctx.Context, expr Expression, evalType types.EvalType, input *chunk.Chunk, result *chunk.Column) (err error)

EvalExpr evaluates this expr according to its type. And it selects the method for evaluating expression based on the environment variables and whether the expression can be vectorized. Note: the input argument `evalType` is needed because of that when `expr` is of the hybrid type(ENUM/SET/BIT), we need the invoker decide the actual EvalType.

func ExplainColumnList

func ExplainColumnList(cols []*Column) []byte

ExplainColumnList generates explain information for a list of columns.

func ExplainExpressionList

func ExplainExpressionList(exprs []Expression, schema *Schema) string

ExplainExpressionList generates explain information for a list of expressions.

func ExprFromSchema

func ExprFromSchema(expr Expression, schema *Schema) bool

ExprFromSchema checks if all columns of this expression are from the same schema.

func ExprNotNull

func ExprNotNull(expr Expression) bool

ExprNotNull checks if an expression is possible to be null.

func ExpressionsToPBList

func ExpressionsToPBList(sc *stmtctx.StatementContext, exprs []Expression, client kv.Client) (pbExpr []*tipb.Expr, err error)

ExpressionsToPBList converts expressions to tipb.Expr list for new plan.

func ExtractColumnSet

func ExtractColumnSet(exprs ...Expression) *intsets.Sparse

ExtractColumnSet extracts the different values of `UniqueId` for columns in expressions.

func ExtractEquivalenceColumns

func ExtractEquivalenceColumns(result [][]Expression, exprs []Expression) [][]Expression

ExtractEquivalenceColumns detects the equivalence from CNF exprs.

func FastLocateHashPartition

func FastLocateHashPartition(ctx sessionctx.Context, conds []Expression, piExpr Expression) (int64, bool, bool)

FastLocateHashPartition is used to get hash partition quickly.

func FieldTypeFromPB

func FieldTypeFromPB(ft *tipb.FieldType) *types.FieldType

FieldTypeFromPB converts *tipb.FieldType to *types.FieldType.

func FindFieldName

func FindFieldName(names types.NameSlice, astCol *ast.ColumnName) (int, error)

FindFieldName finds the column name from NameSlice.

func FindFieldNameIdxByColName

func FindFieldNameIdxByColName(names []*types.FieldName, colName string) int

FindFieldNameIdxByColName finds the index of corresponding name in the given slice. -1 for not found.

func GcColumnExprIsTidbShard

func GcColumnExprIsTidbShard(virtualExpr Expression) bool

GcColumnExprIsTidbShard check whether the expression is tidb_shard()

func GetAccurateCmpType

func GetAccurateCmpType(lhs, rhs Expression) types.EvalType

GetAccurateCmpType uses a more complex logic to decide the EvalType of the two args when compare with each other than getBaseCmpType does.

func GetBuiltinList

func GetBuiltinList() []string

GetBuiltinList returns a list of builtin functions

func GetColumn

func GetColumn(_ types.EvalType, _ int) (*chunk.Column, error)

GetColumn allocates a column. The allocator is not responsible for initializing the column, so please initialize it before using.

func GetDisplayName

func GetDisplayName(name string) string

GetDisplayName translate a function name to its display name

func GetFormatBytes

func GetFormatBytes(bytes float64) string

GetFormatBytes convert byte count to value with units.

func GetFormatNanoTime

func GetFormatNanoTime(time float64) string

GetFormatNanoTime convert time in nanoseconds to value with units.

func GetIntFromConstant

func GetIntFromConstant(ctx sessionctx.Context, value Expression) (int, bool, error)

GetIntFromConstant gets an interger value from the Constant expression.

func GetMinSafeTime

func GetMinSafeTime(sessionCtx sessionctx.Context) time.Time

GetMinSafeTime get minSafeTime

func GetRowLen

func GetRowLen(e Expression) int

GetRowLen gets the length if the func is row, returns 1 if not row.

func GetStmtTimestamp

func GetStmtTimestamp(ctx sessionctx.Context) (time.Time, error)

GetStmtTimestamp directly calls getTimeZone with timezone

func GetStringFromConstant

func GetStringFromConstant(ctx sessionctx.Context, value Expression) (string, bool, error)

GetStringFromConstant gets a string value from the Constant expression.

func GetTimeCurrentTimestamp

func GetTimeCurrentTimestamp(ctx sessionctx.Context, tp byte, fsp int) (d types.Datum, err error)

GetTimeCurrentTimestamp is used for generating a timestamp for some special cases: cast null value to timestamp type with not null flag.

func GetTimeValue

func GetTimeValue(ctx sessionctx.Context, v interface{}, tp byte, fsp int) (d types.Datum, err error)

GetTimeValue gets the time value with type tp.

func GetUint64FromConstant

func GetUint64FromConstant(expr Expression) (uint64, bool, bool)

GetUint64FromConstant gets a uint64 from constant expression.

func GetUsedList

func GetUsedList(usedCols []*Column, schema *Schema) []bool

GetUsedList shows whether each column in schema is contained in usedCols.

func GroupByItemToPB

func GroupByItemToPB(sc *stmtctx.StatementContext, client kv.Client, expr Expression) *tipb.ByItem

GroupByItemToPB converts group by items to pb.

func HandleOverflowOnSelection

func HandleOverflowOnSelection(sc *stmtctx.StatementContext, val int64, err error) (int64, error)

HandleOverflowOnSelection handles Overflow errors when evaluating selection filters. We should ignore overflow errors when evaluating selection conditions:

INSERT INTO t VALUES ("999999999999999999");
SELECT * FROM t WHERE v;

func HasAssignSetVarFunc

func HasAssignSetVarFunc(expr Expression) bool

HasAssignSetVarFunc checks whether an expression contains SetVar function and assign a value

func HasGetSetVarFunc

func HasGetSetVarFunc(expr Expression) bool

HasGetSetVarFunc checks whether an expression contains SetVar/GetVar function.

func InferType4ControlFuncs

func InferType4ControlFuncs(ctx sessionctx.Context, funcName string, lexp, rexp Expression) (*types.FieldType, error)

InferType4ControlFuncs infer result type for builtin IF, IFNULL, NULLIF, LEAD and LAG.

func IsBinaryLiteral

func IsBinaryLiteral(expr Expression) bool

IsBinaryLiteral checks whether an expression is a binary literal

func IsEQCondFromIn

func IsEQCondFromIn(expr Expression) bool

IsEQCondFromIn checks if an expression is equal condition converted from `[not] in (subq)`.

func IsFunctionSupported

func IsFunctionSupported(name string) bool

IsFunctionSupported check if given function name is a builtin sql function.

func IsInmutableExpr

func IsInmutableExpr(expr Expression) bool

IsInmutableExpr checks whether this expression only consists of foldable functions and inmutable constants. This expression can be evaluated by using `expr.Eval(chunk.Row{})` directly if it's inmutable.

func IsMutableEffectsExpr

func IsMutableEffectsExpr(expr Expression) bool

IsMutableEffectsExpr checks if expr contains function which is mutable or has side effects.

func IsPushDownEnabled

func IsPushDownEnabled(name string, storeType kv.StoreType) bool

IsPushDownEnabled returns true if the input expr is not in the expr_pushdown_blacklist

func IsRuntimeConstExpr

func IsRuntimeConstExpr(expr Expression) bool

IsRuntimeConstExpr checks if a expr can be treated as a constant in **executor**.

func IsValidCurrentTimestampExpr

func IsValidCurrentTimestampExpr(exprNode ast.ExprNode, fieldType *types.FieldType) bool

IsValidCurrentTimestampExpr returns true if exprNode is a valid CurrentTimestamp expression. Here `valid` means it is consistent with the given fieldType's decimal.

func MaybeOverOptimized4PlanCache

func MaybeOverOptimized4PlanCache(ctx sessionctx.Context, exprs []Expression) bool

MaybeOverOptimized4PlanCache used to check whether an optimization can work for the statement when we enable the plan cache. In some situations, some optimizations maybe over-optimize and cache an overOptimized plan. The cached plan may not get the correct result when we reuse the plan for other statements. For example, `pk>=$a and pk<=$b` can be optimized to a PointGet when `$a==$b`, but it will cause wrong results when `$a!=$b`. So we need to do the check here. The check includes the following aspects: 1. Whether the plan cache switch is enable. 2. Whether the statement can be cached. 3. Whether the expressions contain a lazy constant. TODO: Do more careful check here.

func PbTypeToFieldType

func PbTypeToFieldType(tp *tipb.FieldType) *types.FieldType

PbTypeToFieldType converts tipb.FieldType to FieldType

func PosFromPositionExpr

func PosFromPositionExpr(ctx sessionctx.Context, v *ast.PositionExpr) (int, bool, error)

PosFromPositionExpr generates a position value from PositionExpr.

func PropConstOverOuterJoin

func PropConstOverOuterJoin(ctx sessionctx.Context, joinConds, filterConds []Expression,
	outerSchema, innerSchema *Schema, nullSensitive bool) ([]Expression, []Expression)

PropConstOverOuterJoin propagate constant equal and column equal conditions over outer join. First step is to extract `outerCol = const` from join conditions and filter conditions, and substitute `outerCol` in join conditions with `const`; Second step is to extract `outerCol = innerCol` from join conditions, and derive new join conditions based on this column equal condition and `outerCol` related expressions in join conditions and filter conditions;

func PropagateType

func PropagateType(evalType types.EvalType, args ...Expression)

PropagateType propagates the type information to the `expr`. Note: For now, we only propagate type for the function CastDecimalAsDouble.

e.g. > create table t(a decimal(9, 8)); > insert into t values(5.04600000) > select a/36000 from t; Type: NEWDECIMAL Length: 15 Decimals: 12 +------------------+ | 5.04600000/36000 | +------------------+ | 0.000140166667 | +------------------+

> select cast(a/36000 as double) as result from t; Type: DOUBLE Length: 23 Decimals: 31 +----------------------+ | result | +----------------------+ | 0.000140166666666666 | +----------------------+ The expected `decimal` and `length` of the outer cast_as_double need to be propagated to the inner div.

func PushDownExprs

func PushDownExprs(sc *stmtctx.StatementContext, exprs []Expression, client kv.Client, storeType kv.StoreType) (pushed []Expression, remained []Expression)

PushDownExprs split the input exprs into pushed and remained, pushed include all the exprs that can be pushed down

func PushDownExprsWithExtraInfo

func PushDownExprsWithExtraInfo(sc *stmtctx.StatementContext, exprs []Expression, client kv.Client, storeType kv.StoreType, canEnumPush bool) (pushed []Expression, remained []Expression)

PushDownExprsWithExtraInfo split the input exprs into pushed and remained, pushed include all the exprs that can be pushed down

func PutColumn

func PutColumn(buf *chunk.Column)

PutColumn releases a column buffer.

func Quote

func Quote(str string) string

Quote produce a result that can be used as a properly escaped data value in an SQL statement.

func ReHashCode

func ReHashCode(sf *ScalarFunction, sc *stmtctx.StatementContext)

ReHashCode is used after we change the argument in place.

func RemoveMutableConst

func RemoveMutableConst(ctx sessionctx.Context, exprs []Expression)

RemoveMutableConst used to remove the `ParamMarker` and `DeferredExpr` in the `Constant` expr.

func ResolveType4Between

func ResolveType4Between(args [3]Expression) types.EvalType

ResolveType4Between resolves eval type for between expression.

func SetBinFlagOrBinStr

func SetBinFlagOrBinStr(argTp *types.FieldType, resTp *types.FieldType)

SetBinFlagOrBinStr sets resTp to binary string if argTp is a binary string, if not, sets the binary flag of resTp to true if argTp has binary flag. We need to check if the tp is enum or set, if so, don't add binary flag directly unless it has binary flag.

func SortByItemToPB

func SortByItemToPB(sc *stmtctx.StatementContext, client kv.Client, expr Expression, desc bool) *tipb.ByItem

SortByItemToPB converts order by items to pb.

func SortedExplainExpressionList

func SortedExplainExpressionList(exprs []Expression) []byte

SortedExplainExpressionList generates explain information for a list of expressions in order. In some scenarios, the expr's order may not be stable when executing multiple times. So we add a sort to make its explain result stable.

func SortedExplainNormalizedExpressionList

func SortedExplainNormalizedExpressionList(exprs []Expression) []byte

SortedExplainNormalizedExpressionList is same like SortedExplainExpressionList, but use for generating normalized information.

func SortedExplainNormalizedScalarFuncList

func SortedExplainNormalizedScalarFuncList(exprs []*ScalarFunction) []byte

SortedExplainNormalizedScalarFuncList is same like SortedExplainExpressionList, but use for generating normalized information.

func ToPBFieldType

func ToPBFieldType(ft *types.FieldType) *tipb.FieldType

ToPBFieldType converts *types.FieldType to *tipb.FieldType.

func ToPBFieldTypeWithCheck

func ToPBFieldTypeWithCheck(ft *types.FieldType, storeType kv.StoreType) (*tipb.FieldType, error)

ToPBFieldTypeWithCheck converts *types.FieldType to *tipb.FieldType with checking the valid decimal for TiFlash

func VecEvalBool

func VecEvalBool(ctx sessionctx.Context, exprList CNFExprs, input *chunk.Chunk, selected, nulls []bool) ([]bool, []bool, error)

VecEvalBool does the same thing as EvalBool but it works in a vectorized manner.

func Vectorizable

func Vectorizable(exprs []Expression) bool

Vectorizable checks whether a list of expressions can employ vectorized execution.

func VectorizedExecute

func VectorizedExecute(ctx sessionctx.Context, exprs []Expression, iterator *chunk.Iterator4Chunk, output *chunk.Chunk) error

VectorizedExecute evaluates a list of expressions column by column and append their results to "output" Chunk.

func VectorizedFilter

func VectorizedFilter(ctx sessionctx.Context, filters []Expression, iterator *chunk.Iterator4Chunk, selected []bool) (_ []bool, err error)

VectorizedFilter applies a list of filters to a Chunk and returns a bool slice, which indicates whether a row is passed the filters. Filters is executed vectorized.

func VectorizedFilterConsiderNull

func VectorizedFilterConsiderNull(ctx sessionctx.Context, filters []Expression, iterator *chunk.Iterator4Chunk, selected []bool, isNull []bool) ([]bool, []bool, error)

VectorizedFilterConsiderNull applies a list of filters to a Chunk and returns two bool slices, `selected` indicates whether a row passed the filters, `isNull` indicates whether the result of the filter is null. Filters is executed vectorized.

func VerifyArgsWrapper

func VerifyArgsWrapper(name string, l int) error

VerifyArgsWrapper verifies a function by its name and the count of the arguments. Note that this function assumes that the function is supported.

Types

type Assignment

type Assignment struct {
	Col *Column
	// ColName indicates its original column name in table schema. It's used for outputting helping message when executing meets some errors.
	ColName model.CIStr
	Expr    Expression
	// LazyErr is used in statement like `INSERT INTO t1 (a) VALUES (1) ON DUPLICATE KEY UPDATE a= (SELECT b FROM source);`, ErrSubqueryMoreThan1Row
	// should be evaluated after the duplicate situation is detected in the executing procedure.
	LazyErr error
}

Assignment represents a set assignment in Update, such as Update t set c1 = hex(12), c2 = c3 where c2 = 1

func (*Assignment) MemoryUsage

func (a *Assignment) MemoryUsage() (sum int64)

MemoryUsage return the memory usage of Assignment

type CNFExprs

type CNFExprs []Expression

CNFExprs stands for a CNF expression.

func (CNFExprs) Clone

func (e CNFExprs) Clone() CNFExprs

Clone clones itself.

func (CNFExprs) Shallow

func (e CNFExprs) Shallow() CNFExprs

Shallow makes a shallow copy of itself.

type Coercibility

type Coercibility int32

Coercibility values are used to check whether the collation of one item can be coerced to the collation of other. See https://dev.mysql.com/doc/refman/8.0/en/charset-collation-coercibility.html

const (
	// CoercibilityExplicit is derived from an explicit COLLATE clause.
	CoercibilityExplicit Coercibility = 0
	// CoercibilityNone is derived from the concatenation of two strings with different collations.
	CoercibilityNone Coercibility = 1
	// CoercibilityImplicit is derived from a column or a stored routine parameter or local variable or cast() function.
	CoercibilityImplicit Coercibility = 2
	// CoercibilitySysconst is derived from a “system constant” (the string returned by functions such as USER() or VERSION()).
	CoercibilitySysconst Coercibility = 3
	// CoercibilityCoercible is derived from a literal.
	CoercibilityCoercible Coercibility = 4
	// CoercibilityNumeric is derived from a numeric or temporal value.
	CoercibilityNumeric Coercibility = 5
	// CoercibilityIgnorable is derived from NULL or an expression that is derived from NULL.
	CoercibilityIgnorable Coercibility = 6
)

type CollationInfo

type CollationInfo interface {
	// HasCoercibility returns if the Coercibility value is initialized.
	HasCoercibility() bool

	// Coercibility returns the coercibility value which is used to check collations.
	Coercibility() Coercibility

	// SetCoercibility sets a specified coercibility for this expression.
	SetCoercibility(val Coercibility)

	// Repertoire returns the repertoire value which is used to check collations.
	Repertoire() Repertoire

	// SetRepertoire sets a specified repertoire for this expression.
	SetRepertoire(r Repertoire)

	// CharsetAndCollation gets charset and collation.
	CharsetAndCollation() (string, string)

	// SetCharsetAndCollation sets charset and collation.
	SetCharsetAndCollation(chs, coll string)
}

CollationInfo contains all interfaces about dealing with collation.

type Column

type Column struct {
	RetType *types.FieldType
	// ID is used to specify whether this column is ExtraHandleColumn or to access histogram.
	// We'll try to remove it in the future.
	ID int64
	// UniqueID is the unique id of this column.
	UniqueID int64

	// Index is used for execution, to tell the column's position in the given row.
	Index int

	// VirtualExpr is used to save expression for virtual column
	VirtualExpr Expression

	OrigName string
	IsHidden bool

	// IsPrefix indicates whether this column is a prefix column in index.
	//
	// for example:
	// 	pk(col1, col2), index(col1(10)), key: col1(10)_col1_col2 => index's col1 will be true
	// 	pk(col1(10), col2), index(col1), key: col1_col1(10)_col2 => pk's col1 will be true
	IsPrefix bool

	// InOperand indicates whether this column is the inner operand of column equal condition converted
	// from `[not] in (subq)`.
	InOperand bool

	CorrelatedColUniqueID int64
	// contains filtered or unexported fields
}

Column represents a column.

func ColInfo2Col

func ColInfo2Col(cols []*Column, col *model.ColumnInfo) *Column

ColInfo2Col finds the corresponding column of the ColumnInfo in a column slice.

func ColumnInfos2ColumnsAndNames

func ColumnInfos2ColumnsAndNames(ctx sessionctx.Context, dbName, tblName model.CIStr, colInfos []*model.ColumnInfo, tblInfo *model.TableInfo) ([]*Column, types.NameSlice, error)

ColumnInfos2ColumnsAndNames converts the ColumnInfo to the *Column and NameSlice.

func ExtractColumns

func ExtractColumns(expr Expression) []*Column

ExtractColumns extracts all columns from an expression.

func ExtractColumnsAndCorColumnsFromExpressions

func ExtractColumnsAndCorColumnsFromExpressions(result []*Column, list []Expression) []*Column

ExtractColumnsAndCorColumnsFromExpressions extracts columns and correlated columns from expressions and append them to `result`.

func ExtractColumnsFromExpressions

func ExtractColumnsFromExpressions(result []*Column, exprs []Expression, filter func(*Column) bool) []*Column

ExtractColumnsFromExpressions is a more efficient version of ExtractColumns for batch operation. filter can be nil, or a function to filter the result column. It's often observed that the pattern of the caller like this:

cols := ExtractColumns(...)

for _, col := range cols {
    if xxx(col) {...}
}

Provide an additional filter argument, this can be done in one step. To avoid allocation for cols that not need.

func ExtractDependentColumns

func ExtractDependentColumns(expr Expression) []*Column

ExtractDependentColumns extracts all dependent columns from a virtual column.

func FindPrefixOfIndex

func FindPrefixOfIndex(cols []*Column, idxColIDs []int64) []*Column

FindPrefixOfIndex will find columns in index by checking the unique id. So it will return at once no matching column is found.

func IndexCol2Col

func IndexCol2Col(colInfos []*model.ColumnInfo, cols []*Column, col *model.IndexColumn) *Column

IndexCol2Col finds the corresponding column of the IndexColumn in a column slice.

func IndexInfo2Cols

func IndexInfo2Cols(colInfos []*model.ColumnInfo, cols []*Column, index *model.IndexInfo) ([]*Column, []int)

IndexInfo2Cols gets the corresponding []*Column of the indexInfo's []*IndexColumn, together with a []int containing their lengths. If this index has three IndexColumn that the 1st and 3rd IndexColumn has corresponding *Column, the return value will be [col1, nil, col2].

func IndexInfo2PrefixCols

func IndexInfo2PrefixCols(colInfos []*model.ColumnInfo, cols []*Column, index *model.IndexInfo) ([]*Column, []int)

IndexInfo2PrefixCols gets the corresponding []*Column of the indexInfo's []*IndexColumn, together with a []int containing their lengths. If this index has three IndexColumn that the 1st and 3rd IndexColumn has corresponding *Column, the return value will be only the 1st corresponding *Column and its length. TODO: Use a struct to represent {*Column, int}. And merge IndexInfo2PrefixCols and IndexInfo2Cols.

func SortColumns

func SortColumns(cols []*Column) []*Column

SortColumns sort columns based on UniqueID.

func (*Column) CharsetAndCollation

func (c *Column) CharsetAndCollation() (string, string)

func (*Column) CleanHashCode

func (col *Column) CleanHashCode()

CleanHashCode will clean the hashcode you may be cached before. It's used especially in schema-cloned & reallocated-uniqueID's cases.

func (*Column) Clone

func (col *Column) Clone() Expression

Clone implements Expression interface.

func (*Column) Coercibility

func (col *Column) Coercibility() Coercibility

Coercibility returns the coercibility value which is used to check collations.

func (*Column) ConstItem

func (col *Column) ConstItem(_ *stmtctx.StatementContext) bool

ConstItem implements Expression interface.

func (*Column) Decorrelate

func (col *Column) Decorrelate(_ *Schema) Expression

Decorrelate implements Expression interface.

func (*Column) Equal

func (col *Column) Equal(_ sessionctx.Context, expr Expression) bool

Equal implements Expression interface.

func (*Column) EqualByExprAndID

func (col *Column) EqualByExprAndID(_ sessionctx.Context, expr Expression) bool

EqualByExprAndID extends Equal by comparing virual expression

func (*Column) Eval

func (col *Column) Eval(row chunk.Row) (types.Datum, error)

Eval implements Expression interface.

func (*Column) EvalDecimal

func (col *Column) EvalDecimal(ctx sessionctx.Context, row chunk.Row) (*types.MyDecimal, bool, error)

EvalDecimal returns decimal representation of Column.

func (*Column) EvalDuration

func (col *Column) EvalDuration(ctx sessionctx.Context, row chunk.Row) (types.Duration, bool, error)

EvalDuration returns Duration representation of Column.

func (*Column) EvalInt

func (col *Column) EvalInt(ctx sessionctx.Context, row chunk.Row) (int64, bool, error)

EvalInt returns int representation of Column.

func (*Column) EvalJSON

func (col *Column) EvalJSON(ctx sessionctx.Context, row chunk.Row) (types.BinaryJSON, bool, error)

EvalJSON returns JSON representation of Column.

func (*Column) EvalReal

func (col *Column) EvalReal(ctx sessionctx.Context, row chunk.Row) (float64, bool, error)

EvalReal returns real representation of Column.

func (*Column) EvalString

func (col *Column) EvalString(ctx sessionctx.Context, row chunk.Row) (string, bool, error)

EvalString returns string representation of Column.

func (*Column) EvalTime

func (col *Column) EvalTime(ctx sessionctx.Context, row chunk.Row) (types.Time, bool, error)

EvalTime returns DATE/DATETIME/TIMESTAMP representation of Column.

func (*Column) EvalVirtualColumn

func (col *Column) EvalVirtualColumn(row chunk.Row) (types.Datum, error)

EvalVirtualColumn evals the virtual column

func (*Column) ExplainInfo

func (col *Column) ExplainInfo() string

ExplainInfo implements the Expression interface.

func (*Column) ExplainNormalizedInfo

func (col *Column) ExplainNormalizedInfo() string

ExplainNormalizedInfo implements the Expression interface.

func (*Column) GetType

func (col *Column) GetType() *types.FieldType

GetType implements Expression interface.

func (*Column) HasCoercibility

func (c *Column) HasCoercibility() bool

func (*Column) HashCode

func (col *Column) HashCode(_ *stmtctx.StatementContext) []byte

HashCode implements Expression interface.

func (*Column) InColumnArray

func (col *Column) InColumnArray(cols []*Column) bool

InColumnArray check whether the col is in the cols array

func (*Column) IsCorrelated

func (col *Column) IsCorrelated() bool

IsCorrelated implements Expression interface.

func (*Column) MarshalJSON

func (col *Column) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (*Column) MemoryUsage

func (col *Column) MemoryUsage() (sum int64)

MemoryUsage return the memory usage of Column

func (*Column) RemapColumn

func (col *Column) RemapColumn(m map[int64]*Column) (Expression, error)

RemapColumn remaps columns with provided mapping and returns new expression

func (*Column) Repertoire

func (col *Column) Repertoire() Repertoire

Repertoire returns the repertoire value which is used to check collations.

func (*Column) ResolveIndices

func (col *Column) ResolveIndices(schema *Schema) (Expression, error)

ResolveIndices implements Expression interface.

func (*Column) ResolveIndicesByVirtualExpr

func (col *Column) ResolveIndicesByVirtualExpr(schema *Schema) (Expression, bool)

ResolveIndicesByVirtualExpr implements Expression interface.

func (*Column) ReverseEval

func (col *Column) ReverseEval(sc *stmtctx.StatementContext, res types.Datum, rType types.RoundingType) (val types.Datum, err error)

ReverseEval evaluates the only one column value with given function result.

func (*Column) SetCharsetAndCollation

func (c *Column) SetCharsetAndCollation(chs, coll string)

func (*Column) SetCoercibility

func (c *Column) SetCoercibility(val Coercibility)

SetCoercibility implements CollationInfo SetCoercibility interface.

func (*Column) SetRepertoire

func (c *Column) SetRepertoire(r Repertoire)

func (*Column) String

func (col *Column) String() string

String implements Stringer interface.

func (*Column) SupportReverseEval

func (col *Column) SupportReverseEval() bool

SupportReverseEval checks whether the builtinFunc support reverse evaluation.

func (*Column) ToInfo

func (col *Column) ToInfo() *model.ColumnInfo

ToInfo converts the expression.Column to model.ColumnInfo for casting values, beware it doesn't fill all the fields of the model.ColumnInfo.

func (*Column) VecEvalDecimal

func (col *Column) VecEvalDecimal(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalDecimal evaluates this expression in a vectorized manner.

func (*Column) VecEvalDuration

func (col *Column) VecEvalDuration(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalDuration evaluates this expression in a vectorized manner.

func (*Column) VecEvalInt

func (col *Column) VecEvalInt(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalInt evaluates this expression in a vectorized manner.

func (*Column) VecEvalJSON

func (col *Column) VecEvalJSON(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalJSON evaluates this expression in a vectorized manner.

func (*Column) VecEvalReal

func (col *Column) VecEvalReal(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalReal evaluates this expression in a vectorized manner.

func (*Column) VecEvalString

func (col *Column) VecEvalString(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalString evaluates this expression in a vectorized manner.

func (*Column) VecEvalTime

func (col *Column) VecEvalTime(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalTime evaluates this expression in a vectorized manner.

func (*Column) Vectorized

func (col *Column) Vectorized() bool

Vectorized returns if this expression supports vectorized evaluation.

type CompareFunc

type CompareFunc = func(sctx sessionctx.Context, lhsArg, rhsArg Expression, lhsRow, rhsRow chunk.Row) (int64, bool, error)

CompareFunc defines the compare function prototype.

func GetCmpFunction

func GetCmpFunction(ctx sessionctx.Context, lhs, rhs Expression) CompareFunc

GetCmpFunction get the compare function according to two arguments.

type Constant

type Constant struct {
	Value   types.Datum
	RetType *types.FieldType
	// DeferredExpr holds deferred function in PlanCache cached plan.
	// it's only used to represent non-deterministic functions(see expression.DeferredFunctions)
	// in PlanCache cached plan, so let them can be evaluated until cached item be used.
	DeferredExpr Expression
	// ParamMarker holds param index inside sessionVars.PreparedParams.
	// It's only used to reference a user variable provided in the `EXECUTE` statement or `COM_EXECUTE` binary protocol.
	ParamMarker *ParamMarker
	// contains filtered or unexported fields
}

Constant stands for a constant value.

func DatumToConstant

func DatumToConstant(d types.Datum, tp byte, flag uint) *Constant

DatumToConstant generates a Constant expression from a Datum.

func NewNull

func NewNull() *Constant

NewNull stands for null constant.

func NewOne

func NewOne() *Constant

NewOne stands for a number 1.

func NewZero

func NewZero() *Constant

NewZero stands for a number 0.

func ParamMarkerExpression

func ParamMarkerExpression(ctx sessionctx.Context, v *driver.ParamMarkerExpr, needParam bool) (*Constant, error)

ParamMarkerExpression generate a getparam function expression.

func RefineComparedConstant

func RefineComparedConstant(ctx sessionctx.Context, targetFieldType types.FieldType, con *Constant, op opcode.Op) (_ *Constant, isExceptional bool)

RefineComparedConstant changes a non-integer constant argument to its ceiling or floor result by the given op. isExceptional indicates whether the 'int column cmp const' might be true/false. If isExceptional is true, ExecptionalVal is returned. Or, CorrectVal is returned. CorrectVal: The computed result. If the constant can be converted to int without exception, return the val. Else return 'con'(the input). ExceptionalVal : It is used to get more information to check whether 'int column cmp const' is true/false

If the op == LT,LE,GT,GE and it gets an Overflow when converting, return inf/-inf.
If the op == EQ,NullEQ and the constant can never be equal to the int column, return ‘con’(the input, a non-int constant).

func (*Constant) CharsetAndCollation

func (c *Constant) CharsetAndCollation() (string, string)

func (*Constant) Clone

func (c *Constant) Clone() Expression

Clone implements Expression interface.

func (*Constant) Coercibility

func (c *Constant) Coercibility() Coercibility

Coercibility returns the coercibility value which is used to check collations.

func (*Constant) ConstItem

func (c *Constant) ConstItem(sc *stmtctx.StatementContext) bool

ConstItem implements Expression interface.

func (*Constant) Decorrelate

func (c *Constant) Decorrelate(_ *Schema) Expression

Decorrelate implements Expression interface.

func (*Constant) Equal

func (c *Constant) Equal(ctx sessionctx.Context, b Expression) bool

Equal implements Expression interface.

func (*Constant) Eval

func (c *Constant) Eval(row chunk.Row) (types.Datum, error)

Eval implements Expression interface.

func (*Constant) EvalDecimal

func (c *Constant) EvalDecimal(ctx sessionctx.Context, row chunk.Row) (*types.MyDecimal, bool, error)

EvalDecimal returns decimal representation of Constant.

func (*Constant) EvalDuration

func (c *Constant) EvalDuration(ctx sessionctx.Context, row chunk.Row) (val types.Duration, isNull bool, err error)

EvalDuration returns Duration representation of Constant.

func (*Constant) EvalInt

func (c *Constant) EvalInt(ctx sessionctx.Context, row chunk.Row) (int64, bool, error)

EvalInt returns int representation of Constant.

func (*Constant) EvalJSON

func (c *Constant) EvalJSON(ctx sessionctx.Context, row chunk.Row) (types.BinaryJSON, bool, error)

EvalJSON returns JSON representation of Constant.

func (*Constant) EvalReal

func (c *Constant) EvalReal(ctx sessionctx.Context, row chunk.Row) (float64, bool, error)

EvalReal returns real representation of Constant.

func (*Constant) EvalString

func (c *Constant) EvalString(ctx sessionctx.Context, row chunk.Row) (string, bool, error)

EvalString returns string representation of Constant.

func (*Constant) EvalTime

func (c *Constant) EvalTime(ctx sessionctx.Context, row chunk.Row) (val types.Time, isNull bool, err error)

EvalTime returns DATE/DATETIME/TIMESTAMP representation of Constant.

func (*Constant) ExplainInfo

func (expr *Constant) ExplainInfo() string

ExplainInfo implements the Expression interface.

func (*Constant) ExplainNormalizedInfo

func (expr *Constant) ExplainNormalizedInfo() string

ExplainNormalizedInfo implements the Expression interface.

func (*Constant) GetType

func (c *Constant) GetType() *types.FieldType

GetType implements Expression interface.

func (*Constant) HasCoercibility

func (c *Constant) HasCoercibility() bool

func (*Constant) HashCode

func (c *Constant) HashCode(sc *stmtctx.StatementContext) []byte

HashCode implements Expression interface.

func (*Constant) IsCorrelated

func (c *Constant) IsCorrelated() bool

IsCorrelated implements Expression interface.

func (*Constant) MarshalJSON

func (c *Constant) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (*Constant) MemoryUsage

func (c *Constant) MemoryUsage() (sum int64)

MemoryUsage return the memory usage of Constant

func (*Constant) RemapColumn

func (c *Constant) RemapColumn(_ map[int64]*Column) (Expression, error)

RemapColumn remaps columns with provided mapping and returns new expression

func (*Constant) Repertoire

func (c *Constant) Repertoire() Repertoire

func (*Constant) ResolveIndices

func (c *Constant) ResolveIndices(_ *Schema) (Expression, error)

ResolveIndices implements Expression interface.

func (*Constant) ResolveIndicesByVirtualExpr

func (c *Constant) ResolveIndicesByVirtualExpr(_ *Schema) (Expression, bool)

ResolveIndicesByVirtualExpr implements Expression interface.

func (*Constant) ReverseEval

func (c *Constant) ReverseEval(sc *stmtctx.StatementContext, res types.Datum, rType types.RoundingType) (val types.Datum, err error)

ReverseEval evaluates the only one column value with given function result.

func (*Constant) SetCharsetAndCollation

func (c *Constant) SetCharsetAndCollation(chs, coll string)

func (*Constant) SetCoercibility

func (c *Constant) SetCoercibility(val Coercibility)

SetCoercibility implements CollationInfo SetCoercibility interface.

func (*Constant) SetRepertoire

func (c *Constant) SetRepertoire(r Repertoire)

func (*Constant) String

func (c *Constant) String() string

String implements fmt.Stringer interface.

func (*Constant) SupportReverseEval

func (c *Constant) SupportReverseEval() bool

SupportReverseEval checks whether the builtinFunc support reverse evaluation.

func (*Constant) VecEvalDecimal

func (c *Constant) VecEvalDecimal(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalDecimal evaluates this expression in a vectorized manner.

func (*Constant) VecEvalDuration

func (c *Constant) VecEvalDuration(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalDuration evaluates this expression in a vectorized manner.

func (*Constant) VecEvalInt

func (c *Constant) VecEvalInt(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalInt evaluates this expression in a vectorized manner.

func (*Constant) VecEvalJSON

func (c *Constant) VecEvalJSON(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalJSON evaluates this expression in a vectorized manner.

func (*Constant) VecEvalReal

func (c *Constant) VecEvalReal(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalReal evaluates this expression in a vectorized manner.

func (*Constant) VecEvalString

func (c *Constant) VecEvalString(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalString evaluates this expression in a vectorized manner.

func (*Constant) VecEvalTime

func (c *Constant) VecEvalTime(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalTime evaluates this expression in a vectorized manner.

func (*Constant) Vectorized

func (c *Constant) Vectorized() bool

Vectorized returns if this expression supports vectorized evaluation.

type CorrelatedColumn

type CorrelatedColumn struct {
	Column

	Data *types.Datum
}

CorrelatedColumn stands for a column in a correlated sub query.

func ExtractCorColumns

func ExtractCorColumns(expr Expression) (cols []*CorrelatedColumn)

ExtractCorColumns extracts correlated column from given expression.

func (*CorrelatedColumn) CharsetAndCollation

func (c *CorrelatedColumn) CharsetAndCollation() (string, string)

func (*CorrelatedColumn) Clone

func (col *CorrelatedColumn) Clone() Expression

Clone implements Expression interface.

func (*CorrelatedColumn) ConstItem

func (col *CorrelatedColumn) ConstItem(_ *stmtctx.StatementContext) bool

ConstItem implements Expression interface.

func (*CorrelatedColumn) Decorrelate

func (col *CorrelatedColumn) Decorrelate(schema *Schema) Expression

Decorrelate implements Expression interface.

func (*CorrelatedColumn) Equal

func (col *CorrelatedColumn) Equal(ctx sessionctx.Context, expr Expression) bool

Equal implements Expression interface.

func (*CorrelatedColumn) Eval

func (col *CorrelatedColumn) Eval(row chunk.Row) (types.Datum, error)

Eval implements Expression interface.

func (*CorrelatedColumn) EvalDecimal

func (col *CorrelatedColumn) EvalDecimal(ctx sessionctx.Context, row chunk.Row) (*types.MyDecimal, bool, error)

EvalDecimal returns decimal representation of CorrelatedColumn.

func (*CorrelatedColumn) EvalDuration

func (col *CorrelatedColumn) EvalDuration(ctx sessionctx.Context, row chunk.Row) (types.Duration, bool, error)

EvalDuration returns Duration representation of CorrelatedColumn.

func (*CorrelatedColumn) EvalInt

func (col *CorrelatedColumn) EvalInt(ctx sessionctx.Context, row chunk.Row) (int64, bool, error)

EvalInt returns int representation of CorrelatedColumn.

func (*CorrelatedColumn) EvalJSON

func (col *CorrelatedColumn) EvalJSON(ctx sessionctx.Context, row chunk.Row) (types.BinaryJSON, bool, error)

EvalJSON returns JSON representation of CorrelatedColumn.

func (*CorrelatedColumn) EvalReal

func (col *CorrelatedColumn) EvalReal(ctx sessionctx.Context, row chunk.Row) (float64, bool, error)

EvalReal returns real representation of CorrelatedColumn.

func (*CorrelatedColumn) EvalString

func (col *CorrelatedColumn) EvalString(ctx sessionctx.Context, row chunk.Row) (string, bool, error)

EvalString returns string representation of CorrelatedColumn.

func (*CorrelatedColumn) EvalTime

func (col *CorrelatedColumn) EvalTime(ctx sessionctx.Context, row chunk.Row) (types.Time, bool, error)

EvalTime returns DATE/DATETIME/TIMESTAMP representation of CorrelatedColumn.

func (*CorrelatedColumn) HasCoercibility

func (c *CorrelatedColumn) HasCoercibility() bool

func (*CorrelatedColumn) IsCorrelated

func (col *CorrelatedColumn) IsCorrelated() bool

IsCorrelated implements Expression interface.

func (*CorrelatedColumn) MemoryUsage

func (col *CorrelatedColumn) MemoryUsage() (sum int64)

MemoryUsage return the memory usage of CorrelatedColumn

func (*CorrelatedColumn) RemapColumn

func (col *CorrelatedColumn) RemapColumn(m map[int64]*Column) (Expression, error)

RemapColumn remaps columns with provided mapping and returns new expression

func (*CorrelatedColumn) ResolveIndices

func (col *CorrelatedColumn) ResolveIndices(_ *Schema) (Expression, error)

ResolveIndices implements Expression interface.

func (*CorrelatedColumn) ResolveIndicesByVirtualExpr

func (col *CorrelatedColumn) ResolveIndicesByVirtualExpr(_ *Schema) (Expression, bool)

ResolveIndicesByVirtualExpr implements Expression interface.

func (*CorrelatedColumn) SetCharsetAndCollation

func (c *CorrelatedColumn) SetCharsetAndCollation(chs, coll string)

func (*CorrelatedColumn) SetCoercibility

func (c *CorrelatedColumn) SetCoercibility(val Coercibility)

SetCoercibility implements CollationInfo SetCoercibility interface.

func (*CorrelatedColumn) SetRepertoire

func (c *CorrelatedColumn) SetRepertoire(r Repertoire)

func (*CorrelatedColumn) VecEvalDecimal

func (col *CorrelatedColumn) VecEvalDecimal(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalDecimal evaluates this expression in a vectorized manner.

func (*CorrelatedColumn) VecEvalDuration

func (col *CorrelatedColumn) VecEvalDuration(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalDuration evaluates this expression in a vectorized manner.

func (*CorrelatedColumn) VecEvalInt

func (col *CorrelatedColumn) VecEvalInt(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalInt evaluates this expression in a vectorized manner.

func (*CorrelatedColumn) VecEvalJSON

func (col *CorrelatedColumn) VecEvalJSON(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalJSON evaluates this expression in a vectorized manner.

func (*CorrelatedColumn) VecEvalReal

func (col *CorrelatedColumn) VecEvalReal(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalReal evaluates this expression in a vectorized manner.

func (*CorrelatedColumn) VecEvalString

func (col *CorrelatedColumn) VecEvalString(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalString evaluates this expression in a vectorized manner.

func (*CorrelatedColumn) VecEvalTime

func (col *CorrelatedColumn) VecEvalTime(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalTime evaluates this expression in a vectorized manner.

type EvaluatorSuite

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

EvaluatorSuite is responsible for the evaluation of a list of expressions. It separates them to "column" and "other" expressions and evaluates "other" expressions before "column" expressions.

func NewEvaluatorSuite

func NewEvaluatorSuite(exprs []Expression, avoidColumnEvaluator bool) *EvaluatorSuite

NewEvaluatorSuite creates an EvaluatorSuite to evaluate all the exprs. avoidColumnEvaluator can be removed after column pool is supported.

func (*EvaluatorSuite) Run

func (e *EvaluatorSuite) Run(ctx sessionctx.Context, input, output *chunk.Chunk) error

Run evaluates all the expressions hold by this EvaluatorSuite. NOTE: "defaultEvaluator" must be evaluated before "columnEvaluator".

func (*EvaluatorSuite) Vectorizable

func (e *EvaluatorSuite) Vectorizable() bool

Vectorizable checks whether this EvaluatorSuite can use vectorizd execution mode.

type ExprCollation

type ExprCollation struct {
	Coer      Coercibility
	Repe      Repertoire
	Charset   string
	Collation string
}

ExprCollation is a struct that store the collation related information.

func CheckAndDeriveCollationFromExprs

func CheckAndDeriveCollationFromExprs(ctx sessionctx.Context, funcName string, evalType types.EvalType, args ...Expression) (et *ExprCollation, err error)

CheckAndDeriveCollationFromExprs derives collation information from these expressions, return error if derives collation error.

type Expression

type Expression interface {
	fmt.Stringer
	goJSON.Marshaler
	VecExpr
	ReverseExpr
	CollationInfo

	// Eval evaluates an expression through a row.
	Eval(row chunk.Row) (types.Datum, error)

	// EvalInt returns the int64 representation of expression.
	EvalInt(ctx sessionctx.Context, row chunk.Row) (val int64, isNull bool, err error)

	// EvalReal returns the float64 representation of expression.
	EvalReal(ctx sessionctx.Context, row chunk.Row) (val float64, isNull bool, err error)

	// EvalString returns the string representation of expression.
	EvalString(ctx sessionctx.Context, row chunk.Row) (val string, isNull bool, err error)

	// EvalDecimal returns the decimal representation of expression.
	EvalDecimal(ctx sessionctx.Context, row chunk.Row) (val *types.MyDecimal, isNull bool, err error)

	// EvalTime returns the DATE/DATETIME/TIMESTAMP representation of expression.
	EvalTime(ctx sessionctx.Context, row chunk.Row) (val types.Time, isNull bool, err error)

	// EvalDuration returns the duration representation of expression.
	EvalDuration(ctx sessionctx.Context, row chunk.Row) (val types.Duration, isNull bool, err error)

	// EvalJSON returns the JSON representation of expression.
	EvalJSON(ctx sessionctx.Context, row chunk.Row) (val types.BinaryJSON, isNull bool, err error)

	// GetType gets the type that the expression returns.
	GetType() *types.FieldType

	// Clone copies an expression totally.
	Clone() Expression

	// Equal checks whether two expressions are equal.
	Equal(ctx sessionctx.Context, e Expression) bool

	// IsCorrelated checks if this expression has correlated key.
	IsCorrelated() bool

	// ConstItem checks if this expression is constant item, regardless of query evaluation state.
	// An expression is constant item if it:
	// refers no tables.
	// refers no correlated column.
	// refers no subqueries that refers any tables.
	// refers no non-deterministic functions.
	// refers no statement parameters.
	// refers no param markers when prepare plan cache is enabled.
	ConstItem(sc *stmtctx.StatementContext) bool

	// Decorrelate try to decorrelate the expression by schema.
	Decorrelate(schema *Schema) Expression

	// ResolveIndices resolves indices by the given schema. It will copy the original expression and return the copied one.
	ResolveIndices(schema *Schema) (Expression, error)

	// ResolveIndicesByVirtualExpr resolves indices by the given schema in terms of virual expression. It will copy the original expression and return the copied one.
	ResolveIndicesByVirtualExpr(schema *Schema) (Expression, bool)

	// RemapColumn remaps columns with provided mapping and returns new expression
	RemapColumn(map[int64]*Column) (Expression, error)

	// ExplainInfo returns operator information to be explained.
	ExplainInfo() string

	// ExplainNormalizedInfo returns operator normalized information for generating digest.
	ExplainNormalizedInfo() string

	// HashCode creates the hashcode for expression which can be used to identify itself from other expression.
	// It generated as the following:
	// Constant: ConstantFlag+encoded value
	// Column: ColumnFlag+encoded value
	// ScalarFunction: SFFlag+encoded function name + encoded arg_1 + encoded arg_2 + ...
	HashCode(sc *stmtctx.StatementContext) []byte

	// MemoryUsage return the memory usage of Expression
	MemoryUsage() int64
	// contains filtered or unexported methods
}

Expression represents all scalar expression in SQL.

func Args2Expressions4Test

func Args2Expressions4Test(args ...interface{}) []Expression

Args2Expressions4Test converts these values to an expression list. This conversion is incomplete, so only use for test.

func BuildCastCollationFunction

func BuildCastCollationFunction(ctx sessionctx.Context, expr Expression, ec *ExprCollation, enumOrSetRealTypeIsStr bool) Expression

BuildCastCollationFunction builds a ScalarFunction which casts the collation.

func BuildCastFunction

func BuildCastFunction(ctx sessionctx.Context, expr Expression, tp *types.FieldType) (res Expression)

BuildCastFunction builds a CAST ScalarFunction from the Expression.

func BuildCastFunction4Union

func BuildCastFunction4Union(ctx sessionctx.Context, expr Expression, tp *types.FieldType) (res Expression)

BuildCastFunction4Union build a implicitly CAST ScalarFunction from the Union Expression.

func BuildCastFunctionWithCheck

func BuildCastFunctionWithCheck(ctx sessionctx.Context, expr Expression, tp *types.FieldType) (res Expression, err error)

BuildCastFunctionWithCheck builds a CAST ScalarFunction from the Expression and return error if any.

func BuildFromBinaryFunction

func BuildFromBinaryFunction(ctx sessionctx.Context, expr Expression, tp *types.FieldType) (res Expression)

BuildFromBinaryFunction builds from_binary function.

func BuildGetVarFunction

func BuildGetVarFunction(ctx sessionctx.Context, expr Expression, retType *types.FieldType) (Expression, error)

BuildGetVarFunction builds a GetVar ScalarFunction from the Expression.

func BuildNotNullExpr

func BuildNotNullExpr(ctx sessionctx.Context, expr Expression) Expression

BuildNotNullExpr wraps up `not(isnull())` for given expression.

func BuildToBinaryFunction

func BuildToBinaryFunction(ctx sessionctx.Context, expr Expression) (res Expression)

BuildToBinaryFunction builds to_binary function.

func Column2Exprs

func Column2Exprs(cols []*Column) []Expression

Column2Exprs will transfer column slice to expression slice.

func ColumnSubstitute

func ColumnSubstitute(expr Expression, schema *Schema, newExprs []Expression) Expression

ColumnSubstitute substitutes the columns in filter to expressions in select fields. e.g. select * from (select b as a from t) k where a < 10 => select * from (select b as a from t where b < 10) k.

func ColumnSubstituteAll

func ColumnSubstituteAll(expr Expression, schema *Schema, newExprs []Expression) (bool, Expression)

ColumnSubstituteAll substitutes the columns just like ColumnSubstitute, but we don't accept partial substitution. Only accept:

1: substitute them all once find col in schema.
2: nothing in expr can be substituted.

func ColumnSubstituteImpl

func ColumnSubstituteImpl(expr Expression, schema *Schema, newExprs []Expression, fail1Return bool) (bool, bool, Expression)

ColumnSubstituteImpl tries to substitute column expr using newExprs, the newFunctionInternal is only called if its child is substituted @return bool means whether the expr has changed. @return bool means whether the expr should change (has the dependency in schema, while the corresponding expr has some compatibility), but finally fallback. @return Expression, the original expr or the changed expr, it depends on the first @return bool.

func ComposeCNFCondition

func ComposeCNFCondition(ctx sessionctx.Context, conditions ...Expression) Expression

ComposeCNFCondition composes CNF items into a balance deep CNF tree, which benefits a lot for pb decoder/encoder.

func ComposeDNFCondition

func ComposeDNFCondition(ctx sessionctx.Context, conditions ...Expression) Expression

ComposeDNFCondition composes DNF items into a balance deep DNF tree.

func DeriveRelaxedFiltersFromDNF

func DeriveRelaxedFiltersFromDNF(expr Expression, schema *Schema) Expression

DeriveRelaxedFiltersFromDNF given a DNF expression, derive a relaxed DNF expression which only contains columns in specified schema; the derived expression is a superset of original expression, i.e, any tuple satisfying the original expression must satisfy the derived expression. Return nil when the derived expression is universal set. A running example is: for schema of t1, `(t1.a=1 and t2.a=1) or (t1.a=2 and t2.a=2)` would be derived as `t1.a=1 or t1.a=2`, while `t1.a=1 or t2.a=1` would get nil.

func EvaluateExprWithNull

func EvaluateExprWithNull(ctx sessionctx.Context, schema *Schema, expr Expression) Expression

EvaluateExprWithNull sets columns in schema as null and calculate the final result of the scalar function. If the Expression is a non-constant value, it means the result is unknown.

func ExtractConstantEqColumnsOrScalar

func ExtractConstantEqColumnsOrScalar(ctx sessionctx.Context, result []Expression, exprs []Expression) []Expression

ExtractConstantEqColumnsOrScalar detects the constant equal relationship from CNF exprs.

func ExtractFiltersFromDNFs

func ExtractFiltersFromDNFs(ctx sessionctx.Context, conditions []Expression) []Expression

ExtractFiltersFromDNFs checks whether the cond is DNF. If so, it will get the extracted part and the remained part. The original DNF will be replaced by the remained part or just be deleted if remained part is nil. And the extracted part will be appended to the end of the orignal slice.

func Filter

func Filter(result []Expression, input []Expression, filter func(Expression) bool) []Expression

Filter the input expressions, append the results to result.

func FilterOutInPlace

func FilterOutInPlace(input []Expression, filter func(Expression) bool) (remained, filteredOut []Expression)

FilterOutInPlace do the filtering out in place. The remained are the ones who doesn't match the filter, storing in the original slice. The filteredOut are the ones match the filter, storing in a new slice.

func FlattenCNFConditions

func FlattenCNFConditions(CNFCondition *ScalarFunction) []Expression

FlattenCNFConditions extracts CNF expression's leaf item. e.g. and(and(a>1, a>2), and(a>3, a>4)), we'll get [a>1, a>2, a>3, a>4].

func FlattenDNFConditions

func FlattenDNFConditions(DNFCondition *ScalarFunction) []Expression

FlattenDNFConditions extracts DNF expression's leaf item. e.g. or(or(a=1, a=2), or(a=3, a=4)), we'll get [a=1, a=2, a=3, a=4].

func FoldConstant

func FoldConstant(expr Expression) Expression

FoldConstant does constant folding optimization on an expression excluding deferred ones.

func GetExprInsideIsTruth

func GetExprInsideIsTruth(expr Expression) Expression

GetExprInsideIsTruth get the expression inside the `istrue_with_null` and `istrue`. This is useful when handling expressions from "not" or "!", because we might wrap `istrue_with_null` or `istrue` when handling them. See pushNotAcrossExpr() and wrapWithIsTrue() for details.

func GetFuncArg

func GetFuncArg(e Expression, idx int) Expression

GetFuncArg gets the argument of the function at idx.

func HandleBinaryLiteral

func HandleBinaryLiteral(ctx sessionctx.Context, expr Expression, ec *ExprCollation, funcName string) Expression

HandleBinaryLiteral wraps `expr` with to_binary or from_binary sig.

func NewFunction

func NewFunction(ctx sessionctx.Context, funcName string, retType *types.FieldType, args ...Expression) (Expression, error)

NewFunction creates a new scalar function or constant via a constant folding.

func NewFunctionBase

func NewFunctionBase(ctx sessionctx.Context, funcName string, retType *types.FieldType, args ...Expression) (Expression, error)

NewFunctionBase creates a new scalar function with no constant folding.

func NewFunctionInternal

func NewFunctionInternal(ctx sessionctx.Context, funcName string, retType *types.FieldType, args ...Expression) Expression

NewFunctionInternal is similar to NewFunction, but do not returns error, should only be used internally.

func NewFunctionTryFold

func NewFunctionTryFold(ctx sessionctx.Context, funcName string, retType *types.FieldType, args ...Expression) (Expression, error)

NewFunctionTryFold creates a new scalar function with trying constant folding.

func PBToExpr

func PBToExpr(expr *tipb.Expr, tps []*types.FieldType, sc *stmtctx.StatementContext) (Expression, error)

PBToExpr converts pb structure to expression.

func PBToExprs

func PBToExprs(pbExprs []*tipb.Expr, fieldTps []*types.FieldType, sc *stmtctx.StatementContext) ([]Expression, error)

PBToExprs converts pb structures to expressions.

func ParseSimpleExprCastWithTableInfo

func ParseSimpleExprCastWithTableInfo(ctx sessionctx.Context, exprStr string, tableInfo *model.TableInfo, targetFt *types.FieldType) (Expression, error)

ParseSimpleExprCastWithTableInfo parses simple expression string to Expression. And the expr returns will cast to the target type.

func ParseSimpleExprWithTableInfo

func ParseSimpleExprWithTableInfo(ctx sessionctx.Context, exprStr string, tableInfo *model.TableInfo) (Expression, error)

ParseSimpleExprWithTableInfo parses simple expression string to Expression. The expression string must only reference the column in table Info.

func ParseSimpleExprsWithNames

func ParseSimpleExprsWithNames(ctx sessionctx.Context, exprStr string, schema *Schema, names types.NameSlice) ([]Expression, error)

ParseSimpleExprsWithNames parses simple expression string to Expression. The expression string must only reference the column in the given NameSlice.

func PopRowFirstArg

func PopRowFirstArg(ctx sessionctx.Context, e Expression) (ret Expression, err error)

PopRowFirstArg pops the first element and returns the rest of row. e.g. After this function (1, 2, 3) becomes (2, 3).

func PropagateConstant

func PropagateConstant(ctx sessionctx.Context, conditions []Expression) []Expression

PropagateConstant propagate constant values of deterministic predicates in a condition.

func PushDownNot

func PushDownNot(ctx sessionctx.Context, expr Expression) Expression

PushDownNot pushes the `not` function down to the expression's arguments.

func RemoveDupExprs

func RemoveDupExprs(ctx sessionctx.Context, exprs []Expression) []Expression

RemoveDupExprs removes identical exprs. Not that if expr contains functions which are mutable or have side effects, we cannot remove it even if it has duplicates; if the plan is going to be cached, we cannot remove expressions containing `?` neither.

func RewriteSimpleExprWithNames

func RewriteSimpleExprWithNames(ctx sessionctx.Context, expr ast.ExprNode, schema *Schema, names []*types.FieldName) (Expression, error)

RewriteSimpleExprWithNames rewrites simple ast.ExprNode to expression.Expression.

func RewriteSimpleExprWithTableInfo

func RewriteSimpleExprWithTableInfo(ctx sessionctx.Context, tbl *model.TableInfo, expr ast.ExprNode, allowCastArray bool) (Expression, error)

RewriteSimpleExprWithTableInfo rewrites simple ast.ExprNode to expression.Expression.

func ScalarFuncs2Exprs

func ScalarFuncs2Exprs(funcs []*ScalarFunction) []Expression

ScalarFuncs2Exprs converts []*ScalarFunction to []Expression.

func SetExprColumnInOperand

func SetExprColumnInOperand(expr Expression) Expression

SetExprColumnInOperand is used to set columns in expr as InOperand.

func SplitCNFItems

func SplitCNFItems(onExpr Expression) []Expression

SplitCNFItems splits CNF items. CNF means conjunctive normal form, e.g. "a and b and c".

func SplitDNFItems

func SplitDNFItems(onExpr Expression) []Expression

SplitDNFItems splits DNF items. DNF means disjunctive normal form, e.g. "a or b or c".

func SubstituteCorCol2Constant

func SubstituteCorCol2Constant(expr Expression) (Expression, error)

SubstituteCorCol2Constant will substitute correlated column to constant value which it contains. If the args of one scalar function are all constant, we will substitute it to constant.

func TryPushCastIntoControlFunctionForHybridType

func TryPushCastIntoControlFunctionForHybridType(ctx sessionctx.Context, expr Expression, tp *types.FieldType) (res Expression)

TryPushCastIntoControlFunctionForHybridType try to push cast into control function for Hybrid Type. If necessary, it will rebuild control function using changed args. When a hybrid type is the output of a control function, the result may be as a numeric type to subsequent calculation We should perform the `Cast` operation early to avoid using the wrong type for calculation For example, the condition `if(1, e, 'a') = 1`, `if` function will output `e` and compare with `1`. If the evaltype is ETString, it will get wrong result. So we can rewrite the condition to `IfInt(1, cast(e as int), cast('a' as int)) = 1` to get the correct result.

func WrapWithCastAsDecimal

func WrapWithCastAsDecimal(ctx sessionctx.Context, expr Expression) Expression

WrapWithCastAsDecimal wraps `expr` with `cast` if the return type of expr is not type decimal, otherwise, returns `expr` directly.

func WrapWithCastAsDuration

func WrapWithCastAsDuration(ctx sessionctx.Context, expr Expression) Expression

WrapWithCastAsDuration wraps `expr` with `cast` if the return type of expr is not type duration, otherwise, returns `expr` directly.

func WrapWithCastAsInt

func WrapWithCastAsInt(ctx sessionctx.Context, expr Expression) Expression

WrapWithCastAsInt wraps `expr` with `cast` if the return type of expr is not type int, otherwise, returns `expr` directly.

func WrapWithCastAsJSON

func WrapWithCastAsJSON(ctx sessionctx.Context, expr Expression) Expression

WrapWithCastAsJSON wraps `expr` with `cast` if the return type of expr is not type json, otherwise, returns `expr` directly.

func WrapWithCastAsReal

func WrapWithCastAsReal(ctx sessionctx.Context, expr Expression) Expression

WrapWithCastAsReal wraps `expr` with `cast` if the return type of expr is not type real, otherwise, returns `expr` directly.

func WrapWithCastAsString

func WrapWithCastAsString(ctx sessionctx.Context, expr Expression) Expression

WrapWithCastAsString wraps `expr` with `cast` if the return type of expr is not type string, otherwise, returns `expr` directly.

func WrapWithCastAsTime

func WrapWithCastAsTime(ctx sessionctx.Context, expr Expression, tp *types.FieldType) Expression

WrapWithCastAsTime wraps `expr` with `cast` if the return type of expr is not same as type of the specified `tp` , otherwise, returns `expr` directly.

type GLCmpStringMode

type GLCmpStringMode uint8

GLCmpStringMode represents Greatest/Least interal string comparison mode

const (
	// GLCmpStringDirectly Greatest and Least function compares string directly
	GLCmpStringDirectly GLCmpStringMode = iota
	// GLCmpStringAsDate Greatest/Least function compares string as 'yyyy-mm-dd' format
	GLCmpStringAsDate
	// GLCmpStringAsDatetime Greatest/Least function compares string as 'yyyy-mm-dd hh:mm:ss' format
	GLCmpStringAsDatetime
)

type GLRetTimeType

type GLRetTimeType uint8

GLRetTimeType represents Greatest/Least return time type

const (
	// GLRetNoneTemporal Greatest/Least function returns non temporal time
	GLRetNoneTemporal GLRetTimeType = iota
	// GLRetDate Greatest/Least function returns date type, 'yyyy-mm-dd'
	GLRetDate
	// GLRetDatetime Greatest/Least function returns datetime type, 'yyyy-mm-dd hh:mm:ss'
	GLRetDatetime
)

type KeyInfo

type KeyInfo []*Column

KeyInfo stores the columns of one unique key or primary key.

func (KeyInfo) Clone

func (ki KeyInfo) Clone() KeyInfo

Clone copies the entire UniqueKey.

func (KeyInfo) String

func (ki KeyInfo) String() string

String implements fmt.Stringer interface.

type ParamMarker

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

ParamMarker indicates param provided by COM_STMT_EXECUTE.

func (*ParamMarker) GetUserVar

func (d *ParamMarker) GetUserVar() types.Datum

GetUserVar returns the corresponding user variable presented in the `EXECUTE` statement or `COM_EXECUTE` command.

type ParamMarkerInPrepareChecker

type ParamMarkerInPrepareChecker struct {
	InPrepareStmt bool
}

ParamMarkerInPrepareChecker checks whether the given ast tree has paramMarker and is in prepare statement.

func (*ParamMarkerInPrepareChecker) Enter

func (pc *ParamMarkerInPrepareChecker) Enter(in ast.Node) (out ast.Node, skipChildren bool)

Enter implements Visitor Interface.

func (*ParamMarkerInPrepareChecker) Leave

func (pc *ParamMarkerInPrepareChecker) Leave(in ast.Node) (out ast.Node, ok bool)

Leave implements Visitor Interface.

type PbConverter

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

PbConverter supplies methods to convert TiDB expressions to TiPB.

func NewPBConverter

func NewPBConverter(client kv.Client, sc *stmtctx.StatementContext) PbConverter

NewPBConverter creates a PbConverter.

func (PbConverter) ExprToPB

func (pc PbConverter) ExprToPB(expr Expression) *tipb.Expr

ExprToPB converts Expression to TiPB.

type PropagateConstantSolver

type PropagateConstantSolver interface {
	PropagateConstant(ctx sessionctx.Context, conditions []Expression) []Expression
}

PropagateConstantSolver is a constant propagate solver.

type Repertoire

type Repertoire int

The Repertoire of a character set is the collection of characters in the set. See https://dev.mysql.com/doc/refman/8.0/en/charset-repertoire.html. Only String expression has Repertoire, for non-string expression, it does not matter what the value it is.

type ReverseExpr

type ReverseExpr interface {
	// SupportReverseEval checks whether the builtinFunc support reverse evaluation.
	SupportReverseEval() bool

	// ReverseEval evaluates the only one column value with given function result.
	ReverseEval(sc *stmtctx.StatementContext, res types.Datum, rType types.RoundingType) (val types.Datum, err error)
}

ReverseExpr contains all resersed evaluation methods.

type SQLDigestTextRetriever

type SQLDigestTextRetriever struct {
	// SQLDigestsMap is the place to put the digests that's requested for getting SQL text and also the place to put
	// the query result.
	SQLDigestsMap map[string]string
	// contains filtered or unexported fields
}

SQLDigestTextRetriever is used to find the normalized SQL statement text by SQL digests in statements_summary table. It's exported for test purposes. It's used by the `tidb_decode_sql_digests` builtin function, but also exposed to be used in other modules.

func NewSQLDigestTextRetriever

func NewSQLDigestTextRetriever() *SQLDigestTextRetriever

NewSQLDigestTextRetriever creates a new SQLDigestTextRetriever.

func (*SQLDigestTextRetriever) RetrieveGlobal

func (r *SQLDigestTextRetriever) RetrieveGlobal(ctx context.Context, sctx sessionctx.Context) error

RetrieveGlobal tries to retrieve the SQL text of the SQL digests from the information of the whole cluster.

func (*SQLDigestTextRetriever) RetrieveLocal

func (r *SQLDigestTextRetriever) RetrieveLocal(ctx context.Context, sctx sessionctx.Context) error

RetrieveLocal tries to retrieve the SQL text of the SQL digests from local information.

type ScalarFunction

type ScalarFunction struct {
	FuncName model.CIStr
	// RetType is the type that ScalarFunction returns.
	// TODO: Implement type inference here, now we use ast's return type temporarily.
	RetType  *types.FieldType
	Function builtinFunc
	// contains filtered or unexported fields
}

ScalarFunction is the function that returns a value.

func NewValuesFunc

func NewValuesFunc(ctx sessionctx.Context, offset int, retTp *types.FieldType) *ScalarFunction

NewValuesFunc creates a new values function.

func (*ScalarFunction) CharsetAndCollation

func (sf *ScalarFunction) CharsetAndCollation() (string, string)

CharsetAndCollation gets charset and collation.

func (*ScalarFunction) Clone

func (sf *ScalarFunction) Clone() Expression

Clone implements Expression interface.

func (*ScalarFunction) Coercibility

func (sf *ScalarFunction) Coercibility() Coercibility

Coercibility returns the coercibility value which is used to check collations.

func (*ScalarFunction) ConstItem

func (sf *ScalarFunction) ConstItem(sc *stmtctx.StatementContext) bool

ConstItem implements Expression interface.

func (*ScalarFunction) Decorrelate

func (sf *ScalarFunction) Decorrelate(schema *Schema) Expression

Decorrelate implements Expression interface.

func (*ScalarFunction) Equal

func (sf *ScalarFunction) Equal(ctx sessionctx.Context, e Expression) bool

Equal implements Expression interface.

func (*ScalarFunction) Eval

func (sf *ScalarFunction) Eval(row chunk.Row) (d types.Datum, err error)

Eval implements Expression interface.

func (*ScalarFunction) EvalDecimal

func (sf *ScalarFunction) EvalDecimal(ctx sessionctx.Context, row chunk.Row) (*types.MyDecimal, bool, error)

EvalDecimal implements Expression interface.

func (*ScalarFunction) EvalDuration

func (sf *ScalarFunction) EvalDuration(ctx sessionctx.Context, row chunk.Row) (types.Duration, bool, error)

EvalDuration implements Expression interface.

func (*ScalarFunction) EvalInt

func (sf *ScalarFunction) EvalInt(ctx sessionctx.Context, row chunk.Row) (int64, bool, error)

EvalInt implements Expression interface.

func (*ScalarFunction) EvalJSON

func (sf *ScalarFunction) EvalJSON(ctx sessionctx.Context, row chunk.Row) (types.BinaryJSON, bool, error)

EvalJSON implements Expression interface.

func (*ScalarFunction) EvalReal

func (sf *ScalarFunction) EvalReal(ctx sessionctx.Context, row chunk.Row) (float64, bool, error)

EvalReal implements Expression interface.

func (*ScalarFunction) EvalString

func (sf *ScalarFunction) EvalString(ctx sessionctx.Context, row chunk.Row) (string, bool, error)

EvalString implements Expression interface.

func (*ScalarFunction) EvalTime

func (sf *ScalarFunction) EvalTime(ctx sessionctx.Context, row chunk.Row) (types.Time, bool, error)

EvalTime implements Expression interface.

func (*ScalarFunction) ExplainInfo

func (expr *ScalarFunction) ExplainInfo() string

ExplainInfo implements the Expression interface.

func (*ScalarFunction) ExplainNormalizedInfo

func (expr *ScalarFunction) ExplainNormalizedInfo() string

ExplainNormalizedInfo implements the Expression interface.

func (*ScalarFunction) GetArgs

func (sf *ScalarFunction) GetArgs() []Expression

GetArgs gets arguments of function.

func (*ScalarFunction) GetCtx

func (sf *ScalarFunction) GetCtx() sessionctx.Context

GetCtx gets the context of function.

func (*ScalarFunction) GetSingleColumn

func (sf *ScalarFunction) GetSingleColumn(reverse bool) (*Column, bool)

GetSingleColumn returns (Col, Desc) when the ScalarFunction is equivalent to (Col, Desc) when used as a sort key, otherwise returns (nil, false).

Can only handle: - ast.Plus - ast.Minus - ast.UnaryMinus

func (*ScalarFunction) GetType

func (sf *ScalarFunction) GetType() *types.FieldType

GetType implements Expression interface.

func (*ScalarFunction) HasCoercibility

func (sf *ScalarFunction) HasCoercibility() bool

HasCoercibility ...

func (*ScalarFunction) HashCode

func (sf *ScalarFunction) HashCode(sc *stmtctx.StatementContext) []byte

HashCode implements Expression interface.

func (*ScalarFunction) IsCorrelated

func (sf *ScalarFunction) IsCorrelated() bool

IsCorrelated implements Expression interface.

func (*ScalarFunction) MarshalJSON

func (sf *ScalarFunction) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (*ScalarFunction) MemoryUsage

func (sf *ScalarFunction) MemoryUsage() (sum int64)

MemoryUsage return the memory usage of ScalarFunction

func (*ScalarFunction) RemapColumn

func (sf *ScalarFunction) RemapColumn(m map[int64]*Column) (Expression, error)

RemapColumn remaps columns with provided mapping and returns new expression

func (*ScalarFunction) Repertoire

func (sf *ScalarFunction) Repertoire() Repertoire

Repertoire returns the repertoire value which is used to check collations.

func (*ScalarFunction) ResolveIndices

func (sf *ScalarFunction) ResolveIndices(schema *Schema) (Expression, error)

ResolveIndices implements Expression interface.

func (*ScalarFunction) ResolveIndicesByVirtualExpr

func (sf *ScalarFunction) ResolveIndicesByVirtualExpr(schema *Schema) (Expression, bool)

ResolveIndicesByVirtualExpr implements Expression interface.

func (*ScalarFunction) ReverseEval

func (sf *ScalarFunction) ReverseEval(sc *stmtctx.StatementContext, res types.Datum, rType types.RoundingType) (val types.Datum, err error)

ReverseEval evaluates the only one column value with given function result.

func (*ScalarFunction) SetCharsetAndCollation

func (sf *ScalarFunction) SetCharsetAndCollation(chs, coll string)

SetCharsetAndCollation sets charset and collation.

func (*ScalarFunction) SetCoercibility

func (sf *ScalarFunction) SetCoercibility(val Coercibility)

SetCoercibility sets a specified coercibility for this expression.

func (*ScalarFunction) SetRepertoire

func (sf *ScalarFunction) SetRepertoire(r Repertoire)

SetRepertoire sets a specified repertoire for this expression.

func (*ScalarFunction) String

func (sf *ScalarFunction) String() string

String implements fmt.Stringer interface.

func (*ScalarFunction) SupportReverseEval

func (sf *ScalarFunction) SupportReverseEval() bool

SupportReverseEval returns if this expression supports reversed evaluation.

func (*ScalarFunction) VecEvalDecimal

func (sf *ScalarFunction) VecEvalDecimal(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalDecimal evaluates this expression in a vectorized manner.

func (*ScalarFunction) VecEvalDuration

func (sf *ScalarFunction) VecEvalDuration(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalDuration evaluates this expression in a vectorized manner.

func (*ScalarFunction) VecEvalInt

func (sf *ScalarFunction) VecEvalInt(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalInt evaluates this expression in a vectorized manner.

func (*ScalarFunction) VecEvalJSON

func (sf *ScalarFunction) VecEvalJSON(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalJSON evaluates this expression in a vectorized manner.

func (*ScalarFunction) VecEvalReal

func (sf *ScalarFunction) VecEvalReal(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalReal evaluates this expression in a vectorized manner.

func (*ScalarFunction) VecEvalString

func (sf *ScalarFunction) VecEvalString(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalString evaluates this expression in a vectorized manner.

func (*ScalarFunction) VecEvalTime

func (sf *ScalarFunction) VecEvalTime(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

VecEvalTime evaluates this expression in a vectorized manner.

func (*ScalarFunction) Vectorized

func (sf *ScalarFunction) Vectorized() bool

Vectorized returns if this expression supports vectorized evaluation.

type Schema

type Schema struct {
	Columns []*Column
	Keys    []KeyInfo
	// UniqueKeys stores those unique indexes that allow null values, but Keys does not allow null values.
	// since equivalence conditions can filter out null values, in this case a unique index with null values can be a Key.
	UniqueKeys []KeyInfo
}

Schema stands for the row schema and unique key information get from input.

func MergeSchema

func MergeSchema(lSchema, rSchema *Schema) *Schema

MergeSchema will merge two schema into one schema. We shouldn't need to consider unique keys. That will be processed in build_key_info.go.

func NewSchema

func NewSchema(cols ...*Column) *Schema

NewSchema returns a schema made by its parameter.

func TableInfo2SchemaAndNames

func TableInfo2SchemaAndNames(ctx sessionctx.Context, dbName model.CIStr, tbl *model.TableInfo) (*Schema, []*types.FieldName, error)

TableInfo2SchemaAndNames converts the TableInfo to the schema and name slice.

func (*Schema) Append

func (s *Schema) Append(col ...*Column)

Append append new column to the columns stored in schema.

func (*Schema) Clone

func (s *Schema) Clone() *Schema

Clone copies the total schema.

func (*Schema) ColumnIndex

func (s *Schema) ColumnIndex(col *Column) int

ColumnIndex finds the index for a column.

func (*Schema) ColumnsByIndices

func (s *Schema) ColumnsByIndices(offsets []int) []*Column

ColumnsByIndices returns columns by multiple offsets. Callers should guarantee that all the offsets provided should be valid, which means offset should: 1. not smaller than 0, and 2. not exceed len(s.Columns)

func (*Schema) ColumnsIndices

func (s *Schema) ColumnsIndices(cols []*Column) (ret []int)

ColumnsIndices will return a slice which contains the position of each column in schema. If there is one column that doesn't match, nil will be returned.

func (*Schema) Contains

func (s *Schema) Contains(col *Column) bool

Contains checks if the schema contains the column.

func (*Schema) ExtractColGroups

func (s *Schema) ExtractColGroups(colGroups [][]*Column) ([][]int, []int)

ExtractColGroups checks if column groups are from current schema, and returns offsets of those satisfied column groups.

func (*Schema) IsUnique

func (s *Schema) IsUnique(col *Column) bool

IsUnique checks if this column is a unique key which may contain duplicate nulls .

func (*Schema) IsUniqueKey

func (s *Schema) IsUniqueKey(col *Column) bool

IsUniqueKey checks if this column is a unique key.

func (*Schema) Len

func (s *Schema) Len() int

Len returns the number of columns in schema.

func (*Schema) MemoryUsage

func (s *Schema) MemoryUsage() (sum int64)

MemoryUsage return the memory usage of Schema

func (*Schema) RetrieveColumn

func (s *Schema) RetrieveColumn(col *Column) *Column

RetrieveColumn retrieves column in expression from the columns in schema.

func (*Schema) SetUniqueKeys

func (s *Schema) SetUniqueKeys(keys []KeyInfo)

SetUniqueKeys will set the value of Schema.Keys.

func (*Schema) String

func (s *Schema) String() string

String implements fmt.Stringer interface.

type TiDBDecodeKeyFunctionKeyType

type TiDBDecodeKeyFunctionKeyType int

TiDBDecodeKeyFunctionKeyType is used to identify the decoder function in context.

const TiDBDecodeKeyFunctionKey TiDBDecodeKeyFunctionKeyType = 0

TiDBDecodeKeyFunctionKey is used to identify the decoder function in context.

func (TiDBDecodeKeyFunctionKeyType) String

String() implements Stringer.

type VarAssignment

type VarAssignment struct {
	Name        string
	Expr        Expression
	IsDefault   bool
	IsGlobal    bool
	IsSystem    bool
	ExtendValue *Constant
}

VarAssignment represents a variable assignment in Set, such as set global a = 1.

type VecExpr

type VecExpr interface {
	// Vectorized returns if this expression supports vectorized evaluation.
	Vectorized() bool

	// VecEvalInt evaluates this expression in a vectorized manner.
	VecEvalInt(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

	// VecEvalReal evaluates this expression in a vectorized manner.
	VecEvalReal(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

	// VecEvalString evaluates this expression in a vectorized manner.
	VecEvalString(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

	// VecEvalDecimal evaluates this expression in a vectorized manner.
	VecEvalDecimal(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

	// VecEvalTime evaluates this expression in a vectorized manner.
	VecEvalTime(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

	// VecEvalDuration evaluates this expression in a vectorized manner.
	VecEvalDuration(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error

	// VecEvalJSON evaluates this expression in a vectorized manner.
	VecEvalJSON(ctx sessionctx.Context, input *chunk.Chunk, result *chunk.Column) error
}

VecExpr contains all vectorized evaluation methods.

Directories

Path Synopsis
generator

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL