implement double truncation and find correct hash comparison type

Author: James Cor

enginetest/queries/join_queries.go

@@ -1200,6 +1200,37 @@ var JoinScriptTests = []ScriptTest{
 			},
 		},
 	},
+	{
+		Name:        "HashLookup with type int8 and string type conversions",
+		SetUpScript: []string{
+			"create table t1 (c1 boolean);",
+			"create table t2 (c2 varchar(500));",
+			"insert into t1 values (true), (false);",
+			"insert into t2 values ('abc'), ('def');", // will be converted to float64(0) and match false
+			"insert into t2 values ('1asdf');",        // will be converted to '1' and match true
+			"insert into t2 values ('5five');",        // will be converted to '5' and match nothing
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				// TODO: our warnings don't align with MySQL
+				Query: "select /*+ HASH_JOIN(t1, t2) */ * from t1 join t2 where c1 = c2 order by c1, c2;",
+				Expected: []sql.Row{
+					{0, "abc"},
+					{0, "def"},
+					{1, "1asdf"},
+				},
+			},
+			{
+				// TODO: our warnings don't align with MySQL
+				Query: "select /*+ INNER_JOIN(t1, t2) */ * from t1 join t2 where c1 = c2 order by c1, c2;",
+				Expected: []sql.Row{
+					{0, "abc"},
+					{0, "def"},
+					{1, "1asdf"},
+				},
+			},
+		},
+	},
 }
 
 var LateralJoinScriptTests = []ScriptTest{

sql/errors.go

@@ -947,6 +947,10 @@ var (
 	ErrColumnSpecifiedTwice = errors.NewKind("column '%v' specified twice")
 
 	ErrEnumTypeTruncated = errors.NewKind("new enum type change truncates value")
+
+	// ErrDoubleTypeTruncated is thrown when trying to convert a bad value to a double
+	// TODO: MySQL's exact error message is "Data truncated for column '%s' at row %d"
+	ErrDoubleTypeTruncated = errors.NewKind("data truncated for '%v'")
 )
 
 // CastSQLError returns a *mysql.SQLError with the error code and in some cases, also a SQL state, populated for the

sql/expression/convert.go

@@ -372,6 +372,10 @@ func convertValue(ctx *sql.Context, val interface{}, castTo string, originType s
 		}
 		d, _, err := types.Float64.Convert(ctx, value)
 		if err != nil {
+			if sql.ErrDoubleTypeTruncated.Is(err) {
+				ctx.Warn(1265, err.Error())
+				return d, nil
+			}
 			return types.Float64.Zero(), nil
 		}
 		return d, nil

sql/plan/hash_lookup.go

@@ -34,10 +34,12 @@ import (
 // simply delegates to the child.
 func NewHashLookup(n sql.Node, rightEntryKey sql.Expression, leftProbeKey sql.Expression, joinType JoinType) *HashLookup {
 	leftKeySch := hash.ExprsToSchema(leftProbeKey)
+	compareType := GetCompareType(leftProbeKey.Type(), rightEntryKey.Type())
 	return &HashLookup{
 		UnaryNode:     UnaryNode{n},
 		RightEntryKey: rightEntryKey,
 		LeftProbeKey:  leftProbeKey,
+		CompareType:   compareType,
 		Mutex:         new(sync.Mutex),
 		JoinType:      joinType,
 		leftKeySch:    leftKeySch,
@@ -48,6 +50,7 @@ type HashLookup struct {
 	UnaryNode
 	RightEntryKey sql.Expression
 	LeftProbeKey  sql.Expression
+	CompareType   sql.Type
 	Mutex         *sync.Mutex
 	Lookup        *map[interface{}][]sql.Row
 	leftKeySch    sql.Schema
@@ -58,6 +61,45 @@ var _ sql.Node = (*HashLookup)(nil)
 var _ sql.Expressioner = (*HashLookup)(nil)
 var _ sql.CollationCoercible = (*HashLookup)(nil)
 
+// GetCompareType returns the type to use when comparing values of types left and right.
+func GetCompareType(left, right sql.Type) sql.Type {
+	// TODO: much of this logic is very similar to castLeftAndRight() from sql/expression/comparison.go
+	if left.Equals(right) {
+		return left
+	}
+	if types.IsTuple(left) && types.IsTuple(right) {
+		return left
+	}
+	if types.IsTime(left) || types.IsTime(right) {
+		return types.DatetimeMaxPrecision
+	}
+	if types.IsJSON(left) || types.IsJSON(right) {
+		return types.JSON
+	}
+	if types.IsBinaryType(left) || types.IsBinaryType(right) {
+		return types.LongBlob
+	}
+	if types.IsNumber(left) || types.IsNumber(right) {
+		if types.IsDecimal(left) {
+			return left
+		}
+		if types.IsDecimal(right) {
+			return right
+		}
+		if types.IsFloat(left) || types.IsFloat(right) {
+			return types.Float64
+		}
+		if types.IsSigned(left) && types.IsSigned(right) {
+			return types.Int64
+		}
+		if types.IsUnsigned(left) && types.IsUnsigned(right) {
+			return types.Uint64
+		}
+		return types.Float64
+	}
+	return types.LongText
+}
+
 func (n *HashLookup) Expressions() []sql.Expression {
 	return []sql.Expression{n.RightEntryKey, n.LeftProbeKey}
 }
@@ -113,7 +155,7 @@ func (n *HashLookup) CollationCoercibility(ctx *sql.Context) (collation sql.Coll
 	return sql.GetCoercibility(ctx, n.Child)
 }
 
-// Convert a tuple expression returning []interface{} into something comparable.
+// GetHashKey converts a tuple expression returning []interface{} into something comparable.
 // Fast paths a few smaller slices into fixed size arrays, puts everything else
 // through string serialization and a hash for now. It is OK to hash lossy here
 // as the join condition is still evaluated after the matching rows are returned.
@@ -122,13 +164,13 @@ func (n *HashLookup) GetHashKey(ctx *sql.Context, e sql.Expression, row sql.Row)
 	if err != nil {
 		return nil, err
 	}
-	typ := n.LeftProbeKey.Type()
-	key, _, err = typ.Convert(ctx, key)
+	key, _, err = n.CompareType.Convert(ctx, key)
 	if types.ErrValueNotNil.Is(err) {
 		// The LHS expression was NullType. This is allowed.
 		return nil, nil
 	}
-	if err != nil {
+	if err != nil && !sql.ErrDoubleTypeTruncated.Is(err) {
+		// Truncated warning is already thrown elsewhere.
 		return nil, err
 	}
 	if s, ok := key.([]interface{}); ok {
@@ -139,7 +181,7 @@ func (n *HashLookup) GetHashKey(ctx *sql.Context, e sql.Expression, row sql.Row)
 		return string(k), nil
 	}
 
-	return hash.HashOfSimple(ctx, key, typ)
+	return hash.HashOfSimple(ctx, key, n.CompareType)
 }
 
 func (n *HashLookup) Dispose() {

sql/types/number.go

@@ -1543,7 +1543,7 @@ func convertToFloat64(t NumberTypeImpl_, v interface{}) (float64, error) {
 			// parse the first longest valid numbers
 			s := numre.FindString(v)
 			i, _ = strconv.ParseFloat(s, 64)
-			return i, sql.ErrInvalidValue.New(v, t.String())
+			return i, sql.ErrDoubleTypeTruncated.New(v)
 		}
 		return i, nil
 	case bool: