expression, util: DecodeDecimal return real precision and frac (#6732) (

#7259)

executor/admin_test.go

@@ -423,6 +423,12 @@ func (s *testSuite) TestAdminCheckTable(c *C) {
 	tk.MustExec(`insert into test set a='12:10:36';`)
 	tk.MustExec(`admin check table test`)
 
+	// Test decimal
+	tk.MustExec(`drop table if exists test`)
+	tk.MustExec("CREATE TABLE test (  a decimal, PRIMARY KEY (a));")
+	tk.MustExec("insert into test set a=10;")
+	tk.MustExec("admin check table test;")
+
 	// Test timestamp type check table.
 	tk.MustExec(`drop table if exists test`)
 	tk.MustExec(`create table test ( a  TIMESTAMP, primary key(a) );`)

expression/distsql_builtin.go

@@ -683,9 +683,8 @@ func convertFloat(val []byte, f32 bool) (*Constant, error) {
 }
 
 func convertDecimal(val []byte) (*Constant, error) {
-	_, dec, err := codec.DecodeDecimal(val)
+	_, dec, precision, frac, err := codec.DecodeDecimal(val)
 	var d types.Datum
-	precision, frac := dec.PrecisionAndFrac()
 	d.SetMysqlDecimal(dec)
 	d.SetLength(precision)
 	d.SetFrac(frac)

util/codec/codec.go

@@ -334,10 +334,12 @@ func DecodeOne(b []byte) (remain []byte, d types.Datum, err error) {
 		b, v, err = DecodeCompactBytes(b)
 		d.SetBytes(v)
 	case decimalFlag:
-		var dec *types.MyDecimal
-		b, dec, err = DecodeDecimal(b)
+		var (
+			dec             *types.MyDecimal
+			precision, frac int
+		)
+		b, dec, precision, frac, err = DecodeDecimal(b)
 		if err == nil {
-			precision, frac := dec.PrecisionAndFrac()
 			d.SetMysqlDecimal(dec)
 			d.SetLength(precision)
 			d.SetFrac(frac)
@@ -559,7 +561,7 @@ func (decoder *Decoder) DecodeOne(b []byte, colIdx int, ft *types.FieldType) (re
 		chk.AppendBytes(colIdx, v)
 	case decimalFlag:
 		var dec *types.MyDecimal
-		b, dec, err = DecodeDecimal(b)
+		b, dec, _, _, err = DecodeDecimal(b)
 		if err != nil {
 			return nil, errors.Trace(err)
 		}

util/codec/decimal.go

@@ -35,13 +35,13 @@ func EncodeDecimal(b []byte, dec *types.MyDecimal, precision, frac int) []byte {
 }
 
 // DecodeDecimal decodes bytes to decimal.
-func DecodeDecimal(b []byte) ([]byte, *types.MyDecimal, error) {
+func DecodeDecimal(b []byte) ([]byte, *types.MyDecimal, int, int, error) {
 	// gofail: var errorInDecodeDecimal bool
 	// if errorInDecodeDecimal {
-	//	 return b, nil, errors.New("gofail error")
+	//	 return b, nil, 0, 0, errors.New("gofail error")
 	// }
 	if len(b) < 3 {
-		return b, nil, errors.New("insufficient bytes to decode value")
+		return b, nil, 0, 0, errors.New("insufficient bytes to decode value")
 	}
 	precision := int(b[0])
 	frac := int(b[1])
@@ -50,7 +50,7 @@ func DecodeDecimal(b []byte) ([]byte, *types.MyDecimal, error) {
 	binSize, err := dec.FromBin(b, precision, frac)
 	b = b[binSize:]
 	if err != nil {
-		return b, nil, errors.Trace(err)
+		return b, nil, precision, frac, errors.Trace(err)
 	}
-	return b, dec, nil
+	return b, dec, precision, frac, nil
 }

util/codec/decimal_test.go

@@ -47,8 +47,17 @@ func (s *testDecimalSuite) TestDecimalCodec(c *C) {
 	for _, input := range inputs {
 		v := types.NewDecFromFloatForTest(input.Input)
 		datum := types.NewDatum(v)
+
 		b := EncodeDecimal([]byte{}, datum.GetMysqlDecimal(), datum.Length(), datum.Frac())
-		_, d, err := DecodeDecimal(b)
+		_, d, prec, frac, err := DecodeDecimal(b)
+		if datum.Length() != 0 {
+			c.Assert(prec, Equals, datum.Length())
+			c.Assert(frac, Equals, datum.Frac())
+		} else {
+			prec1, frac1 := datum.GetMysqlDecimal().PrecisionAndFrac()
+			c.Assert(prec, Equals, prec1)
+			c.Assert(frac, Equals, frac1)
+		}
 		c.Assert(err, IsNil)
 		c.Assert(v.Compare(d), Equals, 0)
 	}
@@ -70,8 +79,9 @@ func (s *testDecimalSuite) TestFrac(c *C) {
 func testFrac(c *C, v *types.MyDecimal) {
 	var d1 types.Datum
 	d1.SetMysqlDecimal(v)
+
 	b := EncodeDecimal([]byte{}, d1.GetMysqlDecimal(), d1.Length(), d1.Frac())
-	_, dec, err := DecodeDecimal(b)
+	_, dec, _, _, err := DecodeDecimal(b)
 	c.Assert(err, IsNil)
 	c.Assert(dec.String(), Equals, v.String())
 }