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,9 @@
 package expression
 
 import (
+ "fmt"
+ "math"
+
  "github.com/juju/errors"
  "github.com/pingcap/tidb/context"
  "github.com/pingcap/tidb/parser/opcode"
@@ -353,7 +356,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 2017 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,40 @@ 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
+ decVal, _ := d.ToDecimal(sc)
+ types.DefaultTypeForValue(decVal, sf.RetType)
+ }
+ return
  }
- sc := sf.GetCtx().GetSessionVars().StmtCtx
  var (
  res interface{}
  isNull bool
@@ -172,6 +201,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 +221,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)