Merge branch 'main' into james/check

Author: James Cor

enginetest/enginetests.go

@@ -496,7 +496,7 @@ func TestReadOnlyDatabases(t *testing.T, harness ReadOnlyDatabaseHarness) {
 
 	for _, querySet := range [][]queries.WriteQueryTest{
 		queries.InsertQueries,
-		queries.UpdateTests,
+		queries.UpdateWriteQueryTests,
 		queries.DeleteTests,
 		queries.ReplaceQueries,
 	} {
@@ -1352,9 +1352,12 @@ func TestReplaceIntoErrors(t *testing.T, harness Harness) {
 
 func TestUpdate(t *testing.T, harness Harness) {
 	harness.Setup(setup.MydbData, setup.MytableData, setup.Mytable_del_idxData, setup.FloattableData, setup.NiltableData, setup.TypestableData, setup.Pk_tablesData, setup.OthertableData, setup.TabletestData)
-	for _, tt := range queries.UpdateTests {
+	for _, tt := range queries.UpdateWriteQueryTests {
 		RunWriteQueryTest(t, harness, tt)
 	}
+	for _, tt := range queries.UpdateScriptTests {
+		TestScript(t, harness, tt)
+	}
 }
 
 func TestUpdateIgnore(t *testing.T, harness Harness) {
@@ -1421,9 +1424,12 @@ func TestDelete(t *testing.T, harness Harness) {
 
 func TestUpdateQueriesPrepared(t *testing.T, harness Harness) {
 	harness.Setup(setup.MydbData, setup.MytableData, setup.Mytable_del_idxData, setup.OthertableData, setup.TypestableData, setup.Pk_tablesData, setup.FloattableData, setup.NiltableData, setup.TabletestData)
-	for _, tt := range queries.UpdateTests {
+	for _, tt := range queries.UpdateWriteQueryTests {
 		runWriteQueryTestPrepared(t, harness, tt)
 	}
+	for _, tt := range queries.UpdateScriptTests {
+		TestScriptPrepared(t, harness, tt)
+	}
 }
 
 func TestDeleteQueriesPrepared(t *testing.T, harness Harness) {

enginetest/queries/check_scripts.go

@@ -495,7 +495,7 @@ var ChecksOnUpdateScriptTests = []ScriptTest{
 		},
 	},
 	{
-		Name: "Update join updates",
+		Name: "Update join - single table",
 		SetUpScript: []string{
 			"CREATE TABLE sales (year_built int primary key, CONSTRAINT `valid_year_built` CHECK (year_built <= 2022));",
 			"INSERT INTO sales VALUES (1981);",
@@ -535,6 +535,45 @@ var ChecksOnUpdateScriptTests = []ScriptTest{
 			},
 		},
 	},
+	{
+		Name: "Update join - multiple tables",
+		SetUpScript: []string{
+			"CREATE TABLE sales (year_built int primary key, CONSTRAINT `valid_year_built` CHECK (year_built <= 2022));",
+			"INSERT INTO sales VALUES (1981);",
+			"CREATE TABLE locations (state char(2) primary key, CONSTRAINT `state` CHECK (state != 'GA'));",
+			"INSERT INTO locations VALUES ('WA');",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query:       "UPDATE sales JOIN locations SET sales.year_built = 2000, locations.state = 'GA';",
+				ExpectedErr: sql.ErrCheckConstraintViolated,
+			},
+			{
+				Query:       "UPDATE sales JOIN locations SET sales.year_built = 2025, locations.state = 'CA';",
+				ExpectedErr: sql.ErrCheckConstraintViolated,
+			},
+			{
+				Query:    "select * from sales;",
+				Expected: []sql.Row{{1981}},
+			},
+			{
+				Query:    "select * from locations;",
+				Expected: []sql.Row{{"WA"}},
+			},
+			{
+				Query:    "UPDATE sales JOIN locations SET sales.year_built = 2000, locations.state = 'CA';",
+				Expected: []sql.Row{{types.OkResult{2, 0, plan.UpdateInfo{2, 2, 0}}}},
+			},
+			{
+				Query:    "select * from sales;",
+				Expected: []sql.Row{{2000}},
+			},
+			{
+				Query:    "select * from locations;",
+				Expected: []sql.Row{{"CA"}},
+			},
+		},
+	},
 }
 
 var DisallowedCheckConstraintsScripts = []ScriptTest{

enginetest/queries/integration_plans.go

@@ -1161,6 +1161,45 @@ var JoinScriptTests = []ScriptTest{
 			},
 		},
 	},
+	{
+		// After this change: https://github.com/dolthub/go-mysql-server/pull/3038
+		// hash.HashOf takes in a sql.Schema to convert and hash keys, so
+		// we need to pass in the schema of the join key.
+		// This tests a bug introduced in that same PR where we incorrectly pass in the entire schema,
+		// resulting in incorrect conversions.
+		Name: "HashLookup on multiple columns with tables with different schemas",
+		SetUpScript: []string{
+			"create table t1 (i int primary key, k int);",
+			"create table t2 (i int primary key, j varchar(1), k int);",
+			"insert into t1 values (111111, 111111);",
+			"insert into t2 values (111111, 'a', 111111);",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "select /*+ HASH_JOIN(t1, t2) */ * from t1 join t2 on t1.i = t2.i and t1.k = t2.k;",
+				Expected: []sql.Row{
+					{111111, 111111, 111111, "a", 111111},
+				},
+			},
+		},
+	},
+	{
+		Name: "HashLookup on multiple columns with collations",
+		SetUpScript: []string{
+			"create table t1 (i int primary key, j varchar(128) collate utf8mb4_0900_ai_ci);",
+			"create table t2 (i int primary key, j varchar(128) collate utf8mb4_0900_ai_ci);",
+			"insert into t1 values (1, 'ABCDE');",
+			"insert into t2 values (1, 'abcde');",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "select /*+ HASH_JOIN(t1, t2) */ * from t1 join t2 on t1.i = t2.i and t1.j = t2.j;",
+				Expected: []sql.Row{
+					{1, "ABCDE", 1, "abcde"},
+				},
+			},
+		},
+	},
 }
 
 var LateralJoinScriptTests = []ScriptTest{

enginetest/queries/join_queries.go

@@ -813,7 +813,7 @@ var QueryTests = []QueryTest{
 	{
 		// Assert that SYSDATE() returns different times on each call in a query (unlike NOW())
 		// Using the maximum precision for fractional seconds, lets us see a difference.
-		Query:    "select now() = sysdate(), sleep(0.5), now(6) < sysdate(6);",
+		Query:    "select sysdate() - now() <= 1, sleep(2), sysdate() - now() > 0;",
 		Expected: []sql.Row{{true, 0, true}},
 	},
 	{
@@ -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

@@ -8712,6 +8712,42 @@ where
 			},
 		},
 	},
+	{
+		Name: "tinyint column does not restrict IF or IFNULL output",
+		// https://github.com/dolthub/dolt/issues/9321
+		SetUpScript: []string{
+			"create table t0 (c0 tinyint);",
+			"insert into t0 values (null);",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "select ifnull(t0.c0, 128) as ref0 from t0",
+				Expected: []sql.Row{
+					{128},
+				},
+			},
+			{
+				Query:    "select if(t0.c0 = 1, t0.c0, 128) as ref0 from t0",
+				Expected: []sql.Row{{128}},
+			},
+		},
+	},
+	{
+		Name:    "subquery with case insensitive collation",
+		Dialect: "mysql",
+		SetUpScript: []string{
+			"create table tbl (t text) collate=utf8mb4_0900_ai_ci;",
+			"insert into tbl values ('abcdef');",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "select 'AbCdEf' in (select t from tbl);",
+				Expected: []sql.Row{
+					{true},
+				},
+			},
+		},
+	},
 }
 
 var SpatialScriptTests = []ScriptTest{

enginetest/queries/script_queries.go

@@ -3784,6 +3784,42 @@ end;
 			},
 		},
 	},
+
+	// Invalid triggers
+	{
+		Name: "insert trigger with subquery projections",
+		SetUpScript: []string{
+			"create table t (i int);",
+			"create trigger trig before insert on t for each row begin replace into t select 1; end;",
+			"alter table t add column j int;",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "show create trigger trig",
+				Expected: []sql.Row{
+					{
+						"trig",
+						"",
+						"create trigger trig before insert on t for each row begin replace into t select 1; end",
+						sql.Collation_Default.CharacterSet().String(),
+						sql.Collation_Default.String(),
+						sql.Collation_Default.String(),
+						time.Unix(0, 0).UTC(),
+					},
+				},
+			},
+			{
+				Query:       "insert into t values (1, 2);",
+				ExpectedErr: sql.ErrInsertIntoMismatchValueCount,
+			},
+			{
+				Query: "drop trigger trig;",
+				Expected: []sql.Row{
+					{types.NewOkResult(0)},
+				},
+			},
+		},
+	},
 }
 
 var TriggerCreateInSubroutineTests = []ScriptTest{

enginetest/queries/trigger_queries.go

@@ -24,7 +24,7 @@ import (
 	"github.com/dolthub/vitess/go/mysql"
 )
 
-var UpdateTests = []WriteQueryTest{
+var UpdateWriteQueryTests = []WriteQueryTest{
 	{
 		WriteQuery:          "UPDATE mytable SET s = 'updated';",
 		ExpectedWriteResult: []sql.Row{{NewUpdateResult(3, 3)}},
@@ -470,6 +470,103 @@ var UpdateTests = []WriteQueryTest{
 	},
 }
 
+var UpdateScriptTests = []ScriptTest{
+	{
+		Dialect: "mysql",
+		Name:    "UPDATE join – single table, with FK constraint",
+		SetUpScript: []string{
+			"CREATE TABLE customers (id INT PRIMARY KEY, name TEXT);",
+			"CREATE TABLE orders (id INT PRIMARY KEY, customer_id INT, amount INT, FOREIGN KEY (customer_id) REFERENCES customers(id));",
+			"INSERT INTO customers VALUES (1, 'Alice'), (2, 'Bob');",
+			"INSERT INTO orders VALUES (101, 1, 50), (102, 2, 75);",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query:       "UPDATE orders o JOIN customers c ON o.customer_id = c.id SET o.customer_id = 123 where o.customer_id != 1;",
+				ExpectedErr: sql.ErrForeignKeyChildViolation,
+			},
+			{
+				Query: "SELECT * FROM orders;",
+				Expected: []sql.Row{
+					{101, 1, 50}, {102, 2, 75},
+				},
+			},
+		},
+	},
+	{
+		Dialect: "mysql",
+		Name:    "UPDATE join – multiple tables, with FK constraint",
+		SetUpScript: []string{
+			"CREATE TABLE parent1 (id INT PRIMARY KEY);",
+			"CREATE TABLE parent2 (id INT PRIMARY KEY);",
+			"CREATE TABLE child1 (id INT PRIMARY KEY, p1_id INT, FOREIGN KEY (p1_id) REFERENCES parent1(id));",
+			"CREATE TABLE child2 (id INT PRIMARY KEY, p2_id INT, FOREIGN KEY (p2_id) REFERENCES parent2(id));",
+			"INSERT INTO parent1 VALUES (1), (3);",
+			"INSERT INTO parent2 VALUES (1), (3);",
+			"INSERT INTO child1 VALUES (10, 1);",
+			"INSERT INTO child2 VALUES (20, 1);",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: `UPDATE child1 c1
+						JOIN child2 c2 ON c1.id = 10 AND c2.id = 20
+						SET c1.p1_id = 999, c2.p2_id = 3;`,
+				ExpectedErr: sql.ErrForeignKeyChildViolation,
+			},
+			{
+				Query: `UPDATE child1 c1
+						JOIN child2 c2 ON c1.id = 10 AND c2.id = 20
+						SET c1.p1_id = 3, c2.p2_id = 999;`,
+				ExpectedErr: sql.ErrForeignKeyChildViolation,
+			},
+			{
+				Query:    "SELECT * FROM child1;",
+				Expected: []sql.Row{{10, 1}},
+			},
+			{
+				Query:    "SELECT * FROM child2;",
+				Expected: []sql.Row{{20, 1}},
+			},
+		},
+	},
+	{
+		Dialect: "mysql",
+		Name:    "UPDATE join – multiple tables, with trigger",
+		SetUpScript: []string{
+			"CREATE TABLE a (id INT PRIMARY KEY, x INT);",
+			"CREATE TABLE b (id INT PRIMARY KEY, y INT);",
+			"CREATE TABLE logbook (entry TEXT);",
+			`CREATE TRIGGER trig_a AFTER UPDATE ON a FOR EACH ROW
+		 BEGIN
+		   INSERT INTO logbook VALUES ('a updated');
+		 END;`,
+			`CREATE TRIGGER trig_b AFTER UPDATE ON b FOR EACH ROW
+		 BEGIN
+		   INSERT INTO logbook VALUES ('b updated');
+		 END;`,
+			"INSERT INTO a VALUES (5, 100);",
+			"INSERT INTO b VALUES (6, 200);",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: `UPDATE a
+					JOIN b ON a.id = 5 AND b.id = 6
+					SET a.x = 101, b.y = 201;`,
+			},
+			{
+				// TODO: UPDATE ... JOIN does not properly apply triggers when multiple tables are being updated,
+				//       and will currently only apply triggers from one of the tables.
+				Skip:  true,
+				Query: "SELECT * FROM logbook ORDER BY entry;",
+				Expected: []sql.Row{
+					{"a updated"},
+					{"b updated"},
+				},
+			},
+		},
+	},
+}
+
 var SpatialUpdateTests = []WriteQueryTest{
 	{
 		WriteQuery:          "UPDATE point_table SET p = point(123.456,789);",