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

executor/aggregate_test.go

@@ -318,6 +318,7 @@ func (s *testSuite) TestAggPrune(c *C) {
 		testleak.AfterTest(c)()
 	}()
 	tk := testkit.NewTestKit(c, s.store)
+
 	tk.MustExec("use test")
 	tk.MustExec("drop table if exists t")
 	tk.MustExec("create table t(id int primary key, b varchar(50), c int)")

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,165 @@ 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.GetType().Tp {
+	case mysql.TypeString, mysql.TypeVarchar, mysql.TypeVarString, mysql.TypeDouble, mysql.TypeFloat,
+		mysql.TypeDatetime, mysql.TypeDuration, mysql.TypeTimestamp:
+		tp = tpReal
+	case mysql.TypeNewDecimal:
+		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) {
+	argExpr := args[0]
+	retTp, intOverflow := b.typeInfer(argExpr)
+
+	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) {
+			bf, err := newBaseBuiltinFuncWithTp(args, ctx, retTp, tpDecimal)
+			if err != nil {
+				return nil, errors.Trace(err)
+			}
+			sig = &builtinUnaryMinusDecimalSig{baseDecimalBuiltinFunc{bf}, false}
+		} else if 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(b.verifyArgs(args))
+}
+
+func unaryMinusDecimal(dec *types.MyDecimal) (to *types.MyDecimal, err error) {
+	to = new(types.MyDecimal)
+	err = types.DecimalSub(new(types.MyDecimal), dec, to)
+	return
+}
+
+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) {
+	var (
+		dec, to *types.MyDecimal
+	)
+
+	sc := b.getCtx().GetSessionVars().StmtCtx
+	if !sc.InSelectStmt && b.constantArgOverflow {
+		return dec, false, types.ErrOverflow.GenByArgs("DECIMAL", dec.String())
+	}
+
+	dec, isNull, err := b.args[0].EvalDecimal(row, sc)
+	if err != nil || isNull {
+		return dec, isNull, errors.Trace(err)
+	}
+
+	to, err = unaryMinusDecimal(dec)
+	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/constant_fold.go

@@ -45,3 +45,32 @@ func FoldConstant(expr Expression) Expression {
 		RetType: scalarFunc.RetType,
 	}
 }
+
+// PlainFoldConstant does constant folding optimization
+// on an expression without recursively folding.
+func PlainFoldConstant(expr Expression) Expression {
+	scalarFunc, ok := expr.(*ScalarFunction)
+	if !ok || !scalarFunc.Function.isDeterministic() {
+		return expr
+	}
+	args := scalarFunc.GetArgs()
+	canFold := true
+	for i := 0; i < len(args); i++ {
+		if _, ok := args[i].(*Constant); !ok {
+			canFold = false
+			break
+		}
+	}
+	if !canFold {
+		return expr
+	}
+	value, err := scalarFunc.Eval(nil)
+	if err != nil {
+		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/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)
 	}