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

executor/executor_test.go

@@ -1034,6 +1034,12 @@ 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 -9223372036854775808;")
+	result.Check(testkit.Rows("-9223372036854775808"))
+
 	// test unhex and hex
 	result = tk.MustQuery("select unhex('4D7953514C')")
 	result.Check(testkit.Rows("MySQL"))

expression/builtin_op.go

@@ -14,6 +14,10 @@
 package expression
 
 import (
+	"math"
+
+	"fmt"
+
 	"github.com/juju/errors"
 	"github.com/pingcap/tidb/context"
 	"github.com/pingcap/tidb/parser/opcode"
@@ -353,7 +357,15 @@ func (b *builtinUnaryOpSig) eval(row []types.Datum) (d types.Datum, err error) {
 		case types.KindInt64:
 			d.SetInt64(-aDatum.GetInt64())
 		case types.KindUint64:
-			d.SetInt64(-int64(aDatum.GetUint64()))
+			uval := aDatum.GetUint64()
+			minInt64 := math.MinInt64
+			absMinInt64 := uint64(-minInt64) // 9223372036854775808
+			if uval > absMinInt64 {
+				// -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:

expression/builtin_op_test.go

@@ -0,0 +1,54 @@
+// 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/pingcap/check"
+	"github.com/pingcap/tidb/ast"
+	"github.com/pingcap/tidb/mysql"
+	"github.com/pingcap/tidb/util/testleak"
+)
+
+func (s *testEvaluatorSuite) TestUnary(c *C) {
+	defer testleak.AfterTest(c)()
+	cases := []struct {
+		args         interface{}
+		expected     interface{}
+		expectedType byte
+		overflow     bool
+		getErr       bool
+	}{
+		{uint64(9223372036854775809), "-9223372036854775809", mysql.TypeNewDecimal, true, false},
+		{uint64(9223372036854775810), "-9223372036854775810", mysql.TypeNewDecimal, true, false},
+		{uint64(9223372036854775808), "-9223372036854775808", mysql.TypeLonglong, false, false},
+	}
+
+	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 {
+			c.Assert(err, NotNil)
+		} else {
+			c.Assert(err, IsNil)
+			if !t.overflow {
+				c.Assert(d.GetString(), Equals, t.expected)
+			} else {
+				c.Assert(d.GetMysqlDecimal().String(), Equals, t.expected)
+				c.Assert(f.GetType().Tp, Equals, t.expectedType)
+			}
+		}
+	}
+}

expression/constant_fold.go

@@ -40,6 +40,7 @@ func FoldConstant(expr Expression) Expression {
 		log.Warnf("There may exist an error during constant folding. The function name is %s, args are %s", scalarFunc.FuncName, args)
 		return expr
 	}
+
 	return &Constant{
 		Value:   value,
 		RetType: scalarFunc.RetType,

expression/scalar_function.go

@@ -23,6 +23,7 @@ import (
 	"github.com/pingcap/tidb/model"
 	"github.com/pingcap/tidb/mysql"
 	"github.com/pingcap/tidb/sessionctx/variable"
+	"github.com/pingcap/tidb/terror"
 	"github.com/pingcap/tidb/util/codec"
 	"github.com/pingcap/tidb/util/types"
 )
@@ -157,12 +158,39 @@ func (sf *ScalarFunction) Decorrelate(schema *Schema) Expression {
 	return sf
 }
 
+func (sf *ScalarFunction) convertArgsToDecimal(sc *variable.StatementContext) error {
+	ft := types.NewFieldType(mysql.TypeNewDecimal)
+	for _, arg := range sf.GetArgs() {
+		if constArg, ok := arg.(*Constant); ok {
+			val, err := constArg.Value.ConvertTo(sc, ft)
+			if err != nil {
+				return err
+			}
+			constArg.Value = val
+		}
+	}
+
+	return nil
+}
+
 // 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)
+		// TODO: fix #3762, maybe better way
+		if err != nil && terror.ErrorEqual(err, types.ErrOverflow) && sf.GetTypeClass() == types.ClassInt &&
+			sf.FuncName.L == ast.UnaryMinus && !sc.InUpdateOrDeleteStmt {
+			err = sf.convertArgsToDecimal(sc)
+			if err != nil {
+				return d, errors.Trace(err)
+			}
+			d, err = sf.Function.eval(row)
+			// change return type
+			types.DefaultTypeForValue(d, sf.RetType)
+		}
+		return
 	}
-	sc := sf.GetCtx().GetSessionVars().StmtCtx
 	var (
 		res    interface{}
 		isNull bool
@@ -172,6 +200,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 {
@@ -191,6 +220,18 @@ func (sf *ScalarFunction) Eval(row []types.Datum) (d types.Datum, err error) {
 			res, isNull, err = sf.EvalString(row, sc)
 		}
 	}
+
+	if err != nil && terror.ErrorEqual(err, types.ErrOverflow) &&
+		sf.FuncName.L == ast.UnaryMinus && !sc.InUpdateOrDeleteStmt {
+		// TODO: fix #3762, overflow convert it to decimal
+		err = sf.convertArgsToDecimal(sc)
+		if err != nil {
+			return d, errors.Trace(err)
+		}
+		res, isNull, err = sf.EvalDecimal(row, sc)
+		types.DefaultTypeForValue(res, sf.RetType)
+	}
+
 	if isNull || err != nil {
 		d.SetValue(nil)
 		return d, errors.Trace(err)