updated tests

Author: angelamayxie

enginetest/queries/integration_plans.go

@@ -6092,7 +6092,7 @@ SELECT * FROM cte WHERE  d = 2;`,
 		Query:    `SELECT if(123 = 123, NULL, NULL = 1)`,
 		Expected: []sql.Row{{nil}},
 		ExpectedColumns: []*sql.Column{
-			{Name: "if(123 = 123, NULL, NULL = 1)", Type: types.Int64}, // TODO: this should be getting coerced to bool
+			{Name: "if(123 = 123, NULL, NULL = 1)", Type: types.Boolean},
 		},
 	},
 	{

enginetest/queries/queries.go

@@ -161,8 +161,8 @@ func TestCaseType(t *testing.T) {
 		}
 	}
 
-	decimalType := types.MustCreateDecimalType(65, 10)
-
+	decimalType := types.MustCreateDecimalType(types.DecimalTypeMaxPrecision, types.DecimalTypeMaxScale)
+	uint64DecimalType := types.MustCreateDecimalType(types.DecimalTypeMaxPrecision, 0)
 	testCases := []struct {
 		name string
 		c    *Case
@@ -175,13 +175,13 @@ func TestCaseType(t *testing.T) {
 		},
 		{
 			"unsigned promoted and unsigned",
-			caseExpr(NewLiteral(uint32(0), types.Uint32), NewLiteral(uint32(1), types.Uint32)),
+			caseExpr(NewLiteral(uint32(0), types.Uint32), NewLiteral(uint32(1), types.Uint64)),
 			types.Uint64,
 		},
 		{
 			"signed promoted and signed",
 			caseExpr(NewLiteral(int8(0), types.Int8), NewLiteral(int32(1), types.Int32)),
-			types.Int64,
+			types.Int32,
 		},
 		{
 			"int and float to float",
@@ -216,7 +216,7 @@ func TestCaseType(t *testing.T) {
 		{
 			"uint64 and int8 to decimal",
 			caseExpr(NewLiteral(uint64(10), types.Uint64), NewLiteral(int8(0), types.Int8)),
-			decimalType,
+			uint64DecimalType,
 		},
 		{
 			"int and text to text",

sql/expression/case_test.go

@@ -557,12 +557,10 @@ func TypesEqual(a, b sql.Type) bool {
 
 // generalizeNumberTypes assumes both inputs return true for IsNumber
 func generalizeNumberTypes(a, b sql.Type) sql.Type {
-	if a == Float64 || b == Float64 {
+	if IsFloat(a) || IsFloat(b) {
+		// TODO: handle cases where MySQL returns Float32
 		return Float64
 	}
-	if a == Float32 || b == Float32 {
-		return Float32
-	}
 
 	if IsDecimal(a) || IsDecimal(b) {
 		// TODO: match precision and scale to that of the decimal type, check if defines column
@@ -598,6 +596,7 @@ func generalizeNumberTypes(a, b sql.Type) sql.Type {
 		if aIsSigned || bIsSigned {
 			return Int32
 		}
+		return Uint24
 	}
 
 	if a == Int24 || b == Int24 {
@@ -644,6 +643,13 @@ func GeneralizeTypes(a, b sql.Type) sql.Type {
 		return a
 	}
 
+	if svt, ok := a.(sql.SystemVariableType); ok {
+		a = svt.UnderlyingType()
+	}
+	if svt, ok := a.(sql.SystemVariableType); ok {
+		b = svt.UnderlyingType()
+	}
+
 	if IsJSON(a) && IsJSON(b) {
 		return JSON
 	}
@@ -663,7 +669,7 @@ func GeneralizeTypes(a, b sql.Type) sql.Type {
 	aIsTimespan := IsTimespan(a)
 	bIsTimespan := IsTimespan(b)
 	if aIsTimespan && bIsTimespan {
-		return a
+		return Time
 	}
 	if (IsTime(a) || aIsTimespan) && (IsTime(b) || bIsTimespan) {
 		if IsDateType(a) && IsDateType(b) {
@@ -678,7 +684,8 @@ func GeneralizeTypes(a, b sql.Type) sql.Type {
 	}
 
 	if IsBlobType(a) || IsBlobType(b) {
-		return Blob
+		// TODO: match blob length to max of the blob lengths
+		return LongBlob
 	}
 
 	aIsBit := IsBit(a)
@@ -707,12 +714,6 @@ func GeneralizeTypes(a, b sql.Type) sql.Type {
 	}
 
 	if IsNumber(a) && IsNumber(b) {
-		if svt, ok := a.(sql.SystemVariableType); ok {
-			a = svt.UnderlyingType()
-		}
-		if svt, ok := a.(sql.SystemVariableType); ok {
-			b = svt.UnderlyingType()
-		}
 		return generalizeNumberTypes(a, b)
 	}
 	// TODO: decide if we want to make this VarChar to match MySQL, match VarChar length to max of two types

sql/types/conversion.go

@@ -160,17 +160,55 @@ func TestColumnCharTypes(t *testing.T) {
 }
 
 func TestGeneralizeTypes(t *testing.T) {
+	decimalType := MustCreateDecimalType(DecimalTypeMaxPrecision, DecimalTypeMaxScale)
+	uint64DecimalType := MustCreateDecimalType(DecimalTypeMaxPrecision, 0)
+
 	tests := []struct {
 		typeA    sql.Type
 		typeB    sql.Type
 		expected sql.Type
 	}{
+		{Float64, Float32, Float64},
+		{Float64, Int32, Float64},
+		{Int24, Float32, Float64},
+		{decimalType, Float64, Float64},
+		{decimalType, Int32, decimalType},
+		{Int64, decimalType, decimalType},
+		{Uint64, Int32, uint64DecimalType},
+		{Int24, Uint64, uint64DecimalType},
+		{Uint64, Uint8, Uint64},
+		{Uint24, Uint64, Uint64},
+		{Int64, Uint32, Int64},
+		{Int24, Int64, Int64},
+		{Int8, Int64, Int64},
+		{Uint32, Int24, Int64},
+		{Uint24, Uint32, Uint32},
+		{Int32, Int8, Int32},
+		{Uint24, Int32, Int32},
+		{Uint24, Int24, Int32},
+		{Uint8, Uint24, Uint24},
+		{Int24, Uint8, Int24},
+		{Int8, Int24, Int24},
+		{Int8, Uint16, Int24},
+		{Uint16, Uint8, Uint16},
+		{Int16, Int16, Int16},
+		{Int8, Int16, Int16},
+		{Uint8, Int8, Int16},
+		{Uint8, Uint8, Uint8},
+		{Int8, Int8, Int8},
+		{Boolean, Int64, Int64},
+		{Boolean, Boolean, Boolean},
 		{Text, Text, LongText},
 		{Text, Float64, LongText},
 		{Int64, Text, LongText},
-		{Float32, Float32, Float32},
-		{Int64, Float64, Float64},
-		{Int32, Int32, Int32},
+		{Int8, Null, Int8},
+		{Time, Time, Time},
+		{Time, Date, DatetimeMaxPrecision},
+		{Date, Date, Date},
+		{Date, Timestamp, DatetimeMaxPrecision},
+		{Timestamp, Timestamp, TimestampMaxPrecision},
+		{Timestamp, Datetime, DatetimeMaxPrecision},
+		{Null, Int64, Int64},
 		{Null, Null, Null},
 	}
 	for _, test := range tests {