Fix Scale and length handling in CASE and JOIN bind variables

go/mysql/json/parser.go

@@ -669,6 +669,14 @@ type Value struct {
  n NumberType
 }
 
+func (v *Value) Size() int32 {
+ return 0
+}
+
+func (v *Value) Scale() int32 {
+ return 0
+}
+
 func (v *Value) MarshalDate() string {
  if d, ok := v.Date(); ok {
  return d.ToStdTime(time.Local).Format("2006-01-02")

go/test/endtoend/vtgate/queries/tpch/tpch_test.go

@@ -19,10 +19,10 @@ package union
 import (
  "testing"
 
+ "github.com/stretchr/testify/require"
+
  "vitess.io/vitess/go/test/endtoend/cluster"
  "vitess.io/vitess/go/test/endtoend/utils"
-
- "github.com/stretchr/testify/require"
 )
 
 func start(t *testing.T) (utils.MySQLCompare, func()) {
@@ -161,6 +161,19 @@ group by
 order by
  value desc;`,
  },
+ {
+ name: "Q14 without decimal literal",
+ query: `select sum(case
+ when p_type like 'PROMO%'
+ then l_extendedprice * (1 - l_discount)
+ else 0
+ end) / sum(l_extendedprice * (1 - l_discount)) as promo_revenue
+from lineitem,
+ part
+where l_partkey = p_partkey
+ and l_shipdate >= '1996-12-01'
+ and l_shipdate < date_add('1996-12-01', interval '1' month);`,
+ },
  }
 
  for _, testcase := range testcases {

go/vt/vtgate/engine/join.go

@@ -17,6 +17,7 @@ limitations under the License.
 package engine
 
 import (
+ "bytes"
  "context"
  "fmt"
  "strings"
@@ -61,7 +62,7 @@ func (jn *Join) TryExecute(ctx context.Context, vcursor VCursor, bindVars map[st
  result := &sqltypes.Result{}
  if len(lresult.Rows) == 0 && wantfields {
  for k, col := range jn.Vars {
- joinVars[k] = bindvarForType(lresult.Fields[col].Type)
+ joinVars[k] = bindvarForType(lresult.Fields[col])
  }
  rresult, err := jn.Right.GetFields(ctx, vcursor, combineVars(bindVars, joinVars))
  if err != nil {
@@ -95,19 +96,21 @@ func (jn *Join) TryExecute(ctx context.Context, vcursor VCursor, bindVars map[st
  return result, nil
 }
 
-func bindvarForType(t querypb.Type) *querypb.BindVariable {
+func bindvarForType(field *querypb.Field) *querypb.BindVariable {
  bv := &querypb.BindVariable{
- Type: t,
+ Type: field.Type,
  Value: nil,
  }
- switch t {
+ switch field.Type {
  case querypb.Type_INT8, querypb.Type_UINT8, querypb.Type_INT16, querypb.Type_UINT16,
  querypb.Type_INT32, querypb.Type_UINT32, querypb.Type_INT64, querypb.Type_UINT64:
  bv.Value = []byte("0")
  case querypb.Type_FLOAT32, querypb.Type_FLOAT64:
  bv.Value = []byte("0e0")
  case querypb.Type_DECIMAL:
- bv.Value = []byte("0.0")
+ size := max(1, int(field.ColumnLength-field.Decimals))
+ scale := max(1, int(field.Decimals))
+ bv.Value = append(append(bytes.Repeat([]byte{'0'}, size), byte('.')), bytes.Repeat([]byte{'0'}, scale)...)
  default:
  return sqltypes.NullBindVariable
  }

go/vt/vtgate/evalengine/api_type_aggregation.go

@@ -47,7 +47,8 @@ type typeAggregation struct {
  blob uint16
  total uint16
 
- nullable bool
+ nullable bool
+ scale, size int32
 }
 
 type TypeAggregator struct {
@@ -63,7 +64,7 @@ func (ta *TypeAggregator) Add(typ Type, env *collations.Environment) error {
  return nil
  }
 
- ta.types.addNullable(typ.typ, typ.nullable)
+ ta.types.addNullable(typ.typ, typ.nullable, typ.size, typ.scale)
  if err := ta.collations.add(typedCoercionCollation(typ.typ, typ.collation), env); err != nil {
  return err
  }
@@ -95,20 +96,25 @@ func (ta *typeAggregation) empty() bool {
 func (ta *typeAggregation) addEval(e eval) {
  var t sqltypes.Type
  var f typeFlag
+ var size, scale int32
  switch e := e.(type) {
  case nil:
  t = sqltypes.Null
  ta.nullable = true
  case *evalBytes:
  t = sqltypes.Type(e.tt)
  f = e.flag
+ size = e.Size()
+ scale = e.Scale()
  default:
  t = e.SQLType()
+ size = e.Size()
+ scale = e.Scale()
  }
- ta.add(t, f)
+ ta.add(t, f, size, scale)
 }
 
-func (ta *typeAggregation) addNullable(typ sqltypes.Type, nullable bool) {
+func (ta *typeAggregation) addNullable(typ sqltypes.Type, nullable bool, size, scale int32) {
  var flag typeFlag
  if typ == sqltypes.HexVal || typ == sqltypes.HexNum {
  typ = sqltypes.Binary
@@ -117,13 +123,15 @@ func (ta *typeAggregation) addNullable(typ sqltypes.Type, nullable bool) {
  if nullable {
  flag |= flagNullable
  }
- ta.add(typ, flag)
+ ta.add(typ, flag, size, scale)
 }
 
-func (ta *typeAggregation) add(tt sqltypes.Type, f typeFlag) {
+func (ta *typeAggregation) add(tt sqltypes.Type, f typeFlag, size, scale int32) {
  if f&flagNullable != 0 {
  ta.nullable = true
  }
+ ta.size = max(ta.size, size)
+ ta.scale = max(ta.scale, scale)
  switch tt {
  case sqltypes.Float32, sqltypes.Float64:
  ta.double++

go/vt/vtgate/evalengine/compiler_asm.go

@@ -516,7 +516,7 @@ func (asm *assembler) Cmp_ne_n() {
  }, "CMPFLAG NE [NULL]")
 }
 
-func (asm *assembler) CmpCase(cases int, hasElse bool, tt sqltypes.Type, cc collations.TypedCollation, allowZeroDate bool) {
+func (asm *assembler) CmpCase(cases int, hasElse bool, tt sqltypes.Type, size, scale int32, cc collations.TypedCollation, allowZeroDate bool) {
  elseOffset := 0
  if hasElse {
  elseOffset = 1
@@ -529,12 +529,12 @@ func (asm *assembler) CmpCase(cases int, hasElse bool, tt sqltypes.Type, cc coll
  end := env.vm.sp - elseOffset
  for sp := env.vm.sp - stackDepth; sp < end; sp += 2 {
  if env.vm.stack[sp] != nil && env.vm.stack[sp].(*evalInt64).i != 0 {
- env.vm.stack[env.vm.sp-stackDepth], env.vm.err = evalCoerce(env.vm.stack[sp+1], tt, cc.Collation, env.now, allowZeroDate)
+ env.vm.stack[env.vm.sp-stackDepth], env.vm.err = evalCoerce(env.vm.stack[sp+1], tt, size, scale, cc.Collation, env.now, allowZeroDate)
  goto done
  }
  }
  if elseOffset != 0 {
- env.vm.stack[env.vm.sp-stackDepth], env.vm.err = evalCoerce(env.vm.stack[env.vm.sp-1], tt, cc.Collation, env.now, allowZeroDate)
+ env.vm.stack[env.vm.sp-stackDepth], env.vm.err = evalCoerce(env.vm.stack[env.vm.sp-1], tt, size, scale, cc.Collation, env.now, allowZeroDate)
  } else {
  env.vm.stack[env.vm.sp-stackDepth] = nil
  }

go/vt/vtgate/evalengine/compiler_test.go

@@ -25,6 +25,7 @@ import (
  "time"
 
  "github.com/olekukonko/tablewriter"
+ "github.com/stretchr/testify/require"
 
  "vitess.io/vitess/go/mysql/collations"
  "vitess.io/vitess/go/sqltypes"
@@ -168,6 +169,7 @@ func TestCompilerSingle(t *testing.T) {
  values []sqltypes.Value
  result string
  collation collations.ID
+ typeWanted evalengine.Type
  }{
  {
  expression: "1 + column0",
@@ -675,6 +677,28 @@ func TestCompilerSingle(t *testing.T) {
  expression: `1 * unix_timestamp(time('1.0000'))`,
  result: `DECIMAL(1698098401.0000)`,
  },
+ {
+ expression: `(case
+ when 'PROMOTION' like 'PROMO%'
+ then 0.01
+ else 0
+ end) * 0.01`,
+ result: `DECIMAL(0.0001)`,
+ typeWanted: evalengine.NewTypeEx(sqltypes.Decimal, collations.CollationBinaryID, false, 4, 4, nil),
+ },
+ {
+ expression: `case when true then 0.02 else 1.000 end`,
+ result: `DECIMAL(0.02)`,
+ },
+ {
+ expression: `case
+ when false
+ then timestamp'2023-10-24 12:00:00.123456'
+ else timestamp'2023-10-24 12:00:00'
+ end`,
+ result: `DATETIME("2023-10-24 12:00:00.000000")`,
+ typeWanted: evalengine.NewTypeEx(sqltypes.Datetime, collations.CollationBinaryID, false, 6, 0, nil),
+ },
  }
 
  tz, _ := time.LoadLocation("Europe/Madrid")
@@ -715,6 +739,12 @@ func TestCompilerSingle(t *testing.T) {
  t.Fatalf("bad collation evaluation from eval engine: got %d, want %d", expected.Collation(), tc.collation)
  }
 
+ if tc.typeWanted.Type() != sqltypes.Unknown {
+ typ, err := env.TypeOf(converted)
+ require.NoError(t, err)
+ require.True(t, tc.typeWanted.Equal(&typ))
+ }
+
  // re-run the same evaluation multiple times to ensure results are always consistent
  for i := 0; i < 8; i++ {
  res, err := env.Evaluate(converted)

go/vt/vtgate/evalengine/eval.go

@@ -72,6 +72,8 @@ func (f typeFlag) Nullable() bool {
 type eval interface {
  ToRawBytes() []byte
  SQLType() sqltypes.Type
+ Size() int32
+ Scale() int32
 }
 
 type hashable interface {
@@ -170,7 +172,7 @@ func evalIsTruthy(e eval) boolean {
  }
 }
 
-func evalCoerce(e eval, typ sqltypes.Type, col collations.ID, now time.Time, allowZero bool) (eval, error) {
+func evalCoerce(e eval, typ sqltypes.Type, size, scale int32, col collations.ID, now time.Time, allowZero bool) (eval, error) {
  if e == nil {
  return nil, nil
  }
@@ -181,7 +183,7 @@ func evalCoerce(e eval, typ sqltypes.Type, col collations.ID, now time.Time, all
  // if we have an explicit VARCHAR coercion, always force it so the collation is replaced in the target
  return evalToVarchar(e, col, false)
  }
- if e.SQLType() == typ {
+ if e.SQLType() == typ && e.Size() == size && e.Scale() == scale {
  // nothing to be done here
  return e, nil
  }
@@ -204,9 +206,9 @@ func evalCoerce(e eval, typ sqltypes.Type, col collations.ID, now time.Time, all
  case sqltypes.Date:
  return evalToDate(e, now, allowZero), nil
  case sqltypes.Datetime, sqltypes.Timestamp:
- return evalToDateTime(e, -1, now, allowZero), nil
+ return evalToDateTime(e, int(size), now, allowZero), nil
  case sqltypes.Time:
- return evalToTime(e, -1), nil
+ return evalToTime(e, int(size)), nil
  default:
  return nil, vterrors.Errorf(vtrpcpb.Code_UNIMPLEMENTED, "Unsupported type conversion: %s", typ.String())
  }

go/vt/vtgate/evalengine/eval_bytes.go

@@ -138,6 +138,14 @@ func (e *evalBytes) SQLType() sqltypes.Type {
  return sqltypes.Type(e.tt)
 }
 
+func (e *evalBytes) Size() int32 {
+ return 0
+}
+
+func (e *evalBytes) Scale() int32 {
+ return 0
+}
+
 func (e *evalBytes) ToRawBytes() []byte {
  return e.bytes
 }

go/vt/vtgate/evalengine/eval_enum.go

@@ -26,6 +26,14 @@ func (e *evalEnum) SQLType() sqltypes.Type {
  return sqltypes.Enum
 }
 
+func (e *evalEnum) Size() int32 {
+ return 0
+}
+
+func (e *evalEnum) Scale() int32 {
+ return 0
+}
+
 func valueIdx(values *EnumSetValues, value string) int {
  if values == nil {
  return -1

go/vt/vtgate/evalengine/eval_numeric.go

@@ -366,6 +366,14 @@ func (e *evalInt64) SQLType() sqltypes.Type {
  return sqltypes.Int64
 }
 
+func (e *evalInt64) Size() int32 {
+ return 0
+}
+
+func (e *evalInt64) Scale() int32 {
+ return 0
+}
+
 func (e *evalInt64) ToRawBytes() []byte {
  return strconv.AppendInt(nil, e.i, 10)
 }
@@ -409,6 +417,14 @@ func (e *evalUint64) SQLType() sqltypes.Type {
  return sqltypes.Uint64
 }
 
+func (e *evalUint64) Size() int32 {
+ return 0
+}
+
+func (e *evalUint64) Scale() int32 {
+ return 0
+}
+
 func (e *evalUint64) ToRawBytes() []byte {
  return strconv.AppendUint(nil, e.u, 10)
 }
@@ -452,6 +468,14 @@ func (e *evalFloat) SQLType() sqltypes.Type {
  return sqltypes.Float64
 }
 
+func (e *evalFloat) Size() int32 {
+ return 0
+}
+
+func (e *evalFloat) Scale() int32 {
+ return 0
+}
+
 func (e *evalFloat) ToRawBytes() []byte {
  return format.FormatFloat(e.f)
 }
@@ -528,6 +552,14 @@ func (e *evalDecimal) SQLType() sqltypes.Type {
  return sqltypes.Decimal
 }
 
+func (e *evalDecimal) Size() int32 {
+ return e.length
+}
+
+func (e *evalDecimal) Scale() int32 {
+ return -e.dec.Exponent()
+}
+
 func (e *evalDecimal) ToRawBytes() []byte {
  return e.dec.FormatMySQL(e.length)
 }

go/vt/vtgate/evalengine/eval_set.go

@@ -29,6 +29,14 @@ func (e *evalSet) SQLType() sqltypes.Type {
  return sqltypes.Set
 }
 
+func (e *evalSet) Size() int32 {
+ return 0
+}
+
+func (e *evalSet) Scale() int32 {
+ return 0
+}
+
 func evalSetBits(values *EnumSetValues, value string) uint64 {
  if values != nil && len(*values) > 64 {
  // This never would happen as MySQL limits SET

go/vt/vtgate/evalengine/eval_temporal.go

@@ -42,6 +42,14 @@ func (e *evalTemporal) SQLType() sqltypes.Type {
  return e.t
 }
 
+func (e *evalTemporal) Size() int32 {
+ return int32(e.prec)
+}
+
+func (e *evalTemporal) Scale() int32 {
+ return 0
+}
+
 func (e *evalTemporal) toInt64() int64 {
  switch e.SQLType() {
  case sqltypes.Date: