Merge branch 'mysql-8.0' into mysql-trunk

Author: Maheedhar PV

mysql-test/r/multi_update_innodb.result

@@ -113,3 +113,17 @@ Note	1003	update `test`.`t1` join `test`.`t2` set `test`.`t2`.`b` = 0
 UPDATE t1,t2 SET t2.b=0;
 SET sql_buffer_result=@old_buf_result;
 DROP TABLE t1,t2;
+#
+# Bug#28716103 - MULTI-TABLE UPDATE OF PRIMARY KEY RESULTS IN ERROR 1032
+# "CAN'T FIND RECORD"
+#
+CREATE TABLE t1 (c1 CHAR(255) NOT NULL);
+CREATE TABLE t2 (c1 CHAR(255) NOT NULL, c2 CHAR(255) NOT NULL,
+c3 CHAR(255) NOT NULL,  PRIMARY KEY (c1, c2, c3));
+INSERT INTO t1 VALUES ('x'), ('x');
+INSERT INTO t2 VALUES ('x', '', '');
+UPDATE t1, t2 SET t2.c2 = 'y', t2.c3 = 'y' WHERE t2.c1 = t1.c1;
+SELECT * FROM t2;
+c1	c2	c3
+x	y	y
+DROP TABLE t1, t2;

mysql-test/t/multi_update_innodb.test

@@ -113,3 +113,21 @@ eval $query;
 
 SET sql_buffer_result=@old_buf_result;
 DROP TABLE t1,t2;
+
+--echo #
+--echo # Bug#28716103 - MULTI-TABLE UPDATE OF PRIMARY KEY RESULTS IN ERROR 1032
+--echo # "CAN'T FIND RECORD"
+--echo #
+
+# Make sure the size of primary key(accounting for bytes per code point)
+# is bigger than 512 bytes. This will force the use of a hash field
+# and a unique constraint on the hash field in the temporary table.
+
+CREATE TABLE t1 (c1 CHAR(255) NOT NULL);
+CREATE TABLE t2 (c1 CHAR(255) NOT NULL, c2 CHAR(255) NOT NULL,
+                 c3 CHAR(255) NOT NULL,  PRIMARY KEY (c1, c2, c3));
+INSERT INTO t1 VALUES ('x'), ('x');
+INSERT INTO t2 VALUES ('x', '', '');
+UPDATE t1, t2 SET t2.c2 = 'y', t2.c3 = 'y' WHERE t2.c1 = t1.c1;
+SELECT * FROM t2;
+DROP TABLE t1, t2;

sql/sql_update.cc

@@ -1891,7 +1891,7 @@ bool Query_result_update::optimize() {
     TABLE *table = table_ref->table;
     uint cnt = table_ref->shared;
     List<Item> temp_fields;
-    ORDER group;
+    ORDER *group = nullptr;
     Temp_table_param *tmp_param;
 
     if (thd->lex->is_ignore()) table->file->ha_extra(HA_EXTRA_IGNORE_DUP_KEY);
@@ -2038,17 +2038,18 @@ bool Query_result_update::optimize() {
 
     temp_fields.concat(fields_for_table[cnt]);
 
+    group = new (thd->mem_root) ORDER;
     /* Make an unique key over the first field to avoid duplicated updates */
-    memset(&group, 0, sizeof(group));
-    group.direction = ORDER_ASC;
-    group.item = temp_fields.head_ref();
+    memset(group, 0, sizeof(*group));
+    group->direction = ORDER_ASC;
+    group->item = temp_fields.head_ref();
 
     tmp_param->allow_group_via_temp_table = true;
     tmp_param->field_count = temp_fields.elements;
     tmp_param->group_parts = 1;
     tmp_param->group_length = table->file->ref_length;
     tmp_tables[cnt] =
-        create_tmp_table(thd, tmp_param, temp_fields, &group, false, false,
+        create_tmp_table(thd, tmp_param, temp_fields, group, false, false,
                          TMP_TABLE_ALL_COLUMNS, HA_POS_ERROR, "");
     if (!tmp_tables[cnt]) return true;
 
@@ -2060,6 +2061,7 @@ bool Query_result_update::optimize() {
       calling fill_record() to assign values to the temporary table's fields.
     */
     tmp_tables[cnt]->triggers = table->triggers;
+    tmp_tables[cnt]->file->ha_index_init(0, false /*sorted*/);
   }
   return false;
 }
@@ -2073,6 +2075,11 @@ void Query_result_update::cleanup(THD *thd) {
   if (tmp_tables) {
     for (uint cnt = 0; cnt < update_table_count; cnt++) {
       if (tmp_tables[cnt]) {
+        /*
+          Cleanup can get called without the send_eof() call, close
+          the index if open.
+        */
+        tmp_tables[cnt]->file->ha_index_or_rnd_end();
         free_tmp_table(thd, tmp_tables[cnt]);
         tmp_table_param[cnt].cleanup();
       }
@@ -2230,11 +2237,16 @@ bool Query_result_update::send_data(THD *thd, List<Item> &) {
                       unupdated_check_opt_tables.elements,
                   *values_for_table[offset], nullptr, nullptr, false);
 
+      // check if a record exists with the same hash value
+      if (!check_unique_constraint(tmp_table))
+        return false;  // skip adding duplicate record to the temp table
+
       /* Write row, ignoring duplicated updates to a row */
       error = tmp_table->file->ha_write_row(tmp_table->record[0]);
       if (error != HA_ERR_FOUND_DUPP_KEY && error != HA_ERR_FOUND_DUPP_UNIQUE) {
         if (error &&
-            create_ondisk_from_heap(thd, tmp_table, error, true, nullptr)) {
+            (create_ondisk_from_heap(thd, tmp_table, error, true, nullptr) ||
+             tmp_table->file->ha_index_init(0, false /*sorted*/))) {
           update_completed = true;
           return true;  // Not a table_is_full error
         }
@@ -2381,6 +2393,8 @@ bool Query_result_update::do_updates(THD *thd) {
     }
     copy_field_end = copy_field_ptr;
 
+    // Before initializing for random scan, close the index opened for insert.
+    tmp_table->file->ha_index_or_rnd_end();
     if ((local_error = tmp_table->file->ha_rnd_init(true))) {
       if (table->file->is_fatal_error(local_error))
         error_flags |= ME_FATALERROR;