Store Decimal precision and size while normalising

go/mysql/decimal/decimal.go

@@ -579,14 +579,6 @@ func (d Decimal) Exponent() int32 {
  return d.exp
 }
 
-func (d Decimal) Size() int32 {
- digitsCount := int32(len(d.value.String()))
- if d.value.Sign() == -1 {
- digitsCount--
- }
- return max(digitsCount, -d.exp)
-}
-
 func (d Decimal) Int64() (int64, bool) {
  scaledD := d.rescale(0)
  return scaledD.value.Int64(), scaledD.value.IsInt64()

go/mysql/decimal/decimal_test.go

@@ -28,7 +28,6 @@ import (
  "testing/quick"
 
  "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
 )
 
 type testEnt struct {
@@ -955,48 +954,57 @@ func TestDecimal_ScalesNotEqual(t *testing.T) {
 }
 
 func TestDecimal_Cmp1(t *testing.T) {
+ a := New(123, 3)
+ b := New(-1234, 2)
+ assert.Equal(t, 1, a.Cmp(b))
+}
+
+func TestSizeAndScaleFromString(t *testing.T) {
  testcases := []struct {
- value string
- sizeExpected int32
+ value string
+ sizeExpected int32
+ scaleExpected int32
  }{
  {
- value: "0.00003",
- sizeExpected: 5,
+ value: "0.00003",
+ sizeExpected: 6,
+ scaleExpected: 5,
  },
  {
- value: "-0.00003",
- sizeExpected: 5,
+ value: "-0.00003",
+ sizeExpected: 6,
+ scaleExpected: 5,
  },
  {
- value: "12.00003",
- sizeExpected: 7,
+ value: "12.00003",
+ sizeExpected: 7,
+ scaleExpected: 5,
  },
  {
- value: "-12.00003",
- sizeExpected: 7,
+ value: "-12.00003",
+ sizeExpected: 7,
+ scaleExpected: 5,
  },
  {
- value: "1000003",
- sizeExpected: 7,
+ value: "1000003",
+ sizeExpected: 7,
+ scaleExpected: 0,
  },
  {
- value: "-1000003",
- sizeExpected: 7,
+ value: "-1000003",
+ sizeExpected: 7,
+ scaleExpected: 0,
  },
  }
  for _, testcase := range testcases {
  t.Run(testcase.value, func(t *testing.T) {
- val, err := NewFromString(testcase.value)
- require.NoError(t, err)
- assert.EqualValues(t, testcase.sizeExpected, val.Size())
+ siz, scale := SizeAndScaleFromString(testcase.value)
+ assert.EqualValues(t, testcase.sizeExpected, siz)
+ assert.EqualValues(t, testcase.scaleExpected, scale)
  })
  }
 }
 
-func TestDecimal_Size(t *testing.T) {
-
-}
-
 func TestDecimal_Cmp2(t *testing.T) {
  a := New(123, 3)
  b := New(1234, 2)

go/mysql/decimal/scan.go

@@ -23,6 +23,7 @@ import (
  "math"
  "math/big"
  "math/bits"
+ "strings"
 
  "vitess.io/vitess/go/mysql/fastparse"
 )
@@ -71,6 +72,21 @@ func parseDecimal64(s []byte) (Decimal, error) {
  }, nil
 }
 
+// SizeAndScaleFromString
+func SizeAndScaleFromString(s string) (int32, int32) {
+ sign := 0
+ switch s[0] {
+ case '+', '-':
+ sign = 1
+ }
+ lenWithoutSign := len(s) - sign
+ idx := strings.Index(s, ".")
+ if idx == -1 {
+ return int32(lenWithoutSign), 0
+ }
+ return int32(lenWithoutSign - 1), int32(len(s) - 1 - idx)
+}
+
 func NewFromMySQL(s []byte) (Decimal, error) {
  var original = s
  var neg bool

go/vt/sqlparser/ast_format.go

@@ -1361,7 +1361,7 @@ func (node *Argument) Format(buf *TrackedBuffer) {
  if node.Size != 0 || node.Scale != 0 {
  buf.astPrintf(node, "(%d", node.Size)
  if node.Scale != 0 {
- buf.astPrintf(node, ", %d", node.Scale)
+ buf.astPrintf(node, ",%d", node.Scale)
  }
  buf.WriteString(")")
  }

go/vt/sqlparser/ast_funcs.go

@@ -567,12 +567,9 @@ func NewTypedArgumentFromLiteral(in string, lit *Literal) (*Argument, error) {
  arg := &Argument{Name: in, Type: lit.SQLType()}
  switch arg.Type {
  case sqltypes.Decimal:
- dec, err := decimal.NewFromMySQL(lit.Bytes())
- if err != nil {
- return nil, err
- }
- arg.Scale = -dec.Exponent()
- arg.Size = dec.Size()
+ siz, scale := decimal.SizeAndScaleFromString(lit.Val)
+ arg.Scale = scale
+ arg.Size = siz
  }
  return arg, nil
 }

go/vt/sqlparser/normalizer.go

@@ -210,6 +210,7 @@ func (nz *normalizer) convertLiteralDedup(node *Literal, cursor *Cursor) {
  arg, err := NewTypedArgumentFromLiteral(bvname, node)
  if err != nil {
  nz.err = err
+ return
  }
  cursor.Replace(arg)
 }
@@ -231,6 +232,7 @@ func (nz *normalizer) convertLiteral(node *Literal, cursor *Cursor) {
  arg, err := NewTypedArgumentFromLiteral(bvname, node)
  if err != nil {
  nz.err = err
+ return
  }
  cursor.Replace(arg)
 }
@@ -279,6 +281,7 @@ func (nz *normalizer) parameterize(left, right Expr) Expr {
  arg, err := NewTypedArgumentFromLiteral(bvname, lit)
  if err != nil {
  nz.err = err
+ return nil
  }
  return arg
 }

go/vt/sqlparser/normalizer_test.go

@@ -75,14 +75,14 @@ func TestNormalize(t *testing.T) {
  }, {
  // float val
  in: "select * from t where foobar = 1.2",
- outstmt: "select * from t where foobar = :foobar /* DECIMAL(2, 1) */",
+ outstmt: "select * from t where foobar = :foobar /* DECIMAL(2,1) */",
  outbv: map[string]*querypb.BindVariable{
  "foobar": sqltypes.DecimalBindVariable("1.2"),
  },
  }, {
  // multiple vals
  in: "select * from t where foo = 1.2 and bar = 2",
- outstmt: "select * from t where foo = :foo /* DECIMAL(2, 1) */ and bar = :bar /* INT64 */",
+ outstmt: "select * from t where foo = :foo /* DECIMAL(2,1) */ and bar = :bar /* INT64 */",
  outbv: map[string]*querypb.BindVariable{
  "foo": sqltypes.DecimalBindVariable("1.2"),
  "bar": sqltypes.Int64BindVariable(2),

go/vt/vtgate/semantics/typer.go

@@ -47,7 +47,7 @@ func (t *typer) up(cursor *sqlparser.Cursor) error {
  t.m[node] = evalengine.NewType(node.SQLType(), collations.CollationForType(node.SQLType(), t.collationEnv.DefaultConnectionCharset()))
  case *sqlparser.Argument:
  if node.Type >= 0 {
- t.m[node] = evalengine.NewTypeEx(node.Type, collations.CollationForType(node.Type, t.collationEnv.DefaultConnectionCharset()), true, node.Size, node.Scale)
+ t.m[node] = evalengine.NewTypeEx(node.Type, collations.CollationForType(node.Type, t.collationEnv.DefaultConnectionCharset()), true, node.Size, node.Scale, nil)
  }
  case sqlparser.AggrFunc:
  code, ok := opcode.SupportedAggregates[node.AggrName()]