limiting scope of changes

Author: James Cor

sql/expression/comparison.go

@@ -190,6 +190,7 @@ func (c *comparison) CompareValue(ctx *sql.Context, row sql.ValueRow) (int, erro
 		}
 		return types.Float64.(sql.ValueType).CompareValue(ctx, lv, rv)
 	}
+
 	return lTyp.CompareValue(ctx, lv, rv)
 }
 
@@ -203,10 +204,8 @@ func (c *comparison) IsValueExpression() bool {
 	if !ok {
 		return false
 	}
-	if _, ok := c.LeftChild.Type().(sql.ValueType); !ok {
-		return false
-	}
-	if _, ok := c.RightChild.Type().(sql.ValueType); !ok {
+	// TODO: only allow comparisons between Integers, Floats, Decimals, Bits and Year for now
+	if !types.IsNumber(c.LeftChild.Type()) || !types.IsNumber(c.RightChild.Type()) {
 		return false
 	}
 	return l.IsValueExpression() && r.IsValueExpression()

sql/types/datetime.go

@@ -191,25 +191,7 @@ func (t datetimeType) Compare(ctx context.Context, a interface{}, b interface{})
 
 // CompareValue implements the ValueType interface
 func (t datetimeType) CompareValue(ctx *sql.Context, a, b sql.Value) (int, error) {
-	if hasNulls, res := CompareNullValues(a, b); hasNulls {
-		return res, nil
-	}
-	at, err := ConvertValueToDatetime(ctx, a)
-	if err != nil {
-		return 0, err
-	}
-	bt, err := ConvertValueToDatetime(ctx, b)
-	if err != nil {
-		return 0, err
-	}
-	switch {
-	case at.Before(bt):
-		return -1, nil
-	case at.After(bt):
-		return 1, nil
-	default:
-		return 0, nil
-	}
+	panic("TODO: implement CompareValue for DatetimeType")
 }
 
 // Convert implements Type interface.
@@ -591,116 +573,3 @@ func ValidateTimestamp(t time.Time) interface{} {
 	}
 	return t
 }
-
-func ConvertValueToDatetime(ctx *sql.Context, v sql.Value) (time.Time, error) {
-	switch v.Typ {
-	case sqltypes.Int8:
-		x := values.ReadInt8(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Int16:
-		x := values.ReadInt16(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Int24:
-		x := values.ReadInt24(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Int32:
-		x := values.ReadInt32(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Int64:
-		x := values.ReadInt64(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Uint8:
-		x := values.ReadUint8(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Uint16:
-		x := values.ReadUint16(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Uint24:
-		x := values.ReadUint24(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Uint32:
-		x := values.ReadUint32(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Uint64:
-		x := values.ReadUint64(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Float32:
-		x := values.ReadFloat32(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Float64:
-		x := values.ReadFloat64(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Decimal:
-		x := values.ReadDecimal(v.Val)
-		if x.IsZero() {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Year:
-		return zeroTime, nil
-	case sqltypes.Date:
-		x := values.ReadDate(v.Val)
-		return x, nil
-	case sqltypes.Time:
-		x := values.ReadInt64(v.Val)
-		if x == 0 {
-			return zeroTime, nil
-		}
-		return zeroTime, ErrConvertingToTime.New(x)
-	case sqltypes.Datetime, sqltypes.Timestamp:
-		x := values.ReadDatetime(v.Val)
-		return x, nil
-	case sqltypes.Text, sqltypes.Blob:
-		var err error
-		if v.Val == nil {
-			v.Val, err = v.WrappedVal.Unwrap(ctx)
-			if err != nil {
-				return zeroTime, err
-			}
-		}
-		val := values.ReadString(v.Val)
-		res, parsed, err := parseDatetime(val)
-		if !parsed {
-			return zeroTime, ErrConvertingToTime.New(v)
-		}
-		return res, err
-	default:
-		return zeroTime, sql.ErrInvalidBaseType.New(v.Typ.String(), "datetime")
-	}
-}

sql/types/enum.go

@@ -158,6 +158,11 @@ func (t EnumType) Compare(ctx context.Context, a interface{}, b interface{}) (in
 	return 0, nil
 }
 
+// CompareValue implements the ValueType interface
+func (t EnumType) CompareValue(ctx *sql.Context, a, b sql.Value) (int, error) {
+	panic("TODO: implement CompareValue for EnumType")
+}
+
 // Convert implements Type interface.
 func (t EnumType) Convert(ctx context.Context, v interface{}) (interface{}, sql.ConvertInRange, error) {
 	if v == nil {

sql/types/number.go

@@ -1126,6 +1126,12 @@ func ConvertValueToInt64(ctx *sql.Context, v sql.Value) (int64, error) {
 			return math.MinInt64, nil
 		}
 		return v.Round(0).IntPart(), nil
+	case sqltypes.Bit:
+		v := values.ReadUint64(v.Val)
+		if v > math.MaxInt64 {
+			return math.MaxInt64, nil
+		}
+		return int64(v), nil
 	case sqltypes.Year:
 		v := values.ReadUint16(v.Val)
 		return int64(v), nil
@@ -1216,6 +1222,8 @@ func ConvertValueToUint64(ctx *sql.Context, v sql.Value) (uint64, error) {
 			return uint64(math.Round(ret)), nil
 		}
 		return uint64(v.Round(0).IntPart()), nil
+	case sqltypes.Bit:
+		return values.ReadUint64(v.Val), nil
 	case sqltypes.Year:
 		v := values.ReadUint16(v.Val)
 		return uint64(v), nil