fix and test

Author: James Cor

enginetest/queries/script_queries.go

@@ -590,7 +590,7 @@ FROM task_instance INNER JOIN job ON job.id = task_instance.queued_by_job_id INN
 			{
 				Query:                           "SELECT '123abc' in ('string', 1, 2, 123);",
 				Expected:                        []sql.Row{{true}},
-				ExpectedWarningsCount:           2, // MySQL only throws 1 warning
+				ExpectedWarningsCount:           3, // MySQL only throws 1 warning
 				ExpectedWarning:                 mysql.ERTruncatedWrongValue,
 				ExpectedWarningMessageSubstring: "Truncated incorrect double value",
 			},
@@ -642,7 +642,7 @@ FROM task_instance INNER JOIN job ON job.id = task_instance.queued_by_job_id INN
 				Expected:                        []sql.Row{{true}},
 				ExpectedWarningsCount:           1,
 				ExpectedWarning:                 mysql.ERTruncatedWrongValue,
-				ExpectedWarningMessageSubstring: "Truncated incorrect double value: 123.456ABC",
+				ExpectedWarningMessageSubstring: "Truncated incorrect decimal(65,30) value: 123.456ABC",
 			},
 			{
 				Query:    "SELECT '123.456e2' in (12345.6);",
@@ -7356,9 +7356,15 @@ CREATE TABLE tab3 (
 				},
 			},
 			{
+				// This actually matches MySQL behavior
+				Query:    "select * from t where (f in (null, 0.8));",
+				Expected: []sql.Row{},
+			},
+			{
+				// This actually matches MySQL behavior
 				Query: "select count(*) from t where (f in (null, 0.8));",
 				Expected: []sql.Row{
-					{1},
+					{0},
 				},
 			},
 			{

sql/analyzer/apply_hash_in.go

@@ -19,6 +19,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/plan"
 	"github.com/dolthub/go-mysql-server/sql/transform"
+	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
 func applyHashIn(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, sel RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
@@ -29,9 +30,7 @@ func applyHashIn(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, s
 		}
 
 		e, same, err := transform.Expr(filter.Expression, func(expr sql.Expression) (sql.Expression, transform.TreeIdentity, error) {
-			if e, ok := expr.(*expression.InTuple); ok &&
-				hasSingleOutput(e.Left()) &&
-				isStatic(e.Right()) {
+			if e, ok := expr.(*expression.InTuple); ok && hasSingleOutput(e.Left()) && isStatic(e.Right()) && isConsistentType(e.Right()) {
 				newe, err := expression.NewHashInTuple(ctx, e.Left(), e.Right())
 				if err != nil {
 					return nil, transform.SameTree, err
@@ -77,3 +76,24 @@ func isStatic(e sql.Expression) bool {
 		}
 	})
 }
+
+func isConsistentType(expr sql.Expression) bool {
+	tup, isTup := expr.(expression.Tuple)
+	if !isTup {
+		return true
+	}
+	var hasNumeric, hasString, hasTime bool
+	for _, elem := range tup {
+		eType := elem.Type()
+		if types.IsNumber(eType) {
+			hasNumeric = true
+		} else if types.IsText(eType) {
+			hasString = true
+		} else if types.IsTime(eType) {
+			hasTime = true
+		}
+	}
+	// if there is a mixture of types, we cannot use hash
+	// must have exactly one true
+	return !((hasNumeric && hasString) || (hasNumeric && hasTime) || (hasString && hasTime))
+}

sql/expression/in.go

@@ -17,8 +17,6 @@ package expression
 import (
 	"fmt"
 
-	"github.com/dolthub/vitess/go/mysql"
-
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/hash"
 	"github.com/dolthub/go-mysql-server/sql/types"
@@ -130,58 +128,59 @@ func validateAndEvalRightTuple(ctx *sql.Context, lType sql.Type, right Tuple, ro
 
 // Eval implements the Expression interface.
 func (in *InTuple) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
-	leftVal, err := in.Left().Eval(ctx, row)
+	lVal, err := in.Left().Eval(ctx, row)
 	if err != nil {
 		return nil, err
 	}
-	if leftVal == nil {
+	if lVal == nil {
 		return nil, nil
 	}
 
+	lType := in.Left().Type()
+	lColCount := types.NumColumns(lType)
+	lLit := NewLiteral(lVal, lType)
+
 	right, isTuple := in.Right().(Tuple)
 	if !isTuple {
 		return nil, ErrUnsupportedInOperand.New(right)
 	}
 
-	lType := in.Left().Type()
-	rVals, cmpType, rHasNull, err := validateAndEvalRightTuple(ctx, lType, right, row)
-	if err != nil {
-		return nil, err
-	}
+	var rHasNull bool
+	for _, el := range right {
+		rType := el.Type()
+		if rType == types.Null {
+			rHasNull = true
+			continue
+		}
 
-	lv, _, lErr := cmpType.Convert(ctx, leftVal)
-	if lErr != nil {
-		if sql.ErrTruncatedIncorrect.Is(lErr) {
-			ctx.Warn(mysql.ERTruncatedWrongValue, "%s", lErr.Error())
-		} else {
-			lv = cmpType.Zero()
+		// Nested tuples must have the same number of columns
+		rColCount := types.NumColumns(rType)
+		if rColCount != lColCount {
+			return nil, sql.ErrInvalidOperandColumns.New(lColCount, rColCount)
 		}
-	}
 
-	for _, rVal := range rVals {
+		rVal, rErr := el.Eval(ctx, row)
+		if rErr != nil {
+			return nil, rErr
+		}
 		if rVal == nil {
+			rHasNull = true
 			continue
 		}
-		rv, _, rErr := cmpType.Convert(ctx, rVal)
-		if rErr != nil {
-			if sql.ErrTruncatedIncorrect.Is(rErr) {
-				ctx.Warn(mysql.ERTruncatedWrongValue, "%s", rErr.Error())
-			} else {
-				rv = cmpType.Zero()
-			}
-		}
-		cmp, cErr := cmpType.Compare(ctx, lv, rv)
+
+		cmpExpr := newComparison(lLit, NewLiteral(rVal, rType))
+		res, cErr := cmpExpr.Compare(ctx, nil)
 		if cErr != nil {
-			continue
+			return nil, cErr
 		}
-		if cmp == 0 {
+		if res == 0 {
 			return true, nil
 		}
 	}
+
 	if rHasNull {
 		return nil, nil
 	}
-
 	return false, nil
 }
 
@@ -258,16 +257,45 @@ func newInMap(ctx *sql.Context, lType sql.Type, right Tuple) (map[uint64]struct{
 	if lType == types.Null {
 		return nil, nil, true, nil
 	}
+	lColCount := types.NumColumns(lType)
 	if len(right) == 0 {
 		return nil, nil, false, nil
 	}
-	rVals, cmpType, rHasNull, err := validateAndEvalRightTuple(ctx, lType, right, nil)
-	if err != nil {
-		return nil, nil, false, err
+	// only non-nil elements are included
+	rVals := make([]any, 0, len(right))
+	var rHasNull bool
+	for _, el := range right {
+		rType := el.Type()
+		rColCount := types.NumColumns(rType)
+		if lColCount != rColCount {
+			return nil, nil, false, sql.ErrInvalidOperandColumns.New(lColCount, rColCount)
+		}
+		if rType == types.Null {
+			rHasNull = true
+			continue
+		}
+		rVal, err := el.Eval(ctx, nil)
+		if err != nil {
+			return nil, nil, false, err
+		}
+		if rVal == nil {
+			rHasNull = true
+			continue
+		}
+		rVals = append(rVals, rVal)
 	}
-	elements := make(map[uint64]struct{})
-	for _, v := range rVals {
-		key, hErr := hash.HashOfSimple(ctx, v, cmpType)
+
+	var cmpType sql.Type
+	if types.IsEnum(lType) || types.IsSet(lType) {
+		cmpType = lType
+	} else {
+		// If we've made it this far, we are guaranteed that the right Tuple has a consistent set of types
+		// (all numeric, string, or time), so it is enough to just compare against the first element of the right Tuple
+		cmpType = types.GetCompareType(lType, right[0].Type())
+	}
+	elements := map[uint64]struct{}{}
+	for _, rVal := range rVals {
+		key, hErr := hash.HashOfSimple(ctx, rVal, cmpType)
 		if hErr != nil {
 			return nil, nil, false, hErr
 		}