expression: fix #3762, signed integer overflow handle in minus unary scalar function

executor/executor_test.go

@@ -1080,6 +1080,19 @@ func (s *testSuite) TestBuiltin(c *C) {
 	result = tk.MustQuery("select cast(a as signed) from t")
 	result.Check(testkit.Rows("130000"))
 
+	// fixed issue #3762
+	result = tk.MustQuery("select -9223372036854775809;")
+	result.Check(testkit.Rows("-9223372036854775809"))
+	result = tk.MustQuery("select --9223372036854775809;")
+	result.Check(testkit.Rows("9223372036854775809"))
+	result = tk.MustQuery("select -9223372036854775808;")
+	result.Check(testkit.Rows("-9223372036854775808"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a bigint(30));")
+	_, err := tk.Exec("insert into t values(-9223372036854775809)")
+	c.Assert(err, NotNil)
+
 	// test unhex and hex
 	result = tk.MustQuery("select unhex('4D7953514C')")
 	result.Check(testkit.Rows("MySQL"))

executor/prepared.go

@@ -347,6 +347,9 @@ func ResetStmtCtx(ctx context.Context, s ast.StmtNode) {
 	case *ast.LoadDataStmt:
 		sc.IgnoreTruncate = false
 		sc.TruncateAsWarning = !sessVars.StrictSQLMode
+	case *ast.SelectStmt:
+		sc.InSelectStmt = true
+		sc.IgnoreTruncate = true
 	default:
 		sc.IgnoreTruncate = true
 		if show, ok := s.(*ast.ShowStmt); ok {

expression/builtin.go

@@ -786,7 +786,7 @@ var funcs = map[string]functionClass{
 	ast.UnaryNot:   &unaryOpFunctionClass{baseFunctionClass{ast.UnaryNot, 1, 1}, opcode.Not},
 	ast.BitNeg:     &unaryOpFunctionClass{baseFunctionClass{ast.BitNeg, 1, 1}, opcode.BitNeg},
 	ast.UnaryPlus:  &unaryOpFunctionClass{baseFunctionClass{ast.UnaryPlus, 1, 1}, opcode.Plus},
-	ast.UnaryMinus: &unaryOpFunctionClass{baseFunctionClass{ast.UnaryMinus, 1, 1}, opcode.Minus},
+	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},

expression/builtin_op.go

@@ -14,8 +14,12 @@
 package expression
 
 import (
+	"fmt"
+	"math"
+
 	"github.com/juju/errors"
 	"github.com/pingcap/tidb/context"
+	"github.com/pingcap/tidb/mysql"
 	"github.com/pingcap/tidb/parser/opcode"
 	"github.com/pingcap/tidb/util/types"
 )
@@ -27,6 +31,7 @@ var (
 	_ functionClass = &bitOpFunctionClass{}
 	_ functionClass = &isTrueOpFunctionClass{}
 	_ functionClass = &unaryOpFunctionClass{}
+	_ functionClass = &unaryMinusFunctionClass{}
 	_ functionClass = &isNullFunctionClass{}
 )
 
@@ -37,6 +42,7 @@ var (
 	_ builtinFunc = &builtinBitOpSig{}
 	_ builtinFunc = &builtinIsTrueOpSig{}
 	_ builtinFunc = &builtinUnaryOpSig{}
+	_ builtinFunc = &builtinUnaryMinusIntSig{}
 	_ builtinFunc = &builtinIsNullSig{}
 )
 
@@ -338,9 +344,19 @@ func (b *builtinUnaryOpSig) eval(row []types.Datum) (d types.Datum, err error) {
 	case opcode.Minus:
 		switch aDatum.Kind() {
 		case types.KindInt64:
-			d.SetInt64(-aDatum.GetInt64())
+			val := aDatum.GetInt64()
+			if val == math.MinInt64 {
+				err = types.ErrOverflow.GenByArgs("BIGINT", fmt.Sprintf("-%v", val))
+			}
+			d.SetInt64(-val)
 		case types.KindUint64:
-			d.SetInt64(-int64(aDatum.GetUint64()))
+			uval := aDatum.GetUint64()
+			if uval > uint64(-math.MinInt64) { // 9223372036854775808
+				// -uval will overflow
+				err = types.ErrOverflow.GenByArgs("BIGINT", fmt.Sprintf("-%v", uval))
+			} else {
+				d.SetInt64(-int64(uval))
+			}
 		case types.KindFloat64:
 			d.SetFloat64(-aDatum.GetFloat64())
 		case types.KindFloat32:
@@ -378,6 +394,157 @@ func (b *builtinUnaryOpSig) eval(row []types.Datum) (d types.Datum, err error) {
 	return
 }
 
+type unaryMinusFunctionClass struct {
+	baseFunctionClass
+}
+
+func (b *unaryMinusFunctionClass) typeInfer(argExpr Expression) (evalTp, bool) {
+	tp := tpInt
+	switch argExpr.GetTypeClass() {
+	case types.ClassString, types.ClassReal:
+		tp = tpReal
+	case types.ClassDecimal:
+		tp = tpDecimal
+	}
+
+	overflow := false
+	// TODO: handle float overflow
+	if arg, ok := argExpr.(*Constant); ok {
+		switch arg.Value.Kind() {
+		case types.KindUint64:
+			uval := arg.Value.GetUint64()
+			if uval > uint64(-math.MinInt64) {
+				overflow = true
+				tp = tpDecimal
+			}
+		case types.KindInt64:
+			val := arg.Value.GetInt64()
+			if val == math.MinInt64 {
+				overflow = true
+				tp = tpDecimal
+			}
+		}
+	}
+	return tp, overflow
+}
+
+func (b *unaryMinusFunctionClass) getFunction(args []Expression, ctx context.Context) (sig builtinFunc, err error) {
+	err = b.verifyArgs(args)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	argExpr := args[0]
+	retTp, intOverflow := b.typeInfer(argExpr)
+
+	var bf baseBuiltinFunc
+	switch argExpr.GetTypeClass() {
+	case types.ClassInt:
+		if intOverflow {
+			bf, err = newBaseBuiltinFuncWithTp(args, ctx, retTp, tpDecimal)
+			if err != nil {
+				return nil, errors.Trace(err)
+			}
+			sig = &builtinUnaryMinusDecimalSig{baseDecimalBuiltinFunc{bf}, false}
+		} else {
+			bf, err = newBaseBuiltinFuncWithTp(args, ctx, retTp, tpInt)
+			if err != nil {
+				return nil, errors.Trace(err)
+			}
+			sig = &builtinUnaryMinusIntSig{baseIntBuiltinFunc{bf}}
+		}
+	case types.ClassDecimal:
+		bf, err = newBaseBuiltinFuncWithTp(args, ctx, retTp, tpDecimal)
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+		sig = &builtinUnaryMinusDecimalSig{baseDecimalBuiltinFunc{bf}, false}
+	case types.ClassReal:
+		bf, err = newBaseBuiltinFuncWithTp(args, ctx, retTp, tpReal)
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+		sig = &builtinUnaryMinusRealSig{baseRealBuiltinFunc{bf}}
+	case types.ClassString:
+		tp := argExpr.GetType().Tp
+		if types.IsTypeTime(tp) || tp == mysql.TypeDuration {
+			bf, err = newBaseBuiltinFuncWithTp(args, ctx, retTp, tpDecimal)
+			if err != nil {
+				return nil, errors.Trace(err)
+			}
+			sig = &builtinUnaryMinusDecimalSig{baseDecimalBuiltinFunc{bf}, false}
+		} else {
+			bf, err = newBaseBuiltinFuncWithTp(args, ctx, retTp, tpReal)
+			if err != nil {
+				return nil, errors.Trace(err)
+			}
+			sig = &builtinUnaryMinusRealSig{baseRealBuiltinFunc{bf}}
+		}
+	}
+
+	return sig.setSelf(sig), errors.Trace(err)
+}
+
+type builtinUnaryMinusIntSig struct {
+	baseIntBuiltinFunc
+}
+
+func (b *builtinUnaryMinusIntSig) evalInt(row []types.Datum) (res int64, isNull bool, err error) {
+	var val int64
+	val, isNull, err = b.args[0].EvalInt(row, b.getCtx().GetSessionVars().StmtCtx)
+	if err != nil || isNull {
+		return val, isNull, errors.Trace(err)
+	}
+
+	if mysql.HasUnsignedFlag(b.args[0].GetType().Flag) {
+		uval := uint64(val)
+		if uval > uint64(-math.MinInt64) {
+			return 0, false, types.ErrOverflow.GenByArgs("BIGINT", fmt.Sprintf("-%v", uval))
+		} else if uval == uint64(-math.MinInt64) {
+			return math.MinInt64, false, nil
+		}
+	} else if val == math.MinInt64 {
+		return 0, false, types.ErrOverflow.GenByArgs("BIGINT", fmt.Sprintf("-%v", val))
+	}
+	return -val, false, err
+}
+
+type builtinUnaryMinusDecimalSig struct {
+	baseDecimalBuiltinFunc
+
+	constantArgOverflow bool
+}
+
+func (b *builtinUnaryMinusDecimalSig) evalDecimal(row []types.Datum) (*types.MyDecimal, bool, error) {
+	sc := b.getCtx().GetSessionVars().StmtCtx
+
+	var dec *types.MyDecimal
+	dec, isNull, err := b.args[0].EvalDecimal(row, sc)
+	if err != nil || isNull {
+		return dec, isNull, errors.Trace(err)
+	}
+
+	if !sc.InSelectStmt && b.constantArgOverflow {
+		return dec, false, types.ErrOverflow.GenByArgs("DECIMAL", dec.String())
+	}
+
+	to := new(types.MyDecimal)
+	err = types.DecimalSub(new(types.MyDecimal), dec, to)
+	return to, false, err
+}
+
+type builtinUnaryMinusRealSig struct {
+	baseRealBuiltinFunc
+}
+
+func (b *builtinUnaryMinusRealSig) evalReal(row []types.Datum) (res float64, isNull bool, err error) {
+	sc := b.getCtx().GetSessionVars().StmtCtx
+	var val float64
+	val, isNull, err = b.args[0].EvalReal(row, sc)
+	res = -val
+	return
+}
+
 type isNullFunctionClass struct {
 	baseFunctionClass
 }

expression/builtin_op_test.go

@@ -14,13 +14,52 @@
 package expression
 
 import (
+	"math"
+
 	"github.com/juju/errors"
 	. "github.com/pingcap/check"
 	"github.com/pingcap/tidb/ast"
 	"github.com/pingcap/tidb/util/testleak"
 	"github.com/pingcap/tidb/util/types"
 )
 
+func (s *testEvaluatorSuite) TestUnary(c *C) {
+	defer testleak.AfterTest(c)()
+	cases := []struct {
+		args     interface{}
+		expected interface{}
+		overflow bool
+		getErr   bool
+	}{
+		{uint64(9223372036854775809), "-9223372036854775809", true, false},
+		{uint64(9223372036854775810), "-9223372036854775810", true, false},
+		{uint64(9223372036854775808), int64(-9223372036854775808), false, false},
+		{int64(math.MinInt64), "9223372036854775808", true, false}, // --9223372036854775808
+	}
+	sc := s.ctx.GetSessionVars().StmtCtx
+	origin := sc.InSelectStmt
+	sc.InSelectStmt = true
+	defer func() {
+		sc.InSelectStmt = origin
+	}()
+
+	for _, t := range cases {
+		f, err := newFunctionForTest(s.ctx, ast.UnaryMinus, primitiveValsToConstants([]interface{}{t.args})...)
+		c.Assert(err, IsNil)
+		d, err := f.Eval(nil)
+		if t.getErr == false {
+			c.Assert(err, IsNil)
+			if !t.overflow {
+				c.Assert(d.GetValue(), Equals, t.expected)
+			} else {
+				c.Assert(d.GetMysqlDecimal().String(), Equals, t.expected)
+			}
+		} else {
+			c.Assert(err, NotNil)
+		}
+	}
+}
+
 func (s *testEvaluatorSuite) TestAndAnd(c *C) {
 	defer testleak.AfterTest(c)()
 

expression/expression.go

@@ -170,7 +170,8 @@ func evalExprToDecimal(expr Expression, row []types.Datum, sc *variable.Statemen
 	if val.IsNull() || err != nil {
 		return res, val.IsNull(), errors.Trace(err)
 	}
-	if expr.GetTypeClass() == types.ClassDecimal {
+	switch expr.GetTypeClass() {
+	case types.ClassDecimal:
 		res, err = val.ToDecimal(sc)
 		return res, false, errors.Trace(err)
 		// TODO: We maintain two sets of type systems, one for Expression, one for Datum.
@@ -180,7 +181,8 @@ func evalExprToDecimal(expr Expression, row []types.Datum, sc *variable.Statemen
 		// but what we actually get is store as float64 in Datum.
 		// So if we wrap `CastDecimalAsInt` upon the result, we'll get <nil> when call `arg.EvalDecimal()`.
 		// This will be fixed after all built-in functions be rewrite correctlly.
-	} else if IsHybridType(expr) {
+	}
+	if IsHybridType(expr) {
 		res, err = val.ToDecimal(sc)
 		return res, false, errors.Trace(err)
 	}

expression/scalar_function.go

@@ -83,11 +83,13 @@ func NewFunction(ctx context.Context, funcName string, retType *types.FieldType,
 	if builtinRetTp := f.getRetTp(); builtinRetTp.Tp != mysql.TypeUnspecified {
 		retType = builtinRetTp
 	}
+
 	sf := &ScalarFunction{
 		FuncName: model.NewCIStr(funcName),
 		RetType:  retType,
 		Function: f,
 	}
+
 	return FoldConstant(sf), nil
 }
 
@@ -160,10 +162,11 @@ func (sf *ScalarFunction) Decorrelate(schema *Schema) Expression {
 
 // Eval implements Expression interface.
 func (sf *ScalarFunction) Eval(row []types.Datum) (d types.Datum, err error) {
+	sc := sf.GetCtx().GetSessionVars().StmtCtx
 	if !TurnOnNewExprEval {
-		return sf.Function.eval(row)
+		d, err = sf.Function.eval(row)
+		return
 	}
-	sc := sf.GetCtx().GetSessionVars().StmtCtx
 	var (
 		res    interface{}
 		isNull bool
@@ -173,6 +176,7 @@ func (sf *ScalarFunction) Eval(row []types.Datum) (d types.Datum, err error) {
 	case types.ClassInt:
 		var intRes int64
 		intRes, isNull, err = sf.EvalInt(row, sc)
+
 		if mysql.HasUnsignedFlag(tp.Flag) {
 			res = uint64(intRes)
 		} else {
@@ -192,6 +196,7 @@ func (sf *ScalarFunction) Eval(row []types.Datum) (d types.Datum, err error) {
 			res, isNull, err = sf.EvalString(row, sc)
 		}
 	}
+
 	if isNull || err != nil {
 		d.SetValue(nil)
 		return d, errors.Trace(err)

expression/typeinferer_test.go

@@ -343,6 +343,10 @@ func (ts *testTypeInferrerSuite) TestInferType(c *C) {
 		{`json_insert('{"a": 1}', '$.a', 3)`, mysql.TypeJSON, charset.CharsetUTF8, 0},
 		{`json_replace('{"a": 1}', '$.a', 3)`, mysql.TypeJSON, charset.CharsetUTF8, 0},
 		{`json_merge('{"a": 1}', '3')`, mysql.TypeJSON, charset.CharsetUTF8, 0},
+		{"-9223372036854775809", mysql.TypeNewDecimal, charset.CharsetBin, mysql.BinaryFlag},
+		{"-9223372036854775808", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag},
+		{"--9223372036854775809", mysql.TypeNewDecimal, charset.CharsetBin, mysql.BinaryFlag},
+		{"--9223372036854775808", mysql.TypeNewDecimal, charset.CharsetBin, mysql.BinaryFlag},
 	}
 	for _, tt := range tests {
 		ctx := testKit.Se.(context.Context)

plan/expression_rewriter.go

@@ -93,6 +93,7 @@ func (b *planBuilder) rewriteWithPreprocess(expr ast.ExprNode, p LogicalPlan, ag
 	if getRowLen(er.ctxStack[0]) != 1 {
 		return nil, nil, ErrOperandColumns.GenByArgs(1)
 	}
+
 	return er.ctxStack[0], er.p, nil
 }
 
@@ -142,7 +143,11 @@ func popRowArg(ctx context.Context, e expression.Expression) (ret expression.Exp
 		return ret, errors.Trace(err)
 	}
 	c, _ := e.(*expression.Constant)
-	ret = &expression.Constant{Value: types.NewDatum(c.Value.GetRow()[1:]), RetType: c.GetType()}
+	if getRowLen(c) == 2 {
+		ret = &expression.Constant{Value: c.Value.GetRow()[1], RetType: c.GetType()}
+	} else {
+		ret = &expression.Constant{Value: types.NewDatum(c.Value.GetRow()[1:]), RetType: c.GetType()}
+	}
 	return
 }