From 03c1714e83732d2c66c80e01766af55605247085 Mon Sep 17 00:00:00 2001 From: Jian Zhang Date: Tue, 8 Aug 2017 17:04:12 +0800 Subject: [PATCH 1/4] expression, plan: rewrite builtin function: IS TRUE && IS FALSE --- expression/builtin.go | 4 +- expression/builtin_op.go | 60 ++++++++++++++++----------- expression/builtin_op_test.go | 75 ++++++++++++++++++++++++++++++++++ expression/integration_test.go | 7 +++- plan/typeinfer_test.go | 22 ++++++++++ 5 files changed, 141 insertions(+), 27 deletions(-) diff --git a/expression/builtin.go b/expression/builtin.go index 3864d20a70617..02dc878cf5232 100644 --- a/expression/builtin.go +++ b/expression/builtin.go @@ -787,8 +787,8 @@ var funcs = map[string]functionClass{ ast.UnaryPlus: &unaryOpFunctionClass{baseFunctionClass{ast.UnaryPlus, 1, 1}, opcode.Plus}, ast.UnaryMinus: &unaryMinusFunctionClass{baseFunctionClass{ast.UnaryMinus, 1, 1}}, ast.In: &inFunctionClass{baseFunctionClass{ast.In, 1, -1}}, - ast.IsTruth: &isTrueOpFunctionClass{baseFunctionClass{ast.IsTruth, 1, 1}, opcode.IsTruth}, - ast.IsFalsity: &isTrueOpFunctionClass{baseFunctionClass{ast.IsFalsity, 1, 1}, opcode.IsFalsity}, + ast.IsTruth: &isTrueOrFalseFunctionClass{baseFunctionClass{ast.IsTruth, 1, 1}, opcode.IsTruth}, + ast.IsFalsity: &isTrueOrFalseFunctionClass{baseFunctionClass{ast.IsFalsity, 1, 1}, opcode.IsFalsity}, ast.Like: &likeFunctionClass{baseFunctionClass{ast.Like, 2, 3}}, ast.Regexp: ®expFunctionClass{baseFunctionClass{ast.Regexp, 2, 2}}, ast.Case: &caseWhenFunctionClass{baseFunctionClass{ast.Case, 1, -1}}, diff --git a/expression/builtin_op.go b/expression/builtin_op.go index cc9927482a47a..223b5641bbb35 100644 --- a/expression/builtin_op.go +++ b/expression/builtin_op.go @@ -28,7 +28,7 @@ var ( _ functionClass = &logicAndFunctionClass{} _ functionClass = &logicOrFunctionClass{} _ functionClass = &logicXorFunctionClass{} - _ functionClass = &isTrueOpFunctionClass{} + _ functionClass = &isTrueOrFalseFunctionClass{} _ functionClass = &unaryOpFunctionClass{} _ functionClass = &unaryMinusFunctionClass{} _ functionClass = &isNullFunctionClass{} @@ -39,7 +39,8 @@ var ( _ builtinFunc = &builtinLogicAndSig{} _ builtinFunc = &builtinLogicOrSig{} _ builtinFunc = &builtinLogicXorSig{} - _ builtinFunc = &builtinIsTrueOpSig{} + _ builtinFunc = &builtinIsTrueSig{} + _ builtinFunc = &builtinIsFalseSig{} _ builtinFunc = &builtinUnaryOpSig{} _ builtinFunc = &builtinUnaryMinusIntSig{} _ builtinFunc = &builtinIsNullSig{} @@ -341,40 +342,51 @@ func (b *builtinRightShiftSig) evalInt(row []types.Datum) (int64, bool, error) { return int64(uint64(arg0) >> uint64(arg1)), false, nil } -type isTrueOpFunctionClass struct { +type isTrueOrFalseFunctionClass struct { baseFunctionClass - op opcode.Op } -func (c *isTrueOpFunctionClass) getFunction(args []Expression, ctx context.Context) (builtinFunc, error) { - sig := &builtinIsTrueOpSig{newBaseBuiltinFunc(args, ctx), c.op} - return sig.setSelf(sig), errors.Trace(c.verifyArgs(args)) +func (c *isTrueOrFalseFunctionClass) getFunction(args []Expression, ctx context.Context) (builtinFunc, error) { + if err := c.verifyArgs(args); err != nil { + return nil, errors.Trace(err) + } + bf, err := newBaseBuiltinFuncWithTp(args, ctx, tpInt, tpInt) + if err != nil { + return nil, errors.Trace(err) + } + bf.tp.Flen = 1 + if c.op == opcode.IsTruth { + sig := &builtinIsTrueSig{baseIntBuiltinFunc{bf}} + return sig.setSelf(sig), nil + } + sig := &builtinIsFalseSig{baseIntBuiltinFunc{bf}} + return sig.setSelf(sig), nil } -type builtinIsTrueOpSig struct { - baseBuiltinFunc +type builtinIsTrueSig struct{ baseIntBuiltinFunc } +type builtinIsFalseSig struct{ baseIntBuiltinFunc } - op opcode.Op +func (b *builtinIsTrueSig) evalInt(row []types.Datum) (int64, bool, error) { + boolResult, isNull, err := b.args[0].EvalInt(row, b.ctx.GetSessionVars().StmtCtx) + if err != nil { + return 0, true, errors.Trace(err) + } + if isNull || boolResult == 0 { + return 0, false, nil + } + return 1, false, nil } -func (b *builtinIsTrueOpSig) eval(row []types.Datum) (d types.Datum, err error) { - args, err := b.evalArgs(row) +func (b *builtinIsFalseSig) evalInt(row []types.Datum) (int64, bool, error) { + boolResult, isNull, err := b.args[0].EvalInt(row, b.ctx.GetSessionVars().StmtCtx) if err != nil { - return types.Datum{}, errors.Trace(err) + return 0, true, errors.Trace(err) } - var boolVal bool - if !args[0].IsNull() { - iVal, err := args[0].ToBool(b.ctx.GetSessionVars().StmtCtx) - if err != nil { - return d, errors.Trace(err) - } - if (b.op == opcode.IsTruth && iVal == 1) || (b.op == opcode.IsFalsity && iVal == 0) { - boolVal = true - } + if isNull || boolResult != 0 { + return 0, false, nil } - d.SetInt64(boolToInt64(boolVal)) - return + return 1, false, nil } type bitNegFunctionClass struct { diff --git a/expression/builtin_op_test.go b/expression/builtin_op_test.go index e1442abc9d385..54d0b8ef2f6ef 100644 --- a/expression/builtin_op_test.go +++ b/expression/builtin_op_test.go @@ -20,6 +20,7 @@ import ( . "github.com/pingcap/check" "github.com/pingcap/tidb/ast" "github.com/pingcap/tidb/util/testleak" + "github.com/pingcap/tidb/util/testutil" "github.com/pingcap/tidb/util/types" ) @@ -476,3 +477,77 @@ func (s *testEvaluatorSuite) TestUnaryNot(c *C) { c.Assert(err, IsNil) c.Assert(f.isDeterministic(), IsTrue) } + +func (s *testEvaluatorSuite) TestIsTrueOrFalse(c *C) { + defer testleak.AfterTest(c)() + sc := s.ctx.GetSessionVars().StmtCtx + origin := sc.IgnoreTruncate + defer func() { + sc.IgnoreTruncate = origin + }() + sc.IgnoreTruncate = true + + testCases := []struct { + args []interface{} + isTrue interface{} + isFalse interface{} + }{ + { + args: []interface{}{int64(-12)}, + isTrue: int64(1), + isFalse: int64(0), + }, + { + args: []interface{}{int64(12)}, + isTrue: int64(1), + isFalse: int64(0), + }, + { + args: []interface{}{int64(0)}, + isTrue: int64(0), + isFalse: int64(1), + }, + { + args: []interface{}{float64(0)}, + isTrue: int64(0), + isFalse: int64(1), + }, + { + args: []interface{}{"aaa"}, + isTrue: int64(0), + isFalse: int64(1), + }, + { + args: []interface{}{""}, + isTrue: int64(0), + isFalse: int64(1), + }, + { + args: []interface{}{nil}, + isTrue: int64(0), + isFalse: int64(0), + }, + } + + for _, tc := range testCases { + isTrueSig, err := funcs[ast.IsTruth].getFunction(datumsToConstants(types.MakeDatums(tc.args...)), s.ctx) + c.Assert(err, IsNil) + c.Assert(isTrueSig, NotNil) + c.Assert(isTrueSig.isDeterministic(), IsTrue) + + isTrue, err := isTrueSig.eval(nil) + c.Assert(err, IsNil) + c.Assert(isTrue, testutil.DatumEquals, types.NewDatum(tc.isTrue)) + } + + for _, tc := range testCases { + isFalseSig, err := funcs[ast.IsFalsity].getFunction(datumsToConstants(types.MakeDatums(tc.args...)), s.ctx) + c.Assert(err, IsNil) + c.Assert(isFalseSig, NotNil) + c.Assert(isFalseSig.isDeterministic(), IsTrue) + + isFalse, err := isFalseSig.eval(nil) + c.Assert(err, IsNil) + c.Assert(isFalse, testutil.DatumEquals, types.NewDatum(tc.isFalse)) + } +} diff --git a/expression/integration_test.go b/expression/integration_test.go index a09ae6c388ed0..ff41c20ba1b97 100644 --- a/expression/integration_test.go +++ b/expression/integration_test.go @@ -633,7 +633,7 @@ func (s *testIntegrationSuite) TestBuiltin(c *C) { tk := testkit.NewTestKit(c, s.store) tk.MustExec("use test") - // for is true + // for is true && is false tk.MustExec("drop table if exists t") tk.MustExec("create table t (a int, b int, index idx_b (b))") tk.MustExec("insert t values (1, 1)") @@ -647,6 +647,11 @@ func (s *testIntegrationSuite) TestBuiltin(c *C) { result.Check(nil) result = tk.MustQuery("select * from t where a is not true") result.Check(nil) + result = tk.MustQuery(`select 1 is true, 0 is true, null is true, "aaa" is true, "" is true, -12.00 is true, 0.0 is true;`) + result.Check(testkit.Rows("1 0 0 0 0 1 0")) + result = tk.MustQuery(`select 1 is false, 0 is false, null is false, "aaa" is false, "" is false, -12.00 is false, 0.0 is false;`) + result.Check(testkit.Rows("0 1 0 1 1 0 1")) + // for in result = tk.MustQuery("select * from t where b in (a)") result.Check(testkit.Rows("1 1", "2 2")) diff --git a/plan/typeinfer_test.go b/plan/typeinfer_test.go index 57e4389797053..9a1df1fb9e4e7 100644 --- a/plan/typeinfer_test.go +++ b/plan/typeinfer_test.go @@ -269,6 +269,28 @@ func (s *testPlanSuite) createTestCase4MathFuncs() []typeInferTestCase { {"ceiling(c_text)", mysql.TypeDouble, charset.CharsetBin, mysql.BinaryFlag, mysql.MaxRealWidth, 0}, {"ceiling(18446744073709551615)", mysql.TypeNewDecimal, charset.CharsetBin, mysql.BinaryFlag, 20, 0}, {"ceiling(18446744073709551615.1)", mysql.TypeNewDecimal, charset.CharsetBin, mysql.BinaryFlag, 22, 0}, + + {"c_int is true", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_decimal is true", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_double is true", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_float is true", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_datetime is true", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_time is true", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_enum is true", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_text is true", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"18446 is true", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"1844674.1 is true", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + + {"c_int is false", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_decimal is false", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_double is false", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_float is false", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_datetime is false", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_time is false", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_enum is false", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"c_text is false", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"18446 is false", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, + {"1844674.1 is false", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 1, 0}, } } From 0af34ea3ffb05b959115bc3770f0f4e78f237c43 Mon Sep 17 00:00:00 2001 From: Jian Zhang Date: Thu, 10 Aug 2017 13:21:47 +0800 Subject: [PATCH 2/4] address comment --- expression/builtin_op.go | 101 ++++++++++++++++++++++++++++----- expression/builtin_op_test.go | 34 +++++------ expression/integration_test.go | 8 +-- 3 files changed, 107 insertions(+), 36 deletions(-) diff --git a/expression/builtin_op.go b/expression/builtin_op.go index 223b5641bbb35..1a292b5e35f97 100644 --- a/expression/builtin_op.go +++ b/expression/builtin_op.go @@ -39,8 +39,12 @@ var ( _ builtinFunc = &builtinLogicAndSig{} _ builtinFunc = &builtinLogicOrSig{} _ builtinFunc = &builtinLogicXorSig{} - _ builtinFunc = &builtinIsTrueSig{} - _ builtinFunc = &builtinIsFalseSig{} + _ builtinFunc = &builtinRealIsTrueSig{} + _ builtinFunc = &builtinDecimalIsTrueSig{} + _ builtinFunc = &builtinIntIsTrueSig{} + _ builtinFunc = &builtinRealIsFalseSig{} + _ builtinFunc = &builtinDecimalIsFalseSig{} + _ builtinFunc = &builtinIntIsFalseSig{} _ builtinFunc = &builtinUnaryOpSig{} _ builtinFunc = &builtinUnaryMinusIntSig{} _ builtinFunc = &builtinIsNullSig{} @@ -351,39 +355,106 @@ func (c *isTrueOrFalseFunctionClass) getFunction(args []Expression, ctx context. if err := c.verifyArgs(args); err != nil { return nil, errors.Trace(err) } - bf, err := newBaseBuiltinFuncWithTp(args, ctx, tpInt, tpInt) + + argTp := tpInt + switch args[0].GetTypeClass() { + case types.ClassReal: + argTp = tpReal + case types.ClassDecimal: + argTp = tpDecimal + } + bf, err := newBaseBuiltinFuncWithTp(args, ctx, tpInt, argTp) if err != nil { return nil, errors.Trace(err) } bf.tp.Flen = 1 - if c.op == opcode.IsTruth { - sig := &builtinIsTrueSig{baseIntBuiltinFunc{bf}} - return sig.setSelf(sig), nil + + var sig builtinFunc + switch { + case c.op == opcode.IsTruth && argTp == tpReal: + sig = &builtinRealIsTrueSig{baseIntBuiltinFunc{bf}} + case c.op == opcode.IsTruth && argTp == tpDecimal: + sig = &builtinDecimalIsTrueSig{baseIntBuiltinFunc{bf}} + case c.op == opcode.IsTruth && argTp == tpInt: + sig = &builtinIntIsTrueSig{baseIntBuiltinFunc{bf}} + case argTp == tpReal: + sig = &builtinRealIsFalseSig{baseIntBuiltinFunc{bf}} + case argTp == tpDecimal: + sig = &builtinDecimalIsFalseSig{baseIntBuiltinFunc{bf}} + default: + sig = &builtinIntIsFalseSig{baseIntBuiltinFunc{bf}} } - sig := &builtinIsFalseSig{baseIntBuiltinFunc{bf}} return sig.setSelf(sig), nil } -type builtinIsTrueSig struct{ baseIntBuiltinFunc } -type builtinIsFalseSig struct{ baseIntBuiltinFunc } +type builtinRealIsTrueSig struct{ baseIntBuiltinFunc } +type builtinDecimalIsTrueSig struct{ baseIntBuiltinFunc } +type builtinIntIsTrueSig struct{ baseIntBuiltinFunc } +type builtinRealIsFalseSig struct{ baseIntBuiltinFunc } +type builtinDecimalIsFalseSig struct{ baseIntBuiltinFunc } +type builtinIntIsFalseSig struct{ baseIntBuiltinFunc } + +func (b *builtinRealIsTrueSig) evalInt(row []types.Datum) (int64, bool, error) { + input, isNull, err := b.args[0].EvalReal(row, b.ctx.GetSessionVars().StmtCtx) + if err != nil { + return 0, true, errors.Trace(err) + } + if isNull || input == 0 { + return 0, false, nil + } + return 1, false, nil +} + +func (b *builtinDecimalIsTrueSig) evalInt(row []types.Datum) (int64, bool, error) { + input, isNull, err := b.args[0].EvalDecimal(row, b.ctx.GetSessionVars().StmtCtx) + if err != nil { + return 0, true, errors.Trace(err) + } + if isNull || input.IsZero() { + return 0, false, nil + } + return 1, false, nil +} + +func (b *builtinIntIsTrueSig) evalInt(row []types.Datum) (int64, bool, error) { + input, isNull, err := b.args[0].EvalInt(row, b.ctx.GetSessionVars().StmtCtx) + if err != nil { + return 0, true, errors.Trace(err) + } + if isNull || input == 0 { + return 0, false, nil + } + return 1, false, nil +} + +func (b *builtinRealIsFalseSig) evalInt(row []types.Datum) (int64, bool, error) { + input, isNull, err := b.args[0].EvalReal(row, b.ctx.GetSessionVars().StmtCtx) + if err != nil { + return 0, true, errors.Trace(err) + } + if isNull || input != 0 { + return 0, false, nil + } + return 1, false, nil +} -func (b *builtinIsTrueSig) evalInt(row []types.Datum) (int64, bool, error) { - boolResult, isNull, err := b.args[0].EvalInt(row, b.ctx.GetSessionVars().StmtCtx) +func (b *builtinDecimalIsFalseSig) evalInt(row []types.Datum) (int64, bool, error) { + input, isNull, err := b.args[0].EvalDecimal(row, b.ctx.GetSessionVars().StmtCtx) if err != nil { return 0, true, errors.Trace(err) } - if isNull || boolResult == 0 { + if isNull || !input.IsZero() { return 0, false, nil } return 1, false, nil } -func (b *builtinIsFalseSig) evalInt(row []types.Datum) (int64, bool, error) { - boolResult, isNull, err := b.args[0].EvalInt(row, b.ctx.GetSessionVars().StmtCtx) +func (b *builtinIntIsFalseSig) evalInt(row []types.Datum) (int64, bool, error) { + input, isNull, err := b.args[0].EvalInt(row, b.ctx.GetSessionVars().StmtCtx) if err != nil { return 0, true, errors.Trace(err) } - if isNull || boolResult != 0 { + if isNull || input != 0 { return 0, false, nil } return 1, false, nil diff --git a/expression/builtin_op_test.go b/expression/builtin_op_test.go index 54d0b8ef2f6ef..225d27b6cdb0d 100644 --- a/expression/builtin_op_test.go +++ b/expression/builtin_op_test.go @@ -493,39 +493,39 @@ func (s *testEvaluatorSuite) TestIsTrueOrFalse(c *C) { isFalse interface{} }{ { - args: []interface{}{int64(-12)}, - isTrue: int64(1), - isFalse: int64(0), + args: []interface{}{-12}, + isTrue: 1, + isFalse: 0, }, { - args: []interface{}{int64(12)}, - isTrue: int64(1), - isFalse: int64(0), + args: []interface{}{12}, + isTrue: 1, + isFalse: 0, }, { - args: []interface{}{int64(0)}, - isTrue: int64(0), - isFalse: int64(1), + args: []interface{}{0}, + isTrue: 0, + isFalse: 1, }, { args: []interface{}{float64(0)}, - isTrue: int64(0), - isFalse: int64(1), + isTrue: 0, + isFalse: 1, }, { args: []interface{}{"aaa"}, - isTrue: int64(0), - isFalse: int64(1), + isTrue: 0, + isFalse: 1, }, { args: []interface{}{""}, - isTrue: int64(0), - isFalse: int64(1), + isTrue: 0, + isFalse: 1, }, { args: []interface{}{nil}, - isTrue: int64(0), - isFalse: int64(0), + isTrue: 0, + isFalse: 0, }, } diff --git a/expression/integration_test.go b/expression/integration_test.go index d9a74dd18c1dd..2b80e60774bac 100644 --- a/expression/integration_test.go +++ b/expression/integration_test.go @@ -688,10 +688,10 @@ func (s *testIntegrationSuite) TestBuiltin(c *C) { result.Check(nil) result = tk.MustQuery("select * from t where a is not true") result.Check(nil) - result = tk.MustQuery(`select 1 is true, 0 is true, null is true, "aaa" is true, "" is true, -12.00 is true, 0.0 is true;`) - result.Check(testkit.Rows("1 0 0 0 0 1 0")) - result = tk.MustQuery(`select 1 is false, 0 is false, null is false, "aaa" is false, "" is false, -12.00 is false, 0.0 is false;`) - result.Check(testkit.Rows("0 1 0 1 1 0 1")) + result = tk.MustQuery(`select 1 is true, 0 is true, null is true, "aaa" is true, "" is true, -12.00 is true, 0.0 is true, 0.0000001 is true;`) + result.Check(testkit.Rows("1 0 0 0 0 1 0 1")) + result = tk.MustQuery(`select 1 is false, 0 is false, null is false, "aaa" is false, "" is false, -12.00 is false, 0.0 is false, 0.0000001 is false;`) + result.Check(testkit.Rows("0 1 0 1 1 0 1 0")) // for in result = tk.MustQuery("select * from t where b in (a)") From 6905d7b86e85d514c328eaaec0999b2c5cb82301 Mon Sep 17 00:00:00 2001 From: Jian Zhang Date: Thu, 10 Aug 2017 15:21:16 +0800 Subject: [PATCH 3/4] address comment: --- expression/builtin_op.go | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-) diff --git a/expression/builtin_op.go b/expression/builtin_op.go index 1a292b5e35f97..82c6b8df07451 100644 --- a/expression/builtin_op.go +++ b/expression/builtin_op.go @@ -370,19 +370,25 @@ func (c *isTrueOrFalseFunctionClass) getFunction(args []Expression, ctx context. bf.tp.Flen = 1 var sig builtinFunc - switch { - case c.op == opcode.IsTruth && argTp == tpReal: - sig = &builtinRealIsTrueSig{baseIntBuiltinFunc{bf}} - case c.op == opcode.IsTruth && argTp == tpDecimal: - sig = &builtinDecimalIsTrueSig{baseIntBuiltinFunc{bf}} - case c.op == opcode.IsTruth && argTp == tpInt: - sig = &builtinIntIsTrueSig{baseIntBuiltinFunc{bf}} - case argTp == tpReal: - sig = &builtinRealIsFalseSig{baseIntBuiltinFunc{bf}} - case argTp == tpDecimal: - sig = &builtinDecimalIsFalseSig{baseIntBuiltinFunc{bf}} - default: - sig = &builtinIntIsFalseSig{baseIntBuiltinFunc{bf}} + switch c.op { + case opcode.IsTruth: + switch argTp { + case tpReal: + sig = &builtinRealIsTrueSig{baseIntBuiltinFunc{bf}} + case tpDecimal: + sig = &builtinDecimalIsTrueSig{baseIntBuiltinFunc{bf}} + case tpInt: + sig = &builtinIntIsTrueSig{baseIntBuiltinFunc{bf}} + } + case opcode.IsFalsity: + switch argTp { + case tpReal: + sig = &builtinRealIsFalseSig{baseIntBuiltinFunc{bf}} + case tpDecimal: + sig = &builtinDecimalIsFalseSig{baseIntBuiltinFunc{bf}} + case tpInt: + sig = &builtinIntIsFalseSig{baseIntBuiltinFunc{bf}} + } } return sig.setSelf(sig), nil } From 9fb65757c4053c8c587ad4912d89442509fe3dfe Mon Sep 17 00:00:00 2001 From: Jian Zhang Date: Thu, 10 Aug 2017 19:34:49 +0800 Subject: [PATCH 4/4] address comment --- expression/builtin_op.go | 29 +++++++++++++++++++++++------ 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/expression/builtin_op.go b/expression/builtin_op.go index fe6f27d1af9f9..c0758d40881e4 100644 --- a/expression/builtin_op.go +++ b/expression/builtin_op.go @@ -398,12 +398,9 @@ func (c *isTrueOrFalseFunctionClass) getFunction(args []Expression, ctx context. return sig.setSelf(sig), nil } -type builtinRealIsTrueSig struct{ baseIntBuiltinFunc } -type builtinDecimalIsTrueSig struct{ baseIntBuiltinFunc } -type builtinIntIsTrueSig struct{ baseIntBuiltinFunc } -type builtinRealIsFalseSig struct{ baseIntBuiltinFunc } -type builtinDecimalIsFalseSig struct{ baseIntBuiltinFunc } -type builtinIntIsFalseSig struct{ baseIntBuiltinFunc } +type builtinRealIsTrueSig struct { + baseIntBuiltinFunc +} func (b *builtinRealIsTrueSig) evalInt(row []types.Datum) (int64, bool, error) { input, isNull, err := b.args[0].EvalReal(row, b.ctx.GetSessionVars().StmtCtx) @@ -416,6 +413,10 @@ func (b *builtinRealIsTrueSig) evalInt(row []types.Datum) (int64, bool, error) { return 1, false, nil } +type builtinDecimalIsTrueSig struct { + baseIntBuiltinFunc +} + func (b *builtinDecimalIsTrueSig) evalInt(row []types.Datum) (int64, bool, error) { input, isNull, err := b.args[0].EvalDecimal(row, b.ctx.GetSessionVars().StmtCtx) if err != nil { @@ -427,6 +428,10 @@ func (b *builtinDecimalIsTrueSig) evalInt(row []types.Datum) (int64, bool, error return 1, false, nil } +type builtinIntIsTrueSig struct { + baseIntBuiltinFunc +} + func (b *builtinIntIsTrueSig) evalInt(row []types.Datum) (int64, bool, error) { input, isNull, err := b.args[0].EvalInt(row, b.ctx.GetSessionVars().StmtCtx) if err != nil { @@ -438,6 +443,10 @@ func (b *builtinIntIsTrueSig) evalInt(row []types.Datum) (int64, bool, error) { return 1, false, nil } +type builtinRealIsFalseSig struct { + baseIntBuiltinFunc +} + func (b *builtinRealIsFalseSig) evalInt(row []types.Datum) (int64, bool, error) { input, isNull, err := b.args[0].EvalReal(row, b.ctx.GetSessionVars().StmtCtx) if err != nil { @@ -449,6 +458,10 @@ func (b *builtinRealIsFalseSig) evalInt(row []types.Datum) (int64, bool, error) return 1, false, nil } +type builtinDecimalIsFalseSig struct { + baseIntBuiltinFunc +} + func (b *builtinDecimalIsFalseSig) evalInt(row []types.Datum) (int64, bool, error) { input, isNull, err := b.args[0].EvalDecimal(row, b.ctx.GetSessionVars().StmtCtx) if err != nil { @@ -460,6 +473,10 @@ func (b *builtinDecimalIsFalseSig) evalInt(row []types.Datum) (int64, bool, erro return 1, false, nil } +type builtinIntIsFalseSig struct { + baseIntBuiltinFunc +} + func (b *builtinIntIsFalseSig) evalInt(row []types.Datum) (int64, bool, error) { input, isNull, err := b.args[0].EvalInt(row, b.ctx.GetSessionVars().StmtCtx) if err != nil {