From 47637a3dd13d19e897a7cbfd1499f1bf3b2fdb2a Mon Sep 17 00:00:00 2001 From: Sujatha Date: Tue, 14 May 2019 13:03:06 +0530 Subject: [PATCH 1/4] MDEV-11095: rpl.rpl_row_mysqlbinlog test fails if row annotation enabled Problem: ======= Whel rpl.rpl_row_mysqlbinlog test is executed as shown below it fails with result content mismatch. perl mtr rpl_row_mysqlbinlog --mysqld=--binlog-annotate-row-events=1 Analysis: ========= When row annotations are enabled the actual query is written into the binlog which helps users to understand the query, even when row based replication is enabled. For example: Simple insert in row based replication looks like shown below. #190402 16:31:27 server id 1 end_log_pos 526 Annotate_rows: #Q> insert into t values (10) #190402 16:31:27 server id 1 end_log_pos 566 Table_map: `test`.`t` mapped to number 19 # at 566 #190402 16:31:27 server id 1 end_log_pos 600 Write_rows: table id 19 flags: STMT_END_F BINLOG ' B0GjXBMBAAAAKAAAADYCAAAAABMAAAAAAAEABHRlc3QAAXQAAQMAAQ== B0GjXBcBAAAAIgAAAFgCAAAAABMAAAAAAAEAAf/+CgAAAA== '/*!*/; # at 600 The test creates some binary log events and redirects them into a SQL file. Executes RESET MASTER and sources the SQL file back on clean master and verifies that the data is available. Please refer following steps. ../client/mysqlbinlog ./var/mysqld.1/data/master-bin.000001 > test.sql ../client/mysql -uroot -S./var/tmp/mysqld.1.sock -Dtest < test.sql ../client/mysqlbinlog ./var/mysqld.1/data/master-bin.000001 -v > row.sql When the row based replication specific SQL file is sourced once again on master the newly generated binlog will treat the entire "BASE 64" encoded event as query and write it into the binary log. Output from 'row.sql': #Q> BINLOG ' #Q> B0GjXBMBAAAAKAAAADYCAAAAABMAAAAAAAEABHRlc3QAAXQAAQMAAQ== #Q> B0GjXBcBAAAAIgAAAFgCAAAAABMAAAAAAAEAAf/+CgAAAA== #190402 16:31:27 server id 1 end_log_pos 657 Table_map: `test`.`t` mapped to number 23 # at 657 #190402 16:31:27 server id 1 end_log_pos 691 Write_rows: table id 23 flags: STMT_END_F BINLOG ' B0GjXBMBAAAAKAAAAJECAAAAABcAAAAAAAEABHRlc3QAAXQAAQMAAQ== B0GjXBcBAAAAIgAAALMCAAAAABcAAAAAAAEAAQH+CgAAAA== ### INSERT INTO `test`.`t` ### SET ### @1=10 '/*!*/; # at 691 This is expected behaviour as we cannot extract query from BASE 64 encoded input. This causes more number of binary logs to be generated when the test is executed with row annotations. The following lines from test assumes that only two binary logs will contain entire data. --echo --- Test 4 Second Remote test -- ---exec $MYSQL_BINLOG --read-from-remote-server --user=root --host=127.0.0.1 --port=$MASTER_MYPORT master-bin.000001 > $MYSQLTEST_VARDIR/tmp/remote.sql ---exec $MYSQL_BINLOG --read-from-remote-server --user=root --host=127.0.0.1 --port=$MASTER_MYPORT master-bin.000002 >> $MYSQLTEST_VARDIR/tmp/remote.sql In a case when row annotations are enabled the data gets spread across four binary logs. As test uses only the first two binary log files, data available in other binary logs gets missed. Hence test fails with result content mismatch as less data is avaialble. Fix: ==== Use "-to-the-last" option of "mysqlbinlog" tool which will ensure that all the available binary log specific contents are included in .sql file. --- mysql-test/suite/rpl/t/rpl_row_mysqlbinlog.test | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/mysql-test/suite/rpl/t/rpl_row_mysqlbinlog.test b/mysql-test/suite/rpl/t/rpl_row_mysqlbinlog.test index 678679f0cf1..a249043fa19 100644 --- a/mysql-test/suite/rpl/t/rpl_row_mysqlbinlog.test +++ b/mysql-test/suite/rpl/t/rpl_row_mysqlbinlog.test @@ -151,8 +151,7 @@ remove_file $MYSQLTEST_VARDIR/tmp/master.sql; --exec $MYSQL_BINLOG --short-form --local-load=$MYSQLTEST_VARDIR/tmp/ --stop-position=$stop_position --read-from-remote-server --user=root --host=127.0.0.1 --port=$MASTER_MYPORT master-bin.000001 --echo --- Test 4 Second Remote test -- ---exec $MYSQL_BINLOG --read-from-remote-server --user=root --host=127.0.0.1 --port=$MASTER_MYPORT master-bin.000001 > $MYSQLTEST_VARDIR/tmp/remote.sql ---exec $MYSQL_BINLOG --read-from-remote-server --user=root --host=127.0.0.1 --port=$MASTER_MYPORT master-bin.000002 >> $MYSQLTEST_VARDIR/tmp/remote.sql +--exec $MYSQL_BINLOG --read-from-remote-server --user=root --host=127.0.0.1 --port=$MASTER_MYPORT --to-last-log master-bin.000001 > $MYSQLTEST_VARDIR/tmp/remote.sql # Now that we have our file, lets get rid of the current database. # Cleanup the master and the slave and try to recreate. From 43bbf88dcbab470947af0567f265d9659b07aab8 Mon Sep 17 00:00:00 2001 From: Sujatha Date: Tue, 14 May 2019 16:06:55 +0530 Subject: [PATCH 2/4] MDEV-19158: MariaDB 10.2.22 is writing duplicate entries into binary log Problem: ======== We have a Master/Master Setup on two servers, but are only writing to one of those servers (so it is essentially Master/Slave) We upgraded from 10.1.* to 10.2.22 last week and starting with the upgrade, we are getting duplicate key errors on the slave. BINLOG=mixed. Analysis: ========= This issue happens with LOCK TABLES and binlog_format=MIXED combination. When an UNSAFE statement is encountered in 'MIXED' mode, it is logged in the form of 'ROW' format. For all the tables that are part of LOCK TABLES list their table maps are written into the binary log. For each table in the list a check is done to see if 'check_table_binlog_row_based_done' flag is set or not. If it is not set a check process is initiated to see if table qualifies for row based binary logging or not and 'check_table_binlog_row_based_done' is set. This flag will be cleared at the time of closing thread tables. But there can be special cases where the LOCK TABLES contains more number of tables but the unsafe query is actually using subset of tables from LOCK TABLES list. For example: LOCK TABLES locks t1,t2,t3 but the unsafe statement makes use of only two tables t1,t3. In this case the 'check_table_binlog_row_based_done' flag is enabled for table 't2' while writing table map, but 'close_thread_tables' function call will not reset this flag. Since the flag is not cleared for table 't2' even a safe statement which used t2 will be logged in the form of row based format. This leads to an assert on debug builds and causes duplicate entries in release builds. In release builds a statement is logged in the form of both ROW and STATEMENT format. This causes the slave to fail with duplicate key error. Fix: === During 'close_thread_tables' when LOCK TABLE modes are active "ha_reset" is done for all the tables which were part of current statement. As mentioned in the example 'ha_reset' is called for tables 't1' and 't3'. This will clear the 'check_table_binlog_row_based_done' flag. At this point add a check for the rest of the tables to see if 'check_table_binlog_row_based_done' is enabled or not. If enabled clear the flag. --- .../suite/rpl/r/rpl_binlog_dup_entry.result | 29 ++++++++ .../suite/rpl/t/rpl_binlog_dup_entry.test | 72 +++++++++++++++++++ sql/handler.cc | 4 +- sql/handler.h | 5 ++ sql/sql_base.cc | 8 +++ 5 files changed, 116 insertions(+), 2 deletions(-) create mode 100644 mysql-test/suite/rpl/r/rpl_binlog_dup_entry.result create mode 100644 mysql-test/suite/rpl/t/rpl_binlog_dup_entry.test diff --git a/mysql-test/suite/rpl/r/rpl_binlog_dup_entry.result b/mysql-test/suite/rpl/r/rpl_binlog_dup_entry.result new file mode 100644 index 00000000000..108a65df07f --- /dev/null +++ b/mysql-test/suite/rpl/r/rpl_binlog_dup_entry.result @@ -0,0 +1,29 @@ +include/master-slave.inc +[connection master] +CREATE TABLE t1 (id mediumint(8) unsigned NOT NULL AUTO_INCREMENT, someLabel varchar(30) NOT NULL, flag tinyint(1) NOT NULL DEFAULT 0, PRIMARY KEY (id)) Engine=MyISAM; +CREATE TABLE t2 (id mediumint(8) unsigned NOT NULL AUTO_INCREMENT, data varchar(30) NOT NULL, status tinyint(1) NOT NULL, PRIMARY KEY (id)) Engine=MyISAM; +CREATE TABLE t3 (id mediumint(8) unsigned NOT NULL AUTO_INCREMENT, t1id mediumint(8) unsigned NOT NULL, flag tinyint(1) NOT NULL DEFAULT 0, status tinyint(1) NOT NULL DEFAULT 0, PRIMARY KEY (id)) Engine=MyISAM; +INSERT INTO t1 ( id, someLabel, flag ) VALUES ( 1, 'ABC', 0 ); +CREATE OR REPLACE TRIGGER doNothing +BEFORE UPDATE ON t1 +FOR EACH ROW +BEGIN +IF +new.someLabel != old.someLabel +THEN +UPDATE t3 SET t3.flag = 0; +END IF; +END| +FLUSH LOGS; +LOCK TABLES t1 WRITE, t2 WRITE; +INSERT INTO t2 (data, status) VALUES ('1', 4); +UPDATE t1 SET flag = 1 WHERE id = 1; +INSERT INTO t2 (data, status) VALUES ('2', 4); +UNLOCK TABLES; +connection slave; +include/diff_tables.inc [master:t1, slave:t1] +include/diff_tables.inc [master:t2, slave:t2] +include/diff_tables.inc [master:t3, slave:t3] +connection master; +DROP TABLE t1, t2, t3; +include/rpl_end.inc diff --git a/mysql-test/suite/rpl/t/rpl_binlog_dup_entry.test b/mysql-test/suite/rpl/t/rpl_binlog_dup_entry.test new file mode 100644 index 00000000000..869c715f407 --- /dev/null +++ b/mysql-test/suite/rpl/t/rpl_binlog_dup_entry.test @@ -0,0 +1,72 @@ +# ==== Purpose ==== +# +# Test verifies that there are no duplicate entries in binlog (i.e a safe +# statement which follows an unsafe statement gets logged in both row format +# and statement format resulting in duplicate entry) when binlog-format=MIXED +# and LOCK TABLES are enabled. +# +# ==== Implementation ==== +# +# Steps: +# 1 - Create three tables t1,t2 and t3 with AUTO_INCREMENT on. +# 2 - Create a trigger on table t3, so that trigger execution results in +# unsafe statement. Note query that modifies autoinc column in +# sub-statement can make the master and slave inconsistent. Hence they +# are logged in row format. +# 3 - Lock tables t1,t2 and t3. +# 4 - Execute an unsafe update which modifies tables t1 and t3. But since t2 +# table is also locked its table map event also gets written into the +# binary log during the execution of update. +# 5 - Execute a safe DML operation using table 't2' and verify that master +# doesn't report any assert. +# 6 - Ensure that slave is in sync with master and data is consistent. +# +# ==== References ==== +# +# MDEV-19158: MariaDB 10.2.22 is writing duplicate entries into binary log + +--source include/have_binlog_format_mixed.inc +--source include/master-slave.inc + +CREATE TABLE t1 (id mediumint(8) unsigned NOT NULL AUTO_INCREMENT, someLabel varchar(30) NOT NULL, flag tinyint(1) NOT NULL DEFAULT 0, PRIMARY KEY (id)) Engine=MyISAM; +CREATE TABLE t2 (id mediumint(8) unsigned NOT NULL AUTO_INCREMENT, data varchar(30) NOT NULL, status tinyint(1) NOT NULL, PRIMARY KEY (id)) Engine=MyISAM; +CREATE TABLE t3 (id mediumint(8) unsigned NOT NULL AUTO_INCREMENT, t1id mediumint(8) unsigned NOT NULL, flag tinyint(1) NOT NULL DEFAULT 0, status tinyint(1) NOT NULL DEFAULT 0, PRIMARY KEY (id)) Engine=MyISAM; + +INSERT INTO t1 ( id, someLabel, flag ) VALUES ( 1, 'ABC', 0 ); + +DELIMITER |; + +CREATE OR REPLACE TRIGGER doNothing +BEFORE UPDATE ON t1 +FOR EACH ROW + BEGIN + IF + new.someLabel != old.someLabel + THEN + UPDATE t3 SET t3.flag = 0; + END IF; + END| + +DELIMITER ;| + +FLUSH LOGS; + +LOCK TABLES t1 WRITE, t2 WRITE; +INSERT INTO t2 (data, status) VALUES ('1', 4); +UPDATE t1 SET flag = 1 WHERE id = 1; +INSERT INTO t2 (data, status) VALUES ('2', 4); +UNLOCK TABLES; + +sync_slave_with_master; + +let $diff_tables= master:t1, slave:t1; +--source include/diff_tables.inc +let $diff_tables= master:t2, slave:t2; +--source include/diff_tables.inc +let $diff_tables= master:t3, slave:t3; +--source include/diff_tables.inc + +--connection master +DROP TABLE t1, t2, t3; + +--source include/rpl_end.inc diff --git a/sql/handler.cc b/sql/handler.cc index 10d2991e67c..c20af4e9bc9 100644 --- a/sql/handler.cc +++ b/sql/handler.cc @@ -6030,8 +6030,8 @@ int handler::ha_reset() table->default_column_bitmaps(); pushed_cond= NULL; tracker= NULL; - mark_trx_read_write_done= check_table_binlog_row_based_done= - check_table_binlog_row_based_result= 0; + mark_trx_read_write_done= 0; + clear_cached_table_binlog_row_based_flag(); /* Reset information about pushed engine conditions */ cancel_pushed_idx_cond(); /* Reset information about pushed index conditions */ diff --git a/sql/handler.h b/sql/handler.h index 9af46ea98a2..a777b7c595a 100644 --- a/sql/handler.h +++ b/sql/handler.h @@ -3972,6 +3972,11 @@ protected: public: inline bool check_table_binlog_row_based(bool binlog_row); + inline void clear_cached_table_binlog_row_based_flag() + { + check_table_binlog_row_based_done= 0; + check_table_binlog_row_based_result= 0; + } private: /* Cache result to avoid extra calls */ inline void mark_trx_read_write() diff --git a/sql/sql_base.cc b/sql/sql_base.cc index bda3e649ad3..035c29d8ebc 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -583,6 +583,12 @@ bool close_cached_connection_tables(THD *thd, LEX_STRING *connection) Marks all tables in the list which were used by current substatement (they are marked by its query_id) as free for reuse. + Clear 'check_table_binlog_row_based_done' flag. For tables which were used + by current substatement the flag is cleared as part of 'ha_reset()' call. + For the rest of the open tables not used by current substament if this + flag is enabled as part of current substatement execution, clear the flag + explicitly. + NOTE The reason we reset query_id is that it's not enough to just test if table->query_id != thd->query_id to know if a table is in use. @@ -604,6 +610,8 @@ static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table) table->query_id= 0; table->file->ha_reset(); } + else if (table->file->check_table_binlog_row_based_done) + table->file->clear_cached_table_binlog_row_based_flag(); } } From 95fb88d5469e9d601aa9c2f319d1b561925e9795 Mon Sep 17 00:00:00 2001 From: Sergey Vojtovich Date: Wed, 12 Sep 2018 16:36:45 +0400 Subject: [PATCH 3/4] MDEV-17167 - InnoDB: Failing assertion: table->get_ref_count() == 0 upon truncating a temporary table TRUNCATE expects only one TABLE instance (which is used by TRUNCATE itself) to be open. However this requirement wasn't enforced after "MDEV-5535: Cannot reopen temporary table". Fixed by closing unused table instances before performing TRUNCATE. --- mysql-test/r/temp_table.result | 24 ++++++++++++++++++++++++ mysql-test/t/temp_table.test | 26 ++++++++++++++++++++++++++ sql/sql_class.h | 1 + sql/sql_plist.h | 7 ++++++- sql/sql_truncate.cc | 2 ++ sql/temporary_tables.cc | 30 ++++++++++++++++++++++++++++++ 6 files changed, 89 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/temp_table.result b/mysql-test/r/temp_table.result index b833f4f9768..a89f44f68d4 100644 --- a/mysql-test/r/temp_table.result +++ b/mysql-test/r/temp_table.result @@ -548,3 +548,27 @@ DROP TABLE nonexisting_table, t1; ERROR 42S02: Unknown table 'temp_db.nonexisting_table' # Cleanup DROP DATABASE temp_db; +USE test; +# +# MDEV-17167 - InnoDB: Failing assertion: table->get_ref_count() == 0 +# upon truncating a temporary table +# +CREATE TEMPORARY TABLE t1(a INT) ENGINE=InnoDB; +SELECT * FROM t1 AS t1a1, t1 AS t2a2; +a a +TRUNCATE TABLE t1; +LOCK TABLES t1 WRITE; +TRUNCATE TABLE t1; +SELECT * FROM t1; +a +UNLOCK TABLES; +LOCK TABLES t1 AS t1a1 WRITE, t1 AS t1a2 WRITE; +TRUNCATE TABLE t1; +SELECT * FROM t1 AS t1a1, t1 AS t1a2; +a a +UNLOCK TABLES; +CREATE TABLE t2(a INT) ENGINE=InnoDB; +LOCK TABLES t2 WRITE; +TRUNCATE TABLE t1; +UNLOCK TABLES; +DROP TABLE t1, t2; diff --git a/mysql-test/t/temp_table.test b/mysql-test/t/temp_table.test index b44ae2a0a76..a1e61b31a82 100644 --- a/mysql-test/t/temp_table.test +++ b/mysql-test/t/temp_table.test @@ -596,4 +596,30 @@ DROP TABLE nonexisting_table, t1; --echo # Cleanup DROP DATABASE temp_db; +USE test; + +--echo # +--echo # MDEV-17167 - InnoDB: Failing assertion: table->get_ref_count() == 0 +--echo # upon truncating a temporary table +--echo # +CREATE TEMPORARY TABLE t1(a INT) ENGINE=InnoDB; +SELECT * FROM t1 AS t1a1, t1 AS t2a2; +TRUNCATE TABLE t1; + +LOCK TABLES t1 WRITE; +TRUNCATE TABLE t1; +SELECT * FROM t1; +UNLOCK TABLES; + +LOCK TABLES t1 AS t1a1 WRITE, t1 AS t1a2 WRITE; +TRUNCATE TABLE t1; +SELECT * FROM t1 AS t1a1, t1 AS t1a2; +UNLOCK TABLES; + +CREATE TABLE t2(a INT) ENGINE=InnoDB; +LOCK TABLES t2 WRITE; +TRUNCATE TABLE t1; +UNLOCK TABLES; + +DROP TABLE t1, t2; diff --git a/sql/sql_class.h b/sql/sql_class.h index f640113d946..fac489a44ee 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -4350,6 +4350,7 @@ public: TMP_TABLE_SHARE* save_tmp_table_share(TABLE *table); void restore_tmp_table_share(TMP_TABLE_SHARE *share); + void close_unused_temporary_table_instances(const TABLE_LIST *tl); private: /* Whether a lock has been acquired? */ diff --git a/sql/sql_plist.h b/sql/sql_plist.h index 1274a5a78c0..574a151f956 100644 --- a/sql/sql_plist.h +++ b/sql/sql_plist.h @@ -186,7 +186,12 @@ public: list= &a; current= a.m_first; } - /* Operator for it++ */ + /** + Operator for it++ + + @note since we save next element pointer, caller may remove current element. + Such modification doesn't invalidate iterator. + */ inline T* operator++(int) { T *result= current; diff --git a/sql/sql_truncate.cc b/sql/sql_truncate.cc index a00659e362b..ea4d7399ea3 100644 --- a/sql/sql_truncate.cc +++ b/sql/sql_truncate.cc @@ -396,6 +396,8 @@ bool Sql_cmd_truncate_table::truncate_table(THD *thd, TABLE_LIST *table_ref) /* In RBR, the statement is not binlogged if the table is temporary. */ binlog_stmt= !thd->is_current_stmt_binlog_format_row(); + thd->close_unused_temporary_table_instances(table_ref); + error= handler_truncate(thd, table_ref, TRUE); /* diff --git a/sql/temporary_tables.cc b/sql/temporary_tables.cc index ed23dae06d2..29097092680 100644 --- a/sql/temporary_tables.cc +++ b/sql/temporary_tables.cc @@ -1511,3 +1511,33 @@ void THD::unlock_temporary_tables() DBUG_VOID_RETURN; } + +/** + Close unused TABLE instances for given temporary table. + + @param tl [IN] TABLE_LIST + + Initial use case was TRUNCATE, which expects only one instance (which is used + by TRUNCATE itself) to be open. Most probably some ALTER TABLE variants and + REPAIR may have similar expectations. +*/ + +void THD::close_unused_temporary_table_instances(const TABLE_LIST *tl) +{ + TMP_TABLE_SHARE *share= find_tmp_table_share(tl); + + if (share) + { + All_share_tables_list::Iterator tables_it(share->all_tmp_tables); + + while (TABLE *table= tables_it++) + { + if (table->query_id == 0) + { + /* Note: removing current list element doesn't invalidate iterator. */ + share->all_tmp_tables.remove(table); + free_temporary_table(table); + } + } + } +} From 409e210e74a6dc7a6e267c71ab32677b2bf12103 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Tue, 14 May 2019 15:29:24 +0300 Subject: [PATCH 4/4] MDEV-19449 Got error 168 for valid TRUNCATE (temporary) TABLE Add the test case. The parent commit, which cherry-picked the MDEV-17167 fix from 10.3 (commit bad2f1569da57c4a81cc84ec2f4a79924df9c8d6) fixed the bug. --- mysql-test/r/temp_table.result | 12 ++++++++++++ mysql-test/t/temp_table.test | 16 ++++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/mysql-test/r/temp_table.result b/mysql-test/r/temp_table.result index a89f44f68d4..78ca7a66682 100644 --- a/mysql-test/r/temp_table.result +++ b/mysql-test/r/temp_table.result @@ -572,3 +572,15 @@ LOCK TABLES t2 WRITE; TRUNCATE TABLE t1; UNLOCK TABLES; DROP TABLE t1, t2; +# +# MDEV-19449 1030: Got error 168 "Unknown (generic) error from engine" +# for valid TRUNCATE (temporary) TABLE +# +CREATE TEMPORARY TABLE t1 (col1 BIGINT) ENGINE = InnoDB; +INSERT INTO t1 (no_such_col) SELECT * FROM t1; +ERROR 42S22: Unknown column 'no_such_col' in 'field list' +TRUNCATE TABLE t1; +ALTER TABLE t1 CHANGE no_such_col1 col1 BIGINT NULL; +ERROR 42S22: Unknown column 'no_such_col1' in 't1' +TRUNCATE TABLE t1; +DROP TEMPORARY TABLE t1; diff --git a/mysql-test/t/temp_table.test b/mysql-test/t/temp_table.test index a1e61b31a82..bd3bba34f89 100644 --- a/mysql-test/t/temp_table.test +++ b/mysql-test/t/temp_table.test @@ -623,3 +623,19 @@ TRUNCATE TABLE t1; UNLOCK TABLES; DROP TABLE t1, t2; + +--echo # +--echo # MDEV-19449 1030: Got error 168 "Unknown (generic) error from engine" +--echo # for valid TRUNCATE (temporary) TABLE +--echo # + +CREATE TEMPORARY TABLE t1 (col1 BIGINT) ENGINE = InnoDB; +--error ER_BAD_FIELD_ERROR +INSERT INTO t1 (no_such_col) SELECT * FROM t1; +TRUNCATE TABLE t1; +--error ER_BAD_FIELD_ERROR +ALTER TABLE t1 CHANGE no_such_col1 col1 BIGINT NULL; +# This would wrongly try to re-truncate the old copy of the table that +# was not dropped during the first TRUNCATE due to extra table handles. +TRUNCATE TABLE t1; +DROP TEMPORARY TABLE t1;