expression: round function for int should use round half up rule

expression/builtin_math.go

@@ -353,7 +353,7 @@ func (b *builtinRoundRealSig) evalReal(row chunk.Row) (float64, bool, error) {
  if isNull || err != nil {
  return 0, isNull, err
  }
- return types.Round(val, 0), false, nil
+ return types.RoundFloat(val, 0), false, nil
 }
 
 type builtinRoundIntSig struct {
@@ -417,7 +417,7 @@ func (b *builtinRoundWithFracRealSig) evalReal(row chunk.Row) (float64, bool, er
  if isNull || err != nil {
  return 0, isNull, err
  }
- return types.Round(val, int(frac)), false, nil
+ return types.RoundFloat(val, int(frac)), false, nil
 }
 
 type builtinRoundWithFracIntSig struct {
@@ -441,7 +441,7 @@ func (b *builtinRoundWithFracIntSig) evalInt(row chunk.Row) (int64, bool, error)
  if isNull || err != nil {
  return 0, isNull, err
  }
- return int64(types.Round(float64(val), int(frac))), false, nil
+ return types.RoundInt(val, int(frac)), false, nil
 }
 
 type builtinRoundWithFracDecSig struct {

expression/builtin_math_test.go

@@ -435,6 +435,11 @@ func (s *testEvaluatorSuite) TestRound(c *C) {
  {[]interface{}{-1.5, 0}, -2},
  {[]interface{}{1.5, 0}, 2},
  {[]interface{}{23.298, -1}, 20},
+ {[]interface{}{49.99999, -2}, 0},
+ {[]interface{}{50, -2}, 100},
+ {[]interface{}{50.00001, -2}, 100},
+ {[]interface{}{123456789, -5}, 123500000},
+ {[]interface{}{2146213728964879326, -15}, 2146000000000000000},
  {[]interface{}{newDec("-1.23")}, newDec("-1")},
  {[]interface{}{newDec("-1.23"), 1}, newDec("-1.2")},
  {[]interface{}{newDec("-1.58")}, newDec("-2")},

expression/builtin_math_vec.go

@@ -517,7 +517,7 @@ func (b *builtinRoundRealSig) vecEvalReal(input *chunk.Chunk, result *chunk.Colu
  if result.IsNull(i) {
  continue
  }
- f64s[i] = types.Round(f64s[i], 0)
+ f64s[i] = types.RoundFloat(f64s[i], 0)
  }
  return nil
 }
@@ -547,7 +547,7 @@ func (b *builtinRoundWithFracRealSig) vecEvalReal(input *chunk.Chunk, result *ch
  if result.IsNull(i) {
  continue
  }
- x[i] = types.Round(x[i], int(d[i]))
+ x[i] = types.RoundFloat(x[i], int(d[i]))
  }
  return nil
 }
@@ -654,7 +654,7 @@ func (b *builtinRoundWithFracIntSig) vecEvalInt(input *chunk.Chunk, result *chun
  if result.IsNull(i) {
  continue
  }
- i64s[i] = int64(types.Round(float64(i64s[i]), int(frac[i])))
+ i64s[i] = types.RoundInt(i64s[i], int(frac[i]))
  }
  return nil
 }

expression/integration_test.go

@@ -696,6 +696,10 @@ func (s *testIntegrationSuite2) TestMathBuiltin(c *C) {
  result.Check(testkit.Rows("100000000000000 1000000000000000 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"))
  result = tk.MustQuery("SELECT ROUND(1e-14, 1), ROUND(1e-15, 1), ROUND(1e-308, 1)")
  result.Check(testkit.Rows("0 0 0"))
+ result = tk.MustQuery("SELECT round(49.99999, -2), round(50, -2), round(50.00001, -2)")
+ result.Check(testkit.Rows("0 100 100"))
+ result = tk.MustQuery("SELECT round(123456789, -5), round(2146213728964879326, -15), round(24999999999999999,-16)")
+ result.Check(testkit.Rows("123500000 2146000000000000000 20000000000000000"))
 
  // for truncate
  result = tk.MustQuery("SELECT truncate(123, -2), truncate(123, 2), truncate(123, 1), truncate(123, -1);")

types/convert.go

@@ -100,7 +100,7 @@ func IntergerSignedLowerBound(intType byte) int64 {
 // ConvertFloatToInt converts a float64 value to a int value.
 // `tp` is used in err msg, if there is overflow, this func will report err according to `tp`
 func ConvertFloatToInt(fval float64, lowerBound, upperBound int64, tp byte) (int64, error) {
- val := RoundFloat(fval)
+ val := math.RoundToEven(fval)
  if val < float64(lowerBound) {
  return lowerBound, overflow(val, tp)
  }
@@ -160,7 +160,7 @@ func ConvertUintToUint(val uint64, upperBound uint64, tp byte) (uint64, error) {
 
 // ConvertFloatToUint converts a float value to an uint value.
 func ConvertFloatToUint(sc *stmtctx.StatementContext, fval float64, upperBound uint64, tp byte) (uint64, error) {
- val := RoundFloat(fval)
+ val := math.RoundToEven(fval)
  if val < 0 {
  if sc.ShouldClipToZero() {
  return 0, overflow(val, tp)

types/etc_test.go

@@ -132,29 +132,6 @@ func (s *testTypeEtcSuite) TestMaxFloat(c *C) {
  }
 }
 
-func (s *testTypeEtcSuite) TestRoundFloat(c *C) {
- defer testleak.AfterTest(c)()
- tbl := []struct {
- Input float64
- Expect float64
- }{
- {2.5, 2},
- {1.5, 2},
- {0.5, 0},
- {0.49999999999999997, 0},
- {0, 0},
- {-0.49999999999999997, 0},
- {-0.5, 0},
- {-2.5, -2},
- {-1.5, -2},
- }
-
- for _, t := range tbl {
- f := RoundFloat(t.Input)
- c.Assert(f, Equals, t.Expect)
- }
-}
-
 func (s *testTypeEtcSuite) TestRound(c *C) {
  defer testleak.AfterTest(c)()
  tbl := []struct {
@@ -171,7 +148,7 @@ func (s *testTypeEtcSuite) TestRound(c *C) {
  }
 
  for _, t := range tbl {
- f := Round(t.Input, t.Dec)
+ f := RoundFloat(t.Input, t.Dec)
  c.Assert(f, Equals, t.Expect)
  }
 }

types/helper.go

@@ -23,31 +23,35 @@ import (
  "github.com/pingcap/errors"
 )
 
-// RoundFloat rounds float val to the nearest even integer value with float64 format, like MySQL Round function.
-// RoundFloat uses default rounding mode, see https://dev.mysql.com/doc/refman/5.7/en/precision-math-rounding.html
-// so rounding use "round to nearest even".
-// e.g, 1.5 -> 2, -1.5 -> -2.
-func RoundFloat(f float64) float64 {
- return math.RoundToEven(f)
-}
-
-// Round rounds the argument f to dec decimal places.
+// RoundFloat rounds the argument f to dec decimal places using "round to nearest even" rule.
 // dec defaults to 0 if not specified. dec can be negative
-// to cause dec digits left of the decimal point of the
-// value f to become zero.
-func Round(f float64, dec int) float64 {
+// see https://dev.mysql.com/doc/refman/5.7/en/precision-math-rounding.html
+func RoundFloat(f float64, dec int) float64 {
  shift := math.Pow10(dec)
  tmp := f * shift
  if math.IsInf(tmp, 0) {
  return f
  }
- result := RoundFloat(tmp) / shift
+ result := math.RoundToEven(tmp) / shift
  if math.IsNaN(result) {
  return 0
  }
  return result
 }
 
+// RoundInt rounds the argument i to dec decimal places using "round half up" rule.
+// dec defaults to 0 if not specified. dec can be negative
+func RoundInt(i int64, dec int) int64 {
+ // is itself when dec >= 0
+ if dec >= 0 {
+ return i
+ }
+
+ shift := math.Pow10(-dec)
+ intPart := math.Round(float64(i) / shift)
+ return int64(intPart) * int64(shift)
+}
+
 // Truncate truncates the argument f to dec decimal places.
 // dec defaults to 0 if not specified. dec can be negative
 // to cause dec digits left of the decimal point of the
@@ -80,7 +84,7 @@ func TruncateFloat(f float64, flen int, decimal int) (float64, error) {
  maxF := GetMaxFloat(flen, decimal)
 
  if !math.IsInf(f, 0) {
- f = Round(f, decimal)
+ f = RoundFloat(f, decimal)
  }
 
  var err error

types/helper_test.go

@@ -16,18 +16,14 @@ package types
 
 import (
  "strconv"
+ "testing"
 
- . "github.com/pingcap/check"
  "github.com/pingcap/errors"
+ "github.com/stretchr/testify/require"
 )
 
-var _ = Suite(&testTypeHelperSuite{})
-
-type testTypeHelperSuite struct {
-}
-
-func (s *testTypeHelperSuite) TestStrToInt(c *C) {
- c.Parallel()
+func TestStrToInt(t *testing.T) {
+ t.Parallel()
  tests := []struct {
  input string
  output string
@@ -42,13 +38,13 @@ func (s *testTypeHelperSuite) TestStrToInt(c *C) {
  }
  for _, tt := range tests {
  output, err := strToInt(tt.input)
- c.Assert(errors.Cause(err), Equals, tt.err)
- c.Check(strconv.FormatInt(output, 10), Equals, tt.output)
+ require.Equal(t, tt.err, errors.Cause(err))
+ require.Equal(t, tt.output, strconv.FormatInt(output, 10))
  }
 }
 
-func (s *testTypeHelperSuite) TestTruncate(c *C) {
- c.Parallel()
+func TestTruncate(t *testing.T) {
+ t.Parallel()
  tests := []struct {
  f float64
  dec int
@@ -61,12 +57,12 @@ func (s *testTypeHelperSuite) TestTruncate(c *C) {
  }
  for _, tt := range tests {
  res := Truncate(tt.f, tt.dec)
- c.Assert(res, Equals, tt.expected)
+ require.Equal(t, tt.expected, res)
  }
 }
 
-func (s *testTypeHelperSuite) TestTruncateFloatToString(c *C) {
- c.Parallel()
+func TestTruncateFloatToString(t *testing.T) {
+ t.Parallel()
  tests := []struct {
  f float64
  dec int
@@ -83,6 +79,30 @@ func (s *testTypeHelperSuite) TestTruncateFloatToString(c *C) {
  }
  for _, tt := range tests {
  res := TruncateFloatToString(tt.f, tt.dec)
- c.Assert(res, Equals, tt.expected)
+ require.Equal(t, tt.expected, res)
+ }
+}
+
+func TestRoundInt(t *testing.T) {
+ t.Parallel()
+ tests := []struct {
+ i int64
+ dec int
+ expected int64
+ }{
+ {1, 0, 1},
+ {2146213728964879326, -15, 2146000000000000000},
+ {123456789, -5, 123500000},
+ {50, -2, 100},
+ {150, 2, 150},
+ {-1, 0, -1},
+ {-2146213728964879326, -15, -2146000000000000000},
+ {-123456789, -5, -123500000},
+ {-50, -2, -100},
+ {-150, 2, -150},
+ }
+ for _, tt := range tests {
+ res := RoundInt(tt.i, tt.dec)
+ require.Equal(t, tt.expected, res)
  }
 }