You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
860 lines
25 KiB
860 lines
25 KiB
// Copyright 2015 PingCAP, Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package expression
|
|
|
|
import (
|
|
"github.com/cznic/mathutil"
|
|
"github.com/pingcap/parser/charset"
|
|
"github.com/pingcap/parser/mysql"
|
|
"github.com/pingcap/tidb/sessionctx"
|
|
"github.com/pingcap/tidb/types"
|
|
"github.com/pingcap/tidb/types/json"
|
|
"github.com/pingcap/tidb/util/chunk"
|
|
"github.com/pingcap/tipb/go-tipb"
|
|
)
|
|
|
|
var (
|
|
_ functionClass = &caseWhenFunctionClass{}
|
|
_ functionClass = &ifFunctionClass{}
|
|
_ functionClass = &ifNullFunctionClass{}
|
|
)
|
|
|
|
var (
|
|
_ builtinFunc = &builtinCaseWhenIntSig{}
|
|
_ builtinFunc = &builtinCaseWhenRealSig{}
|
|
_ builtinFunc = &builtinCaseWhenDecimalSig{}
|
|
_ builtinFunc = &builtinCaseWhenStringSig{}
|
|
_ builtinFunc = &builtinCaseWhenTimeSig{}
|
|
_ builtinFunc = &builtinCaseWhenDurationSig{}
|
|
_ builtinFunc = &builtinCaseWhenJSONSig{}
|
|
_ builtinFunc = &builtinIfNullIntSig{}
|
|
_ builtinFunc = &builtinIfNullRealSig{}
|
|
_ builtinFunc = &builtinIfNullDecimalSig{}
|
|
_ builtinFunc = &builtinIfNullStringSig{}
|
|
_ builtinFunc = &builtinIfNullTimeSig{}
|
|
_ builtinFunc = &builtinIfNullDurationSig{}
|
|
_ builtinFunc = &builtinIfNullJSONSig{}
|
|
_ builtinFunc = &builtinIfIntSig{}
|
|
_ builtinFunc = &builtinIfRealSig{}
|
|
_ builtinFunc = &builtinIfDecimalSig{}
|
|
_ builtinFunc = &builtinIfStringSig{}
|
|
_ builtinFunc = &builtinIfTimeSig{}
|
|
_ builtinFunc = &builtinIfDurationSig{}
|
|
_ builtinFunc = &builtinIfJSONSig{}
|
|
)
|
|
|
|
func maxlen(lhsFlen, rhsFlen int) int {
|
|
// -1 indicates that the length is unknown, such as the case for expressions.
|
|
if lhsFlen < 0 || rhsFlen < 0 {
|
|
return mysql.MaxRealWidth
|
|
}
|
|
return mathutil.Max(lhsFlen, rhsFlen)
|
|
}
|
|
|
|
// InferType4ControlFuncs infer result type for builtin IF, IFNULL, NULLIF, LEAD and LAG.
|
|
func InferType4ControlFuncs(lhs, rhs *types.FieldType) *types.FieldType {
|
|
resultFieldType := &types.FieldType{}
|
|
if lhs.Tp == mysql.TypeNull {
|
|
*resultFieldType = *rhs
|
|
// If both arguments are NULL, make resulting type BINARY(0).
|
|
if rhs.Tp == mysql.TypeNull {
|
|
resultFieldType.Tp = mysql.TypeString
|
|
resultFieldType.Flen, resultFieldType.Decimal = 0, 0
|
|
types.SetBinChsClnFlag(resultFieldType)
|
|
}
|
|
} else if rhs.Tp == mysql.TypeNull {
|
|
*resultFieldType = *lhs
|
|
} else {
|
|
resultFieldType = types.AggFieldType([]*types.FieldType{lhs, rhs})
|
|
evalType := types.AggregateEvalType([]*types.FieldType{lhs, rhs}, &resultFieldType.Flag)
|
|
if evalType == types.ETInt {
|
|
resultFieldType.Decimal = 0
|
|
} else {
|
|
if lhs.Decimal == types.UnspecifiedLength || rhs.Decimal == types.UnspecifiedLength {
|
|
resultFieldType.Decimal = types.UnspecifiedLength
|
|
} else {
|
|
resultFieldType.Decimal = mathutil.Max(lhs.Decimal, rhs.Decimal)
|
|
}
|
|
}
|
|
if types.IsNonBinaryStr(lhs) && !types.IsBinaryStr(rhs) {
|
|
resultFieldType.Charset, resultFieldType.Collate, resultFieldType.Flag = charset.CharsetUTF8MB4, charset.CollationUTF8MB4, 0
|
|
if mysql.HasBinaryFlag(lhs.Flag) || !types.IsNonBinaryStr(rhs) {
|
|
resultFieldType.Flag |= mysql.BinaryFlag
|
|
}
|
|
} else if types.IsNonBinaryStr(rhs) && !types.IsBinaryStr(lhs) {
|
|
resultFieldType.Charset, resultFieldType.Collate, resultFieldType.Flag = charset.CharsetUTF8MB4, charset.CollationUTF8MB4, 0
|
|
if mysql.HasBinaryFlag(rhs.Flag) || !types.IsNonBinaryStr(lhs) {
|
|
resultFieldType.Flag |= mysql.BinaryFlag
|
|
}
|
|
} else if types.IsBinaryStr(lhs) || types.IsBinaryStr(rhs) || !evalType.IsStringKind() {
|
|
types.SetBinChsClnFlag(resultFieldType)
|
|
} else {
|
|
resultFieldType.Charset, resultFieldType.Collate, resultFieldType.Flag = mysql.DefaultCharset, mysql.DefaultCollationName, 0
|
|
}
|
|
if evalType == types.ETDecimal || evalType == types.ETInt {
|
|
lhsUnsignedFlag, rhsUnsignedFlag := mysql.HasUnsignedFlag(lhs.Flag), mysql.HasUnsignedFlag(rhs.Flag)
|
|
lhsFlagLen, rhsFlagLen := 0, 0
|
|
if !lhsUnsignedFlag {
|
|
lhsFlagLen = 1
|
|
}
|
|
if !rhsUnsignedFlag {
|
|
rhsFlagLen = 1
|
|
}
|
|
lhsFlen := lhs.Flen - lhsFlagLen
|
|
rhsFlen := rhs.Flen - rhsFlagLen
|
|
if lhs.Decimal != types.UnspecifiedLength {
|
|
lhsFlen -= lhs.Decimal
|
|
}
|
|
if lhs.Decimal != types.UnspecifiedLength {
|
|
rhsFlen -= rhs.Decimal
|
|
}
|
|
flen := maxlen(lhsFlen, rhsFlen) + resultFieldType.Decimal + 1 // account for -1 len fields
|
|
resultFieldType.Flen = mathutil.Min(flen, mysql.MaxDecimalWidth) // make sure it doesn't overflow
|
|
} else {
|
|
resultFieldType.Flen = maxlen(lhs.Flen, rhs.Flen)
|
|
}
|
|
}
|
|
// Fix decimal for int and string.
|
|
resultEvalType := resultFieldType.EvalType()
|
|
if resultEvalType == types.ETInt {
|
|
resultFieldType.Decimal = 0
|
|
} else if resultEvalType == types.ETString {
|
|
if lhs.Tp != mysql.TypeNull || rhs.Tp != mysql.TypeNull {
|
|
resultFieldType.Decimal = types.UnspecifiedLength
|
|
}
|
|
}
|
|
return resultFieldType
|
|
}
|
|
|
|
type caseWhenFunctionClass struct {
|
|
baseFunctionClass
|
|
}
|
|
|
|
func (c *caseWhenFunctionClass) getFunction(ctx sessionctx.Context, args []Expression) (sig builtinFunc, err error) {
|
|
if err = c.verifyArgs(args); err != nil {
|
|
return nil, err
|
|
}
|
|
l := len(args)
|
|
// Fill in each 'THEN' clause parameter type.
|
|
fieldTps := make([]*types.FieldType, 0, (l+1)/2)
|
|
decimal, flen, isBinaryStr, isBinaryFlag := args[1].GetType().Decimal, 0, false, false
|
|
for i := 1; i < l; i += 2 {
|
|
fieldTps = append(fieldTps, args[i].GetType())
|
|
decimal = mathutil.Max(decimal, args[i].GetType().Decimal)
|
|
if args[i].GetType().Flen == -1 {
|
|
flen = -1
|
|
} else if flen != -1 {
|
|
flen = mathutil.Max(flen, args[i].GetType().Flen)
|
|
}
|
|
isBinaryStr = isBinaryStr || types.IsBinaryStr(args[i].GetType())
|
|
isBinaryFlag = isBinaryFlag || !types.IsNonBinaryStr(args[i].GetType())
|
|
}
|
|
if l%2 == 1 {
|
|
fieldTps = append(fieldTps, args[l-1].GetType())
|
|
decimal = mathutil.Max(decimal, args[l-1].GetType().Decimal)
|
|
if args[l-1].GetType().Flen == -1 {
|
|
flen = -1
|
|
} else if flen != -1 {
|
|
flen = mathutil.Max(flen, args[l-1].GetType().Flen)
|
|
}
|
|
isBinaryStr = isBinaryStr || types.IsBinaryStr(args[l-1].GetType())
|
|
isBinaryFlag = isBinaryFlag || !types.IsNonBinaryStr(args[l-1].GetType())
|
|
}
|
|
|
|
fieldTp := types.AggFieldType(fieldTps)
|
|
tp := fieldTp.EvalType()
|
|
|
|
if tp == types.ETInt {
|
|
decimal = 0
|
|
}
|
|
fieldTp.Decimal, fieldTp.Flen = decimal, flen
|
|
if fieldTp.EvalType().IsStringKind() && !isBinaryStr {
|
|
fieldTp.Charset, fieldTp.Collate = charset.CharsetUTF8MB4, charset.CollationUTF8MB4
|
|
}
|
|
if isBinaryFlag {
|
|
fieldTp.Flag |= mysql.BinaryFlag
|
|
}
|
|
// Set retType to BINARY(0) if all arguments are of type NULL.
|
|
if fieldTp.Tp == mysql.TypeNull {
|
|
fieldTp.Flen, fieldTp.Decimal = 0, types.UnspecifiedLength
|
|
types.SetBinChsClnFlag(fieldTp)
|
|
}
|
|
argTps := make([]types.EvalType, 0, l)
|
|
for i := 0; i < l-1; i += 2 {
|
|
if args[i], err = wrapWithIsTrue(ctx, true, args[i], false); err != nil {
|
|
return nil, err
|
|
}
|
|
argTps = append(argTps, types.ETInt, tp)
|
|
}
|
|
if l%2 == 1 {
|
|
argTps = append(argTps, tp)
|
|
}
|
|
bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, tp, argTps...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
bf.tp = fieldTp
|
|
|
|
switch tp {
|
|
case types.ETInt:
|
|
bf.tp.Decimal = 0
|
|
sig = &builtinCaseWhenIntSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_CaseWhenInt)
|
|
case types.ETReal:
|
|
sig = &builtinCaseWhenRealSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_CaseWhenReal)
|
|
case types.ETDecimal:
|
|
sig = &builtinCaseWhenDecimalSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_CaseWhenDecimal)
|
|
case types.ETString:
|
|
bf.tp.Decimal = types.UnspecifiedLength
|
|
sig = &builtinCaseWhenStringSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_CaseWhenString)
|
|
case types.ETDatetime, types.ETTimestamp:
|
|
sig = &builtinCaseWhenTimeSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_CaseWhenTime)
|
|
case types.ETDuration:
|
|
sig = &builtinCaseWhenDurationSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_CaseWhenDuration)
|
|
case types.ETJson:
|
|
sig = &builtinCaseWhenJSONSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_CaseWhenJson)
|
|
}
|
|
return sig, nil
|
|
}
|
|
|
|
type builtinCaseWhenIntSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinCaseWhenIntSig) Clone() builtinFunc {
|
|
newSig := &builtinCaseWhenIntSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
// evalInt evals a builtinCaseWhenIntSig.
|
|
// See https://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html#operator_case
|
|
func (b *builtinCaseWhenIntSig) evalInt(row chunk.Row) (ret int64, isNull bool, err error) {
|
|
var condition int64
|
|
args, l := b.getArgs(), len(b.getArgs())
|
|
for i := 0; i < l-1; i += 2 {
|
|
condition, isNull, err = args[i].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return 0, isNull, err
|
|
}
|
|
if isNull || condition == 0 {
|
|
continue
|
|
}
|
|
ret, isNull, err = args[i+1].EvalInt(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
// when clause(condition, result) -> args[i], args[i+1]; (i >= 0 && i+1 < l-1)
|
|
// else clause -> args[l-1]
|
|
// If case clause has else clause, l%2 == 1.
|
|
if l%2 == 1 {
|
|
ret, isNull, err = args[l-1].EvalInt(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
return ret, true, nil
|
|
}
|
|
|
|
type builtinCaseWhenRealSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinCaseWhenRealSig) Clone() builtinFunc {
|
|
newSig := &builtinCaseWhenRealSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
// evalReal evals a builtinCaseWhenRealSig.
|
|
// See https://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html#operator_case
|
|
func (b *builtinCaseWhenRealSig) evalReal(row chunk.Row) (ret float64, isNull bool, err error) {
|
|
var condition int64
|
|
args, l := b.getArgs(), len(b.getArgs())
|
|
for i := 0; i < l-1; i += 2 {
|
|
condition, isNull, err = args[i].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return 0, isNull, err
|
|
}
|
|
if isNull || condition == 0 {
|
|
continue
|
|
}
|
|
ret, isNull, err = args[i+1].EvalReal(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
// when clause(condition, result) -> args[i], args[i+1]; (i >= 0 && i+1 < l-1)
|
|
// else clause -> args[l-1]
|
|
// If case clause has else clause, l%2 == 1.
|
|
if l%2 == 1 {
|
|
ret, isNull, err = args[l-1].EvalReal(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
return ret, true, nil
|
|
}
|
|
|
|
type builtinCaseWhenDecimalSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinCaseWhenDecimalSig) Clone() builtinFunc {
|
|
newSig := &builtinCaseWhenDecimalSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
// evalDecimal evals a builtinCaseWhenDecimalSig.
|
|
// See https://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html#operator_case
|
|
func (b *builtinCaseWhenDecimalSig) evalDecimal(row chunk.Row) (ret *types.MyDecimal, isNull bool, err error) {
|
|
var condition int64
|
|
args, l := b.getArgs(), len(b.getArgs())
|
|
for i := 0; i < l-1; i += 2 {
|
|
condition, isNull, err = args[i].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return nil, isNull, err
|
|
}
|
|
if isNull || condition == 0 {
|
|
continue
|
|
}
|
|
ret, isNull, err = args[i+1].EvalDecimal(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
// when clause(condition, result) -> args[i], args[i+1]; (i >= 0 && i+1 < l-1)
|
|
// else clause -> args[l-1]
|
|
// If case clause has else clause, l%2 == 1.
|
|
if l%2 == 1 {
|
|
ret, isNull, err = args[l-1].EvalDecimal(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
return ret, true, nil
|
|
}
|
|
|
|
type builtinCaseWhenStringSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinCaseWhenStringSig) Clone() builtinFunc {
|
|
newSig := &builtinCaseWhenStringSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
// evalString evals a builtinCaseWhenStringSig.
|
|
// See https://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html#operator_case
|
|
func (b *builtinCaseWhenStringSig) evalString(row chunk.Row) (ret string, isNull bool, err error) {
|
|
var condition int64
|
|
args, l := b.getArgs(), len(b.getArgs())
|
|
for i := 0; i < l-1; i += 2 {
|
|
condition, isNull, err = args[i].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return "", isNull, err
|
|
}
|
|
if isNull || condition == 0 {
|
|
continue
|
|
}
|
|
ret, isNull, err = args[i+1].EvalString(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
// when clause(condition, result) -> args[i], args[i+1]; (i >= 0 && i+1 < l-1)
|
|
// else clause -> args[l-1]
|
|
// If case clause has else clause, l%2 == 1.
|
|
if l%2 == 1 {
|
|
ret, isNull, err = args[l-1].EvalString(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
return ret, true, nil
|
|
}
|
|
|
|
type builtinCaseWhenTimeSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinCaseWhenTimeSig) Clone() builtinFunc {
|
|
newSig := &builtinCaseWhenTimeSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
// evalTime evals a builtinCaseWhenTimeSig.
|
|
// See https://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html#operator_case
|
|
func (b *builtinCaseWhenTimeSig) evalTime(row chunk.Row) (ret types.Time, isNull bool, err error) {
|
|
var condition int64
|
|
args, l := b.getArgs(), len(b.getArgs())
|
|
for i := 0; i < l-1; i += 2 {
|
|
condition, isNull, err = args[i].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return ret, isNull, err
|
|
}
|
|
if isNull || condition == 0 {
|
|
continue
|
|
}
|
|
ret, isNull, err = args[i+1].EvalTime(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
// when clause(condition, result) -> args[i], args[i+1]; (i >= 0 && i+1 < l-1)
|
|
// else clause -> args[l-1]
|
|
// If case clause has else clause, l%2 == 1.
|
|
if l%2 == 1 {
|
|
ret, isNull, err = args[l-1].EvalTime(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
return ret, true, nil
|
|
}
|
|
|
|
type builtinCaseWhenDurationSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinCaseWhenDurationSig) Clone() builtinFunc {
|
|
newSig := &builtinCaseWhenDurationSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
// evalDuration evals a builtinCaseWhenDurationSig.
|
|
// See https://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html#operator_case
|
|
func (b *builtinCaseWhenDurationSig) evalDuration(row chunk.Row) (ret types.Duration, isNull bool, err error) {
|
|
var condition int64
|
|
args, l := b.getArgs(), len(b.getArgs())
|
|
for i := 0; i < l-1; i += 2 {
|
|
condition, isNull, err = args[i].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return ret, true, err
|
|
}
|
|
if isNull || condition == 0 {
|
|
continue
|
|
}
|
|
ret, isNull, err = args[i+1].EvalDuration(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
// when clause(condition, result) -> args[i], args[i+1]; (i >= 0 && i+1 < l-1)
|
|
// else clause -> args[l-1]
|
|
// If case clause has else clause, l%2 == 1.
|
|
if l%2 == 1 {
|
|
ret, isNull, err = args[l-1].EvalDuration(b.ctx, row)
|
|
return ret, isNull, err
|
|
}
|
|
return ret, true, nil
|
|
}
|
|
|
|
type builtinCaseWhenJSONSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinCaseWhenJSONSig) Clone() builtinFunc {
|
|
newSig := &builtinCaseWhenJSONSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
// evalJSON evals a builtinCaseWhenJSONSig.
|
|
// See https://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html#operator_case
|
|
func (b *builtinCaseWhenJSONSig) evalJSON(row chunk.Row) (ret json.BinaryJSON, isNull bool, err error) {
|
|
var condition int64
|
|
args, l := b.getArgs(), len(b.getArgs())
|
|
for i := 0; i < l-1; i += 2 {
|
|
condition, isNull, err = args[i].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if isNull || condition == 0 {
|
|
continue
|
|
}
|
|
return args[i+1].EvalJSON(b.ctx, row)
|
|
}
|
|
// when clause(condition, result) -> args[i], args[i+1]; (i >= 0 && i+1 < l-1)
|
|
// else clause -> args[l-1]
|
|
// If case clause has else clause, l%2 == 1.
|
|
if l%2 == 1 {
|
|
return args[l-1].EvalJSON(b.ctx, row)
|
|
}
|
|
return ret, true, nil
|
|
}
|
|
|
|
type ifFunctionClass struct {
|
|
baseFunctionClass
|
|
}
|
|
|
|
// getFunction see https://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html#function_if
|
|
func (c *ifFunctionClass) getFunction(ctx sessionctx.Context, args []Expression) (sig builtinFunc, err error) {
|
|
if err = c.verifyArgs(args); err != nil {
|
|
return nil, err
|
|
}
|
|
retTp := InferType4ControlFuncs(args[1].GetType(), args[2].GetType())
|
|
evalTps := retTp.EvalType()
|
|
args[0], err = wrapWithIsTrue(ctx, true, args[0], false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, evalTps, types.ETInt, evalTps, evalTps)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
retTp.Flag |= bf.tp.Flag
|
|
bf.tp = retTp
|
|
switch evalTps {
|
|
case types.ETInt:
|
|
sig = &builtinIfIntSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfInt)
|
|
case types.ETReal:
|
|
sig = &builtinIfRealSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfReal)
|
|
case types.ETDecimal:
|
|
sig = &builtinIfDecimalSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfDecimal)
|
|
case types.ETString:
|
|
sig = &builtinIfStringSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfString)
|
|
case types.ETDatetime, types.ETTimestamp:
|
|
sig = &builtinIfTimeSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfTime)
|
|
case types.ETDuration:
|
|
sig = &builtinIfDurationSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfDuration)
|
|
case types.ETJson:
|
|
sig = &builtinIfJSONSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfJson)
|
|
}
|
|
return sig, nil
|
|
}
|
|
|
|
type builtinIfIntSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfIntSig) Clone() builtinFunc {
|
|
newSig := &builtinIfIntSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfIntSig) evalInt(row chunk.Row) (ret int64, isNull bool, err error) {
|
|
arg0, isNull0, err := b.args[0].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return 0, true, err
|
|
}
|
|
if !isNull0 && arg0 != 0 {
|
|
return b.args[1].EvalInt(b.ctx, row)
|
|
}
|
|
return b.args[2].EvalInt(b.ctx, row)
|
|
}
|
|
|
|
type builtinIfRealSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfRealSig) Clone() builtinFunc {
|
|
newSig := &builtinIfRealSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfRealSig) evalReal(row chunk.Row) (ret float64, isNull bool, err error) {
|
|
arg0, isNull0, err := b.args[0].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return 0, true, err
|
|
}
|
|
if !isNull0 && arg0 != 0 {
|
|
return b.args[1].EvalReal(b.ctx, row)
|
|
}
|
|
return b.args[2].EvalReal(b.ctx, row)
|
|
}
|
|
|
|
type builtinIfDecimalSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfDecimalSig) Clone() builtinFunc {
|
|
newSig := &builtinIfDecimalSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfDecimalSig) evalDecimal(row chunk.Row) (ret *types.MyDecimal, isNull bool, err error) {
|
|
arg0, isNull0, err := b.args[0].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return nil, true, err
|
|
}
|
|
if !isNull0 && arg0 != 0 {
|
|
return b.args[1].EvalDecimal(b.ctx, row)
|
|
}
|
|
return b.args[2].EvalDecimal(b.ctx, row)
|
|
}
|
|
|
|
type builtinIfStringSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfStringSig) Clone() builtinFunc {
|
|
newSig := &builtinIfStringSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfStringSig) evalString(row chunk.Row) (ret string, isNull bool, err error) {
|
|
arg0, isNull0, err := b.args[0].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return "", true, err
|
|
}
|
|
if !isNull0 && arg0 != 0 {
|
|
return b.args[1].EvalString(b.ctx, row)
|
|
}
|
|
return b.args[2].EvalString(b.ctx, row)
|
|
}
|
|
|
|
type builtinIfTimeSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfTimeSig) Clone() builtinFunc {
|
|
newSig := &builtinIfTimeSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfTimeSig) evalTime(row chunk.Row) (ret types.Time, isNull bool, err error) {
|
|
arg0, isNull0, err := b.args[0].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return ret, true, err
|
|
}
|
|
if !isNull0 && arg0 != 0 {
|
|
return b.args[1].EvalTime(b.ctx, row)
|
|
}
|
|
return b.args[2].EvalTime(b.ctx, row)
|
|
}
|
|
|
|
type builtinIfDurationSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfDurationSig) Clone() builtinFunc {
|
|
newSig := &builtinIfDurationSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfDurationSig) evalDuration(row chunk.Row) (ret types.Duration, isNull bool, err error) {
|
|
arg0, isNull0, err := b.args[0].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return ret, true, err
|
|
}
|
|
if !isNull0 && arg0 != 0 {
|
|
return b.args[1].EvalDuration(b.ctx, row)
|
|
}
|
|
return b.args[2].EvalDuration(b.ctx, row)
|
|
}
|
|
|
|
type builtinIfJSONSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfJSONSig) Clone() builtinFunc {
|
|
newSig := &builtinIfJSONSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfJSONSig) evalJSON(row chunk.Row) (ret json.BinaryJSON, isNull bool, err error) {
|
|
arg0, isNull0, err := b.args[0].EvalInt(b.ctx, row)
|
|
if err != nil {
|
|
return ret, true, err
|
|
}
|
|
if !isNull0 && arg0 != 0 {
|
|
return b.args[1].EvalJSON(b.ctx, row)
|
|
}
|
|
return b.args[2].EvalJSON(b.ctx, row)
|
|
}
|
|
|
|
type ifNullFunctionClass struct {
|
|
baseFunctionClass
|
|
}
|
|
|
|
func (c *ifNullFunctionClass) getFunction(ctx sessionctx.Context, args []Expression) (sig builtinFunc, err error) {
|
|
if err = c.verifyArgs(args); err != nil {
|
|
return nil, err
|
|
}
|
|
lhs, rhs := args[0].GetType(), args[1].GetType()
|
|
retTp := InferType4ControlFuncs(lhs, rhs)
|
|
retTp.Flag |= (lhs.Flag & mysql.NotNullFlag) | (rhs.Flag & mysql.NotNullFlag)
|
|
if lhs.Tp == mysql.TypeNull && rhs.Tp == mysql.TypeNull {
|
|
retTp.Tp = mysql.TypeNull
|
|
retTp.Flen, retTp.Decimal = 0, -1
|
|
types.SetBinChsClnFlag(retTp)
|
|
}
|
|
evalTps := retTp.EvalType()
|
|
bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, evalTps, evalTps, evalTps)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
bf.tp = retTp
|
|
switch evalTps {
|
|
case types.ETInt:
|
|
sig = &builtinIfNullIntSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfNullInt)
|
|
case types.ETReal:
|
|
sig = &builtinIfNullRealSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfNullReal)
|
|
case types.ETDecimal:
|
|
sig = &builtinIfNullDecimalSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfNullDecimal)
|
|
case types.ETString:
|
|
sig = &builtinIfNullStringSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfNullString)
|
|
case types.ETDatetime, types.ETTimestamp:
|
|
sig = &builtinIfNullTimeSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfNullTime)
|
|
case types.ETDuration:
|
|
sig = &builtinIfNullDurationSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfNullDuration)
|
|
case types.ETJson:
|
|
sig = &builtinIfNullJSONSig{bf}
|
|
sig.setPbCode(tipb.ScalarFuncSig_IfNullJson)
|
|
}
|
|
return sig, nil
|
|
}
|
|
|
|
type builtinIfNullIntSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfNullIntSig) Clone() builtinFunc {
|
|
newSig := &builtinIfNullIntSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfNullIntSig) evalInt(row chunk.Row) (int64, bool, error) {
|
|
arg0, isNull, err := b.args[0].EvalInt(b.ctx, row)
|
|
if !isNull || err != nil {
|
|
return arg0, err != nil, err
|
|
}
|
|
arg1, isNull, err := b.args[1].EvalInt(b.ctx, row)
|
|
return arg1, isNull || err != nil, err
|
|
}
|
|
|
|
type builtinIfNullRealSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfNullRealSig) Clone() builtinFunc {
|
|
newSig := &builtinIfNullRealSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfNullRealSig) evalReal(row chunk.Row) (float64, bool, error) {
|
|
arg0, isNull, err := b.args[0].EvalReal(b.ctx, row)
|
|
if !isNull || err != nil {
|
|
return arg0, err != nil, err
|
|
}
|
|
arg1, isNull, err := b.args[1].EvalReal(b.ctx, row)
|
|
return arg1, isNull || err != nil, err
|
|
}
|
|
|
|
type builtinIfNullDecimalSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfNullDecimalSig) Clone() builtinFunc {
|
|
newSig := &builtinIfNullDecimalSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfNullDecimalSig) evalDecimal(row chunk.Row) (*types.MyDecimal, bool, error) {
|
|
arg0, isNull, err := b.args[0].EvalDecimal(b.ctx, row)
|
|
if !isNull || err != nil {
|
|
return arg0, err != nil, err
|
|
}
|
|
arg1, isNull, err := b.args[1].EvalDecimal(b.ctx, row)
|
|
return arg1, isNull || err != nil, err
|
|
}
|
|
|
|
type builtinIfNullStringSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfNullStringSig) Clone() builtinFunc {
|
|
newSig := &builtinIfNullStringSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfNullStringSig) evalString(row chunk.Row) (string, bool, error) {
|
|
arg0, isNull, err := b.args[0].EvalString(b.ctx, row)
|
|
if !isNull || err != nil {
|
|
return arg0, err != nil, err
|
|
}
|
|
arg1, isNull, err := b.args[1].EvalString(b.ctx, row)
|
|
return arg1, isNull || err != nil, err
|
|
}
|
|
|
|
type builtinIfNullTimeSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfNullTimeSig) Clone() builtinFunc {
|
|
newSig := &builtinIfNullTimeSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfNullTimeSig) evalTime(row chunk.Row) (types.Time, bool, error) {
|
|
arg0, isNull, err := b.args[0].EvalTime(b.ctx, row)
|
|
if !isNull || err != nil {
|
|
return arg0, err != nil, err
|
|
}
|
|
arg1, isNull, err := b.args[1].EvalTime(b.ctx, row)
|
|
return arg1, isNull || err != nil, err
|
|
}
|
|
|
|
type builtinIfNullDurationSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfNullDurationSig) Clone() builtinFunc {
|
|
newSig := &builtinIfNullDurationSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfNullDurationSig) evalDuration(row chunk.Row) (types.Duration, bool, error) {
|
|
arg0, isNull, err := b.args[0].EvalDuration(b.ctx, row)
|
|
if !isNull || err != nil {
|
|
return arg0, err != nil, err
|
|
}
|
|
arg1, isNull, err := b.args[1].EvalDuration(b.ctx, row)
|
|
return arg1, isNull || err != nil, err
|
|
}
|
|
|
|
type builtinIfNullJSONSig struct {
|
|
baseBuiltinFunc
|
|
}
|
|
|
|
func (b *builtinIfNullJSONSig) Clone() builtinFunc {
|
|
newSig := &builtinIfNullJSONSig{}
|
|
newSig.cloneFrom(&b.baseBuiltinFunc)
|
|
return newSig
|
|
}
|
|
|
|
func (b *builtinIfNullJSONSig) evalJSON(row chunk.Row) (json.BinaryJSON, bool, error) {
|
|
arg0, isNull, err := b.args[0].EvalJSON(b.ctx, row)
|
|
if !isNull {
|
|
return arg0, err != nil, err
|
|
}
|
|
arg1, isNull, err := b.args[1].EvalJSON(b.ctx, row)
|
|
return arg1, isNull || err != nil, err
|
|
}
|
|
|