Merge branch 'main' into angela/emptyjoin

Author: angelamayxie

enginetest/join_op_tests.go

@@ -2047,16 +2047,54 @@ WHERE
 		},
 	},
 	{
-		// https://github.com/dolthub/dolt/issues/9782
-		name: "joining with subquery on empty table",
+		name: "joining on decimals",
 		setup: [][]string{
 			{
-				"CREATE TABLE t(c INT);",
-				"INSERT INTO t VALUES (1);",
+				"create table t1(c0 decimal(6,3))",
+				"create table t2(c0 decimal(5,2))",
+				"insert into t1 values (10.000),(20.505),(30.000)",
+				"insert into t2 values (20.5), (25.0), (30.0)",
+			},
+		},
+		tests: []JoinOpTests{
+			{
+				Query:    "select * from t1 join t2 on t1.c0 = t2.c0",
+				Expected: []sql.Row{{"30.000", "30.00"}},
+			},
+		},
+	},
+	{
+		// https://github.com/dolthub/dolt/issues/9777
+		name: "join with % condition",
+		setup: [][]string{
+			{
+				"create table t1(c0 int)",
+				"create table t2(c0 int)",
+				"insert into t1 values (1),(2)",
+				"insert into t2 values (3),(4)",
 			},
 		},
 		tests: []JoinOpTests{
 			{
+				Query: "select * from t1 join t2 on (t1.c0 % 2) = (t2.c0 % 2)",
+				Expected: []sql.Row{
+					{1, 3},
+					{2, 4},
+				},
+			},
+		},
+	},
+  {
+		// https://github.com/dolthub/dolt/issues/9782
+		name: "joining with subquery on empty table",
+		setup: [][]string{
+			{
+				"CREATE TABLE t(c INT);",
+				"INSERT INTO t VALUES (1);",
+      },
+    },
+    tests: []JoinOpTests{
+      {
 				Query:    "SELECT t.c FROM t LEFT JOIN (SELECT t.c FROM t WHERE FALSE) AS subq ON TRUE;",
 				Expected: []sql.Row{{1}},
 			},
@@ -2071,9 +2109,9 @@ WHERE
 			{
 				Query:    "SELECT t.c FROM (SELECT t.c FROM t WHERE FALSE) AS subq NATURAL RIGHT JOIN t;",
 				Expected: []sql.Row{{1}},
-			},
-		},
-	},
+      },
+    },
+  },
 }
 
 var rangeJoinOpTests = []JoinOpTests{

enginetest/queries/update_queries.go

@@ -597,9 +597,9 @@ var UpdateScriptTests = []ScriptTest{
 		},
 	},
 	{
-		Dialect: "mysql",
 		// https://github.com/dolthub/dolt/issues/9403
-		Name: "UPDATE join – multiple tables with same column names with triggers",
+		Dialect: "mysql",
+		Name:    "UPDATE join – multiple tables with same column names with triggers",
 		SetUpScript: []string{
 			"create table customers (id int primary key, name text, tier text)",
 			"create table orders (id int primary key, customer_id int, status text)",
@@ -632,8 +632,54 @@ var UpdateScriptTests = []ScriptTest{
 		},
 	},
 	{
-		Name: "UPDATE with subquery in keyless tables",
+		Dialect: "mysql",
+		Name:    "UPDATE join - conflicting alias in Subquery Alias",
+		SetUpScript: []string{
+			"create table parent (id int primary key);",
+			"insert into parent values (1), (2), (3);",
+			"create table child (id int primary key, pid int, foreign key (pid) references parent(id), oid int);",
+			"insert into child values (1, 1, 0), (2, 2, 0), (3, 3, 0);",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: `
+update child t1
+left join 
+(
+    select
+        t1.id
+    from
+        child t1
+) sqa
+on
+    t1.id = sqa.id
+join
+    child t2
+set
+t1.oid = t2.pid;`,
+				Expected: []sql.Row{
+					{types.OkResult{
+						RowsAffected: 3,
+						Info: plan.UpdateInfo{
+							Matched: 3,
+							Updated: 3,
+						},
+					}},
+				},
+			},
+			{
+				Query: "select * from child;",
+				Expected: []sql.Row{
+					{1, 1, 1},
+					{2, 2, 1},
+					{3, 3, 1},
+				},
+			},
+		},
+	},
+	{
 		// https://github.com/dolthub/dolt/issues/9334
+		Name: "UPDATE with subquery in keyless tables",
 		SetUpScript: []string{
 			"create table t (i int)",
 			"insert into t values (1)",

sql/analyzer/apply_foreign_keys.go

@@ -127,8 +127,7 @@ func applyForeignKeysToNodes(ctx *sql.Context, a *Analyzer, n sql.Node, cache *f
 			fkHandlerMap := make(map[string]sql.Node, len(updateTargets))
 			for tableName, updateTarget := range updateTargets {
 				fkHandlerMap[tableName] = updateTarget
-				fkHandler, err :=
-					getForeignKeyHandlerFromUpdateTarget(ctx, a, updateTarget, cache, fkChain)
+				fkHandler, err := getForeignKeyHandlerFromUpdateTarget(ctx, a, updateTarget, cache, fkChain)
 				if err != nil {
 					return nil, transform.SameTree, err
 				}

sql/analyzer/tables.go

@@ -98,28 +98,28 @@ func getResolvedTable(node sql.Node) *plan.ResolvedTable {
 }
 
 // getTablesByName takes a node and returns all found resolved tables in a map.
+// This function will not look inside sql.OpaqueNodes (like plan.SubqueryAlias).
 func getTablesByName(node sql.Node) map[string]*plan.ResolvedTable {
 	ret := make(map[string]*plan.ResolvedTable)
-
-	transform.Inspect(node, func(node sql.Node) bool {
+	// TODO: We should change transform.Inspect to not walk the children of sql.OpaqueNodes (like transform.Node)
+	//  and add a transform.InspectWithOpaque that does.
+	//  Using transform.Node here achieves the same result without a large refactor.
+	transform.Node(node, func(node sql.Node) (sql.Node, transform.TreeIdentity, error) {
 		switch n := node.(type) {
 		case *plan.ResolvedTable:
 			ret[strings.ToLower(n.Table.Name())] = n
 		case *plan.IndexedTableAccess:
 			rt, ok := n.TableNode.(*plan.ResolvedTable)
 			if ok {
 				ret[strings.ToLower(rt.Name())] = rt
-				return false
 			}
 		case *plan.TableAlias:
 			rt := getResolvedTable(n)
 			if rt != nil {
 				ret[n.Name()] = rt
 			}
-		default:
 		}
-		return true
+		return nil, transform.SameTree, nil
 	})
-
 	return ret
 }

sql/expression/in.go

@@ -16,9 +16,9 @@ package expression
 
 import (
 	"fmt"
-	"strconv"
 
 	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/hash"
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
@@ -106,11 +106,11 @@ func (in *InTuple) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 			elType := el.Type()
 			if types.IsDecimal(elType) || types.IsFloat(elType) {
 				rtyp := el.Type().Promote()
-				left, err := convertOrTruncate(ctx, left, rtyp)
+				left, err := types.ConvertOrTruncate(ctx, left, rtyp)
 				if err != nil {
 					return nil, err
 				}
-				right, err := convertOrTruncate(ctx, originalRight, rtyp)
+				right, err := types.ConvertOrTruncate(ctx, originalRight, rtyp)
 				if err != nil {
 					return nil, err
 				}
@@ -119,7 +119,7 @@ func (in *InTuple) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 					return nil, err
 				}
 			} else {
-				right, err := convertOrTruncate(ctx, originalRight, typ)
+				right, err := types.ConvertOrTruncate(ctx, originalRight, typ)
 				if err != nil {
 					return nil, err
 				}
@@ -233,9 +233,9 @@ func newInMap(ctx *sql.Context, right Tuple, lType sql.Type) (map[uint64]sql.Exp
 
 		var key uint64
 		if types.IsDecimal(rType) || types.IsFloat(rType) {
-			key, err = hashOfSimple(ctx, i, rType)
+			key, err = hash.HashOfSimple(ctx, i, rType)
 		} else {
-			key, err = hashOfSimple(ctx, i, lType)
+			key, err = hash.HashOfSimple(ctx, i, lType)
 		}
 		if err != nil {
 			return nil, false, err
@@ -246,66 +246,6 @@ func newInMap(ctx *sql.Context, right Tuple, lType sql.Type) (map[uint64]sql.Exp
 	return elements, hasNull, nil
 }
 
-func hashOfSimple(ctx *sql.Context, i interface{}, t sql.Type) (uint64, error) {
-	if i == nil {
-		return 0, nil
-	}
-
-	var str string
-	coll := sql.Collation_Default
-	if types.IsTuple(t) {
-		tup := i.([]interface{})
-		tupType := t.(types.TupleType)
-		hashes := make([]uint64, len(tup))
-		for idx, v := range tup {
-			h, err := hashOfSimple(ctx, v, tupType[idx])
-			if err != nil {
-				return 0, err
-			}
-			hashes[idx] = h
-		}
-		str = fmt.Sprintf("%v", hashes)
-	} else if types.IsTextOnly(t) {
-		coll = t.(sql.StringType).Collation()
-		if s, ok := i.(string); ok {
-			str = s
-		} else {
-			converted, err := convertOrTruncate(ctx, i, t)
-			if err != nil {
-				return 0, err
-			}
-			str, _, err = sql.Unwrap[string](ctx, converted)
-			if err != nil {
-				return 0, err
-			}
-		}
-	} else {
-		x, err := convertOrTruncate(ctx, i, t.Promote())
-		if err != nil {
-			return 0, err
-		}
-
-		// Remove trailing 0s from floats
-		switch v := x.(type) {
-		case float32:
-			str = strconv.FormatFloat(float64(v), 'f', -1, 32)
-			if str == "-0" {
-				str = "0"
-			}
-		case float64:
-			str = strconv.FormatFloat(v, 'f', -1, 64)
-			if str == "-0" {
-				str = "0"
-			}
-		default:
-			str = fmt.Sprintf("%v", v)
-		}
-	}
-
-	// Collated strings that are equivalent may have different runes, so we must make them hash to the same value
-	return coll.HashToUint(str)
-}
-
 // Eval implements the Expression interface.
 func (hit *HashInTuple) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	leftElems := types.NumColumns(hit.in.Left().Type().Promote())
@@ -319,7 +259,7 @@ func (hit *HashInTuple) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 		return nil, nil
 	}
 
-	key, err := hashOfSimple(ctx, leftVal, hit.in.Left().Type())
+	key, err := hash.HashOfSimple(ctx, leftVal, hit.in.Left().Type())
 	if err != nil {
 		return nil, err
 	}
@@ -339,43 +279,6 @@ func (hit *HashInTuple) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 	return true, nil
 }
 
-// convertOrTruncate converts the value |i| to type |t| and returns the converted value; if the value does not convert
-// cleanly and the type is automatically coerced (i.e. string and numeric types), then a warning is logged and the
-// value is truncated to the Zero value for type |t|. If the value does not convert and the type is not automatically
-// coerced, then an error is returned.
-func convertOrTruncate(ctx *sql.Context, i interface{}, t sql.Type) (interface{}, error) {
-	converted, _, err := t.Convert(ctx, i)
-	if err == nil {
-		return converted, nil
-	}
-
-	// If a value can't be converted to an enum or set type, truncate it to a value that is guaranteed
-	// to not match any enum value.
-	if types.IsEnum(t) || types.IsSet(t) {
-		return nil, nil
-	}
-
-	// Values for numeric and string types are automatically coerced. For all other types, if they
-	// don't convert cleanly, it's an error.
-	if err != nil && !(types.IsNumber(t) || types.IsTextOnly(t)) {
-		return nil, err
-	}
-
-	// For numeric and string types, if the value can't be cleanly converted, truncate to the zero value for
-	// the type and log a warning in the session.
-	warning := sql.Warning{
-		Level:   "Warning",
-		Message: fmt.Sprintf("Truncated incorrect %s value: %v", t.String(), i),
-		Code:    1292,
-	}
-
-	if ctx != nil && ctx.Session != nil {
-		ctx.Session.Warn(&warning)
-	}
-
-	return t.Zero(), nil
-}
-
 func (hit *HashInTuple) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte) {
 	return hit.in.CollationCoercibility(ctx)
 }