a ton of conversions

Author: James Cor

sql/expression/comparison.go

@@ -17,7 +17,6 @@ package expression
 import (
 	"fmt"
 
-	"github.com/dolthub/vitess/go/sqltypes"
 	"gopkg.in/src-d/go-errors.v1"
 
 	"github.com/dolthub/go-mysql-server/sql"
@@ -158,6 +157,59 @@ func (c *comparison) Compare(ctx *sql.Context, row sql.Row) (int, error) {
 	return compareType.Compare(ctx, l, r)
 }
 
+// CompareValue the two given values using the types of the expressions in the comparison.
+func (c *comparison) CompareValue(ctx *sql.Context, row sql.ValueRow) (int, error) {
+	// TODO: avoid type assertions
+	lv, err := c.LeftChild.(sql.ValueExpression).EvalValue(ctx, row)
+	if err != nil {
+		return 0, err
+	}
+	rv, err := c.RightChild.(sql.ValueExpression).EvalValue(ctx, row)
+	if err != nil {
+		return 0, err
+	}
+
+	if lv.IsNull() || rv.IsNull() {
+		return 0, nil
+	}
+
+	lTyp, rTyp := c.LeftChild.Type().(sql.ValueType), c.RightChild.Type().(sql.ValueType)
+	if types.TypesEqual(lTyp, rTyp) {
+		return lTyp.(sql.ValueType).CompareValue(ctx, lv, rv)
+	}
+
+	// TODO: enums
+
+	// TODO: sets
+
+	if types.IsNumber(lTyp) || types.IsNumber(rTyp) {
+		if types.IsUnsigned(lTyp) && types.IsUnsigned(rTyp) {
+			return types.Uint64.(sql.ValueType).CompareValue(ctx, lv, rv)
+		}
+		if types.IsSigned(lTyp) && types.IsSigned(rTyp) {
+			return types.Int64.(sql.ValueType).CompareValue(ctx, lv, rv)
+		}
+		if types.IsDecimal(lTyp) || types.IsDecimal(rTyp) {
+			return types.InternalDecimalType.(sql.ValueType).CompareValue(ctx, lv, rv)
+		}
+		return types.Float64.(sql.ValueType).CompareValue(ctx, lv, rv)
+	}
+	return lTyp.CompareValue(ctx, lv, rv)
+}
+
+// IsValueExpression returns whether every child supports sql.ValueExpression
+func (c *comparison) IsValueExpression() bool {
+	l, ok := c.LeftChild.(sql.ValueExpression)
+	if !ok {
+		return false
+	}
+	r, ok := c.RightChild.(sql.ValueExpression)
+	if !ok {
+		return false
+	}
+	return l.IsValueExpression() && r.IsValueExpression()
+}
+
 func (c *comparison) evalLeftAndRight(ctx *sql.Context, row sql.Row) (interface{}, interface{}, error) {
 	left, err := c.Left().Eval(ctx, row)
 	if err != nil {
@@ -520,71 +572,6 @@ func (gt *GreaterThan) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 	return result == 1, nil
 }
 
-// EvalValue implements the sql.ValueExpression interface.
-func (gt *GreaterThan) EvalValue(ctx *sql.Context, row sql.ValueRow) (sql.Value, error) {
-	lv, err := gt.comparison.LeftChild.(sql.ValueExpression).EvalValue(ctx, row)
-	if err != nil {
-		return sql.Value{}, err
-	}
-	rv, err := gt.comparison.RightChild.(sql.ValueExpression).EvalValue(ctx, row)
-	if err != nil {
-		return sql.Value{}, err
-	}
-
-	// TODO: move this logic into comparison
-	var cmp byte
-	if sqltypes.IsUnsigned(lv.Typ) && sqltypes.IsUnsigned(rv.Typ) {
-		l, cErr := types.ConvertValueToUint64(lv)
-		if cErr != nil {
-			return sql.Value{}, cErr
-		}
-		r, cErr := types.ConvertValueToUint64(rv)
-		if cErr != nil {
-			return sql.Value{}, cErr
-		}
-		if l > r {
-			cmp = 1
-		}
-	} else {
-		l, cErr := types.ConvertValueToInt64(lv)
-		if cErr != nil {
-			return sql.Value{}, cErr
-		}
-		r, cErr := types.ConvertValueToInt64(rv)
-		if cErr != nil {
-			return sql.Value{}, cErr
-		}
-		if l > r {
-			cmp = 1
-		}
-	}
-
-	res := sql.Value{
-		Val: []byte{cmp},
-		Typ: sqltypes.Int8,
-	}
-	return res, nil
-}
-
-// IsValueRowIter implements the ValueExpression interface.
-func (gt *GreaterThan) IsValueExpression() bool {
-	l, ok := gt.comparison.LeftChild.(sql.ValueExpression)
-	if !ok {
-		return false
-	}
-	if !l.IsValueExpression() {
-		return false
-	}
-	r, ok := gt.comparison.RightChild.(sql.ValueExpression)
-	if !ok {
-		return false
-	}
-	if !r.IsValueExpression() {
-		return false
-	}
-	return true
-}
-
 // WithChildren implements the Expression interface.
 func (gt *GreaterThan) WithChildren(children ...sql.Expression) (sql.Expression, error) {
 	if len(children) != 2 {
@@ -605,6 +592,23 @@ func (gt *GreaterThan) DebugString() string {
 	return pr.String()
 }
 
+// EvalValue implements the sql.ValueExpression interface.
+func (gt *GreaterThan) EvalValue(ctx *sql.Context, row sql.ValueRow) (sql.Value, error) {
+	cmp, err := gt.CompareValue(ctx, row)
+	if err != nil {
+		return sql.NullValue, err
+	}
+	if cmp != 1 {
+		return sql.FalseValue, nil
+	}
+	return sql.TrueValue, nil
+}
+
+// IsValueExpression implements the ValueExpression interface.
+func (gt *GreaterThan) IsValueExpression() bool {
+	return gt.comparison.IsValueExpression()
+}
+
 // LessThan is a comparison that checks an expression is less than another.
 type LessThan struct {
 	comparison
@@ -630,10 +634,8 @@ func (lt *LessThan) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		if ErrNilOperand.Is(err) {
 			return nil, nil
 		}
-
 		return nil, err
 	}
-
 	return result == -1, nil
 }
 
@@ -657,6 +659,23 @@ func (lt *LessThan) DebugString() string {
 	return pr.String()
 }
 
+// EvalValue implements the sql.ValueExpression interface.
+func (lt *LessThan) EvalValue(ctx *sql.Context, row sql.ValueRow) (sql.Value, error) {
+	cmp, err := lt.CompareValue(ctx, row)
+	if err != nil {
+		return sql.NullValue, err
+	}
+	if cmp != -1 {
+		return sql.FalseValue, nil
+	}
+	return sql.TrueValue, nil
+}
+
+// IsValueExpression implements the ValueExpression interface.
+func (lt *LessThan) IsValueExpression() bool {
+	return lt.comparison.IsValueExpression()
+}
+
 // GreaterThanOrEqual is a comparison that checks an expression is greater or equal to
 // another.
 type GreaterThanOrEqual struct {
@@ -683,10 +702,8 @@ func (gte *GreaterThanOrEqual) Eval(ctx *sql.Context, row sql.Row) (interface{},
 		if ErrNilOperand.Is(err) {
 			return nil, nil
 		}
-
 		return nil, err
 	}
-
 	return result > -1, nil
 }
 
@@ -710,6 +727,23 @@ func (gte *GreaterThanOrEqual) DebugString() string {
 	return pr.String()
 }
 
+// EvalValue implements the sql.ValueExpression interface.
+func (gte *GreaterThanOrEqual) EvalValue(ctx *sql.Context, row sql.ValueRow) (sql.Value, error) {
+	cmp, err := gte.CompareValue(ctx, row)
+	if err != nil {
+		return sql.NullValue, err
+	}
+	if cmp == -1 {
+		return sql.FalseValue, nil
+	}
+	return sql.TrueValue, nil
+}
+
+// IsValueExpression implements the ValueExpression interface.
+func (gte *GreaterThanOrEqual) IsValueExpression() bool {
+	return gte.comparison.IsValueExpression()
+}
+
 // LessThanOrEqual is a comparison that checks an expression is equal or lower than
 // another.
 type LessThanOrEqual struct {
@@ -763,6 +797,23 @@ func (lte *LessThanOrEqual) DebugString() string {
 	return pr.String()
 }
 
+// EvalValue implements the sql.ValueExpression interface.
+func (lte *LessThanOrEqual) EvalValue(ctx *sql.Context, row sql.ValueRow) (sql.Value, error) {
+	cmp, err := lte.CompareValue(ctx, row)
+	if err != nil {
+		return sql.NullValue, err
+	}
+	if cmp == 1 {
+		return sql.FalseValue, nil
+	}
+	return sql.TrueValue, nil
+}
+
+// IsValueExpression implements the ValueExpression interface.
+func (lte *LessThanOrEqual) IsValueExpression() bool {
+	return lte.comparison.IsValueExpression()
+}
+
 var (
 	// ErrUnsupportedInOperand is returned when there is an invalid righthand
 	// operand in an IN operator.

sql/type.go

@@ -108,6 +108,9 @@ type Type interface {
 // ValueType is an extension of the Type interface, that operates over sql.Values.
 type ValueType interface {
 	Type
+	// CompareValue returns an integer comparing two sql.Values.
+	// The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
+	CompareValue(*Context, Value, Value) (int, error)
 	// SQLValue returns the sqltypes.Value for the given sql.Value.
 	// Implementations can optionally use |dest| to append
 	// serialized data, but should not mutate existing data.

sql/types/bit.go

@@ -103,6 +103,31 @@ func (t BitType_) Compare(ctx context.Context, a interface{}, b interface{}) (in
 	return 0, nil
 }
 
+// CompareValue implements the ValueType interface
+func (t BitType_) CompareValue(ctx *sql.Context, a, b sql.Value) (int, error) {
+	if hasNulls, res := CompareNullValues(a, b); hasNulls {
+		return res, nil
+	}
+
+	av, err := ConvertValueToUint64(ctx, a)
+	if err != nil {
+		return 0, err
+	}
+	bv, err := ConvertValueToUint64(ctx, b)
+	if err != nil {
+		return 0, err
+	}
+
+	switch {
+	case av < bv:
+		return -1, nil
+	case av > bv:
+		return 1, nil
+	default:
+		return 0, nil
+	}
+}
+
 // Convert implements Type interface.
 func (t BitType_) Convert(ctx context.Context, v interface{}) (interface{}, sql.ConvertInRange, error) {
 	if v == nil {
@@ -211,7 +236,7 @@ func (t BitType_) SQL(ctx *sql.Context, dest []byte, v interface{}) (sqltypes.Va
 	return sqltypes.MakeTrusted(sqltypes.Bit, val), nil
 }
 
-// ToSQLValue implements ValueType interface.
+// SQLValue implements ValueType interface.
 func (t BitType_) SQLValue(ctx *sql.Context, v sql.Value, dest []byte) (sqltypes.Value, error) {
 	if v.IsNull() {
 		return sqltypes.NULL, nil

sql/types/conversion.go

@@ -472,6 +472,24 @@ func CompareNulls(a interface{}, b interface{}) (bool, int) {
 	return false, 0
 }
 
+// CompareNullValues compares two sql.Values, and returns true if either is null.
+// The returned integer represents the ordering, with a rule that states nulls
+// as being ordered before non-nulls.
+func CompareNullValues(a, b sql.Value) (bool, int) {
+	aIsNull := a.IsNull()
+	bIsNull := b.IsNull()
+	switch {
+	case aIsNull && bIsNull:
+		return true, 0
+	case aIsNull && !bIsNull:
+		return false, 1
+	case !aIsNull && bIsNull:
+		return false, -1
+	default:
+		return false, 0
+	}
+}
+
 // NumColumns returns the number of columns in a type. This is one for all
 // types, except tuples.
 func NumColumns(t sql.Type) int {