From 95334ac6c724b42da5c1960f4546b6e9670e83d6 Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 19 Aug 2004 00:29:11 +0200 Subject: [PATCH] Fix for BUG#4971 "CREATE TABLE ... TYPE=HEAP SELECT ... stops slave (wrong DELETE in binlog)": replacing the no_log argument of mysql_create_table() by some safer method (temporarily setting OPTION_BIN_LOG to 0) which guarantees that even the automatic DELETE FROM heap_table does not get into the binlog when a not-yet-existing HEAP table is opened by mysql_create_table(). mysql-test/r/rpl_heap.result: result update mysql-test/t/rpl_heap.test: testing a bug sql/log.cc: new class Disable_binlog used to temporarily disable binlogging for one thread. sql/mysql_priv.h: removing argument no_log from mysql_create_table(); no_log was perfect as some binlogging could still be done by open_unireg_entry() for a HEAP table. sql/sql_class.h: new class Disable_binlog used to temporarily disable binlogging for one thread. sql/sql_parse.cc: removing no_log sql/sql_table.cc: removing no_log from mysql_create_table(); instead using new class Disable_binlog. Disabling binlogging in some cases, where the binlogging is done later by some other code (case of CREATE SELECT and ALTER). --- mysql-test/r/rpl_heap.result | 12 ++++++------ mysql-test/t/rpl_heap.test | 6 ++++-- sql/log.cc | 16 ++++++++++++++++ sql/mysql_priv.h | 2 +- sql/sql_class.h | 21 +++++++++++++++++++++ sql/sql_parse.cc | 2 +- sql/sql_table.cc | 28 +++++++++++++++++++++------- 7 files changed, 70 insertions(+), 17 deletions(-) diff --git a/mysql-test/r/rpl_heap.result b/mysql-test/r/rpl_heap.result index 1556bcd5f25..1facbcb7676 100644 --- a/mysql-test/r/rpl_heap.result +++ b/mysql-test/r/rpl_heap.result @@ -1,22 +1,22 @@ reset master; drop table if exists t1; -create table t1 (a int) type=HEAP; -insert into t1 values(10); +create table t1 type=HEAP select 10 as a; +insert into t1 values(11); show binlog events from 79; Log_name Pos Event_type Server_id Orig_log_pos Info -master-bin.001 79 Query 1 79 use `test`; create table t1 (a int) type=HEAP -master-bin.001 147 Query 1 147 use `test`; DELETE FROM `test`.`t1` -master-bin.001 205 Query 1 205 use `test`; insert into t1 values(10) +master-bin.001 79 Query 1 79 use `test`; create table t1 type=HEAP select 10 as a +master-bin.001 154 Query 1 154 use `test`; insert into t1 values(11) reset slave; start slave; show create table t1; Table Create Table t1 CREATE TABLE `t1` ( - `a` int(11) default NULL + `a` bigint(2) NOT NULL default '0' ) TYPE=HEAP select * from t1; a 10 +11 select * from t1; a select * from t1 limit 10; diff --git a/mysql-test/t/rpl_heap.test b/mysql-test/t/rpl_heap.test index 15f61918034..0bc71eaf30c 100644 --- a/mysql-test/t/rpl_heap.test +++ b/mysql-test/t/rpl_heap.test @@ -13,8 +13,10 @@ connect (slave,localhost,root,,test,0,slave.sock); connection master; reset master; drop table if exists t1; -create table t1 (a int) type=HEAP; -insert into t1 values(10); +# we use CREATE SELECT to verify that DELETE does not get into binlog +# before CREATE SELECT +create table t1 type=HEAP select 10 as a; +insert into t1 values(11); save_master_pos; show binlog events from 79; connection slave; diff --git a/sql/log.cc b/sql/log.cc index e031656cc6e..2956efc047f 100644 --- a/sql/log.cc +++ b/sql/log.cc @@ -1627,6 +1627,22 @@ void MYSQL_LOG::set_max_size(ulong max_size_arg) } +Disable_binlog::Disable_binlog(THD *thd_arg) : + thd(thd_arg), + save_options(thd_arg->options), save_master_access(thd_arg->master_access) +{ + thd_arg->options&= ~OPTION_BIN_LOG; + thd_arg->master_access|= SUPER_ACL; // unneeded in 4.1 +}; + + +Disable_binlog::~Disable_binlog() +{ + thd->options= save_options; + thd->master_access= save_master_access; +} + + /* Check if a string is a valid number diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index 2e893ead407..ca4b8d2c2b9 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -438,7 +438,7 @@ Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type, int mysql_create_table(THD *thd,const char *db, const char *table_name, HA_CREATE_INFO *create_info, List &fields, List &keys, - bool tmp_table, bool no_log); + bool tmp_table); TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, const char *db, const char *name, List *extra_fields, diff --git a/sql/sql_class.h b/sql/sql_class.h index e646d33fe5d..8284cd23b9e 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -638,6 +638,27 @@ public: #define SYSTEM_THREAD_SLAVE_IO 2 #define SYSTEM_THREAD_SLAVE_SQL 4 +/* + Disables binary logging for one thread, and resets it back to what it was + before being disabled. + Some functions (like the internal mysql_create_table() when it's called by + mysql_alter_table()) must NOT write to the binlog (binlogging is done at the + at a later stage of the command already, and must be, for locking reasons); + so we internally disable it temporarily by creating the Disable_binlog + object and reset the state by destroying the object (don't forget that! or + write code so that the object gets automatically destroyed when leaving a + function...). +*/ +class Disable_binlog { +private: + THD *thd; + ulong save_options; + ulong save_master_access; +public: + Disable_binlog(THD *thd_arg); + ~Disable_binlog(); +}; + /* Used to hold information about file and file structure in exchainge via non-DB file (...INTO OUTFILE..., ...LOAD DATA...) diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 39c1a78b081..7a5260a78f0 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -1692,7 +1692,7 @@ mysql_execute_command(void) tables->real_name, &lex->create_info, lex->create_list, - lex->key_list,0, 0); // do logging + lex->key_list,0); if (!res) send_ok(&thd->net); } diff --git a/sql/sql_table.cc b/sql/sql_table.cc index 7f4a8583b78..c09892ac48b 100644 --- a/sql/sql_table.cc +++ b/sql/sql_table.cc @@ -336,7 +336,6 @@ static int sort_keys(KEY *a, KEY *b) keys List of keys to create tmp_table Set to 1 if this is an internal temporary table (From ALTER TABLE) - no_log Don't log the query to binary log. DESCRIPTION If one creates a temporary table, this is automaticly opened @@ -354,7 +353,7 @@ static int sort_keys(KEY *a, KEY *b) int mysql_create_table(THD *thd,const char *db, const char *table_name, HA_CREATE_INFO *create_info, List &fields, - List &keys,bool tmp_table,bool no_log) + List &keys,bool tmp_table) { char path[FN_REFLEN]; const char *key_name, *alias; @@ -779,7 +778,7 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name, goto end; } } - if (!tmp_table && !no_log) + if (!tmp_table) { // Must be written before unlock mysql_update_log.write(thd,thd->query, thd->query_length); @@ -843,6 +842,7 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, TABLE tmp_table; // Used during 'create_field()' TABLE *table; tmp_table.table_name=0; + Disable_binlog disable_binlog(thd); DBUG_ENTER("create_table_from_items"); /* Add selected items to field list */ @@ -873,9 +873,17 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, } /* create and lock table */ /* QQ: This should be done atomic ! */ + /* We don't log the statement, it will be logged later */ if (mysql_create_table(thd,db,name,create_info,*extra_fields, - *keys,0,1)) // no logging + *keys,0)) DBUG_RETURN(0); + /* + If this is a HEAP table, the automatic DELETE FROM which is written to the + binlog when a HEAP table is opened for the first time since startup, must + not be written: 1) it would be wrong (imagine we're in CREATE SELECT: we + don't want to delete from it) 2) it would be written before the CREATE + TABLE, which is a wrong order. So we keep binary logging disabled. + */ if (!(table=open_table(thd,db,name,name,(bool*) 0))) { quick_rm_table(create_info->db_type,db,table_case_name(create_info,name)); @@ -892,6 +900,7 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, } table->file->extra(HA_EXTRA_WRITE_CACHE); DBUG_RETURN(table); + /* Note that leaving the function resets binlogging properties */ } @@ -1753,6 +1762,7 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name, List_iterator key_it(keys); List_iterator field_it(create_list); List key_parts; + Disable_binlog *disable_binlog; KEY *key_info=table->key_info; for (uint i=0 ; i < table->keys ; i++,key_info++) @@ -1915,12 +1925,16 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name, } else create_info->data_file_name=create_info->index_file_name=0; - + /* We don't log the statement, it will be logged later */ + disable_binlog= new Disable_binlog(thd); if ((error=mysql_create_table(thd, new_db, tmp_name, create_info, - create_list,key_list,1,1))) // no logging + create_list,key_list,1))) + { + delete disable_binlog; DBUG_RETURN(error); - + } + delete disable_binlog; // reset binlogging properties for next code lines if (table->tmp_table) new_table=open_table(thd,new_db,tmp_name,tmp_name,0); else