Merge work.mysql.com:/home/bk/mysql

into mysql.sashanet.com:/home/sasha/src/bk/mysql


sql/mysql_priv.h:
  Auto merged
sql/mysqld.cc:
  Auto merged
sql/slave.cc:
  Auto merged
sql/sql_class.cc:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_table.cc:
  Auto merged

11 files changed, 89 insertions, 26 deletions

diff --git a/sql/log_event.h b/sql/log_event.h
index c956cfde396..b31d444ad21 100644
--- a/sql/log_event.h
+++ b/sql/log_event.h
@@ -115,7 +115,7 @@ public:
   // otherwise, set it to 0, in which case, we compute it with strlen()
   uint32 db_len;
   uint16 error_code;
-  int thread_id;
+  ulong thread_id;
 #if !defined(MYSQL_CLIENT)
   THD* thd;
   Query_log_event(THD* thd_arg, const char* query_arg):
@@ -186,7 +186,7 @@ protected:
   void copy_log_event(const char *buf, ulong data_len);
 
 public:
-  int thread_id;
+  ulong thread_id;
   uint32 table_name_len;
   uint32 db_len;
   uint32 fname_len;
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 10e470ffc78..efc4183092a 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -401,7 +401,7 @@ void close_temporary_tables(THD *thd);
 TABLE **find_temporary_table(THD *thd, const char *db, const char *table_name);
 bool close_temporary_table(THD *thd, const char *db, const char *table_name);
 void close_temporary(TABLE *table, bool delete_table=1);
-bool rename_temporary_table(TABLE *table, const char *new_db,
+bool rename_temporary_table(THD* thd, TABLE *table, const char *new_db,
 			    const char *table_name);
 void remove_db_from_cache(const my_string db);
 void flush_tables();
@@ -455,7 +455,8 @@ extern ulong refresh_version,flush_version, thread_id,query_id,opened_tables,
 extern ulong filesort_rows, filesort_range_count, filesort_scan_count;
 extern ulong filesort_merge_passes;
 extern ulong select_range_check_count, select_range_count, select_scan_count;
-extern ulong select_full_range_join_count,select_full_join_count;
+extern ulong select_full_range_join_count,select_full_join_count,
+			 slave_open_temp_tables;
 extern uint test_flags,select_errors,mysql_port,ha_open_options;
 extern ulong thd_startup_options, slow_launch_threads, slow_launch_time;
 extern time_t start_time;
diff --git a/sql/mysqlbinlog.cc b/sql/mysqlbinlog.cc
index 21a740ca1f4..0fe9ab21987 100644
--- a/sql/mysqlbinlog.cc
+++ b/sql/mysqlbinlog.cc
@@ -361,8 +361,7 @@ static void dump_local_log_entries(const char* logname)
 	die("Could not read entry at offset %ld : Error in log format or \
 read error",
 	    my_b_tell(file));
-      else
-	die("Could not construct event object");
+      // file->error == 0 means EOF, that's OK, we break in this case
       break;
     }
     if (rec_count >= offset)
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 316b97f5c52..69bcfdd04b4 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -199,7 +199,7 @@ ulong keybuff_size,sortbuff_size,max_item_sort_length,table_cache_size,
       thread_stack_min,net_wait_timeout,what_to_log= ~ (1L << (uint) COM_TIME),
       query_buff_size, lower_case_table_names, mysqld_net_retry_count,
       net_interactive_timeout, slow_launch_time = 2L,
-      net_read_timeout,net_write_timeout;
+      net_read_timeout,net_write_timeout,slave_open_temp_tables=0;
 ulong thread_cache_size=0;
 volatile ulong cached_thread_count=0;
 
@@ -2555,6 +2555,7 @@ struct show_var_st status_vars[]= {
   {"Select_range_check",       (char*) &select_range_check_count, SHOW_LONG},
   {"Select_scan",	       (char*) &select_scan_count,	SHOW_LONG},
   {"Slave_running",            (char*) &slave_running,          SHOW_BOOL},
+  {"Slave_open_temp_tables",   (char*) &slave_open_temp_tables, SHOW_LONG},
   {"Slow_launch_threads",      (char*) &slow_launch_threads,    SHOW_LONG},
   {"Slow_queries",             (char*) &long_query_count,       SHOW_LONG},
   {"Sort_merge_passes",	       (char*) &filesort_merge_passes,  SHOW_LONG},
diff --git a/sql/slave.cc b/sql/slave.cc
index f2636ab5380..c969d7f11ae 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -761,6 +761,7 @@ static int exec_event(THD* thd, NET* net, MASTER_INFO* mi, int event_len)
 	thd->query_error = 0; // clear error
 	thd->net.last_errno = 0;
 	thd->net.last_error[0] = 0;
+	thd->slave_proxy_id = qev->thread_id; // for temp tables
 	mysql_parse(thd, thd->query, q_len);
 	int expected_error,actual_error;
 	if((expected_error = qev->error_code) !=
@@ -781,24 +782,17 @@ static int exec_event(THD* thd, NET* net, MASTER_INFO* mi, int event_len)
       thd->convert_set = 0; // assume no convert for next query
       // unless set explictly
       close_thread_tables(thd);
-      free_root(&thd->mem_root,0);
       
-      if (thd->query_error)
+      if (thd->query_error || thd->fatal_error)
       {
 	sql_print_error("Slave:  error running query '%s' ",
 			qev->query);
+        free_root(&thd->mem_root,0);
 	delete ev;
 	return 1;
       }
-      
+      free_root(&thd->mem_root,0);
       delete ev;
-	    
-      if(thd->fatal_error)
-      {
-	sql_print_error("Slave: Fatal error running query '%s' ",
-			thd->query);
-	return 1;
-      }
 
       mi->inc_pos(event_len);
       flush_master_info(mi);
@@ -874,6 +868,7 @@ static int exec_event(THD* thd, NET* net, MASTER_INFO* mi, int event_len)
 
 	List<Item> fields;
 	lev->set_fields(fields);
+	thd->slave_proxy_id = thd->thread_id;
 	thd->net.vio = net->vio;
 	// mysql_load will use thd->net to read the file
 	thd->net.pkt_nr = net->pkt_nr;
@@ -919,11 +914,13 @@ static int exec_event(THD* thd, NET* net, MASTER_INFO* mi, int event_len)
     }
 
     case START_EVENT:
+      close_temporary_tables(thd);
       mi->inc_pos(event_len);
       flush_master_info(mi);
       break;
                   
     case STOP_EVENT:
+      close_temporary_tables(thd);
       mi->inc_pos(event_len);
       flush_master_info(mi);
       break;
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 3560fc42d49..45bd8959a8e 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -422,11 +422,48 @@ void close_temporary(TABLE *table,bool delete_table)
 void close_temporary_tables(THD *thd)
 {
   TABLE *table,*next;
+  uint init_query_buf_size = 11, query_buf_size; // "drop table "
+  char* query, *p;
+  LINT_INIT(p);
+  query_buf_size = init_query_buf_size;
+  
+  for (table=thd->temporary_tables ; table ; table=table->next)
+  {
+    query_buf_size += table->key_length;
+    
+  }
+
+  if(query_buf_size == init_query_buf_size)
+    return; // no tables to close
+  
+  if((query = alloc_root(&thd->mem_root, query_buf_size)))
+    {
+      memcpy(query, "drop table ", init_query_buf_size);
+      p = query + init_query_buf_size;
+    }
+  
   for (table=thd->temporary_tables ; table ; table=next)
   {
+    if(query) // we might be out of memory, but this is not fatal
+      {
+	p = strmov(p,table->table_cache_key); // here we assume it always starts
+	// with \0 terminated db name
+	*p++ = '.';
+	p = strmov(p,table->table_name);
+	*p++ = ',';
+      }
     next=table->next;
     close_temporary(table);
   }
+  if(query && mysql_bin_log.is_open())
+    {
+      uint save_query_len = thd->query_length;
+      *--p = 0;
+      thd->query_length = (uint)(p-query);
+      Query_log_event qinfo(thd, query);
+      mysql_bin_log.write(&qinfo);
+      thd->query_length = save_query_len;
+    }
   thd->temporary_tables=0;
 }
 
@@ -437,6 +474,9 @@ TABLE **find_temporary_table(THD *thd, const char *db, const char *table_name)
   uint	key_length= (uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
   TABLE *table,**prev;
 
+  *((ulong*)(key+key_length)) = thd->slave_proxy_id;
+  key_length += 4;
+  
   prev= &thd->temporary_tables;
   for (table=thd->temporary_tables ; table ; table=table->next)
   {
@@ -457,21 +497,25 @@ bool close_temporary_table(THD *thd, const char *db, const char *table_name)
   table= *prev;
   *prev= table->next;
   close_temporary(table);
+  if(thd->slave_thread)
+    --slave_open_temp_tables;
   return 0;
 }
 
-bool rename_temporary_table(TABLE *table, const char *db,
+bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
 			    const char *table_name)
 {
   char *key;
   if (!(key=(char*) alloc_root(&table->mem_root,
 			       (uint) strlen(db)+
-			       (uint) strlen(table_name)+2)))
+			       (uint) strlen(table_name)+6)))
     return 1;				/* purecov: inspected */
   table->key_length=(uint)
     (strmov((table->real_name=strmov(table->table_cache_key=key,
 				     db)+1),
 	    table_name) - table->table_cache_key)+1;
+  *((ulong*)(key+table->key_length)) = thd->slave_proxy_id;
+  table->key_length += 4;
   return 0;
 }
 
@@ -624,8 +668,10 @@ TABLE *open_table(THD *thd,const char *db,const char *table_name,
     *refresh=0;
   if (thd->killed)
     DBUG_RETURN(0);
-  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
-
+  key_length= (uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
+  *((ulong*)(key + key_length)) = thd->slave_proxy_id;
+  key_length += 4;
+  
   for (table=thd->temporary_tables; table ; table=table->next)
   {
     if (table->key_length == key_length &&
@@ -1339,8 +1385,14 @@ TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
 {
   TABLE *tmp_table;
   DBUG_ENTER("open_temporary_table");
+  
+  // the extra size in my_malloc() is for table_cache_key
+  //  4 bytes for master thread id if we are in the slave
+  //  1 byte to terminate db
+  //  1 byte to terminate table_name
+  // total of 6 extra bytes in my_malloc in addition to table/db stuff
   if (!(tmp_table=(TABLE*) my_malloc(sizeof(*tmp_table)+(uint) strlen(db)+
-				     (uint) strlen(table_name)+2,
+				     (uint) strlen(table_name)+6,
 				     MYF(MY_WME))))
     DBUG_RETURN(0);				/* purecov: inspected */
 
@@ -1361,10 +1413,16 @@ TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
   tmp_table->key_length= (uint) (strmov(strmov(tmp_table->table_cache_key,db)
 					+1, table_name)
 				 - tmp_table->table_cache_key)+1;
+  *((ulong*)(tmp_table->table_cache_key + tmp_table->key_length)) =
+	thd->slave_proxy_id;
+  tmp_table->key_length += 4;
+  
   if (link_in_list)
   {
     tmp_table->next=thd->temporary_tables;
     thd->temporary_tables=tmp_table;
+    if(thd->slave_thread)
+      ++slave_open_temp_tables;
   }
   DBUG_RETURN(tmp_table);
 }
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 696c111c01a..067e75ceeef 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -98,6 +98,7 @@ THD::THD():user_time(0),fatal_error(0),last_insert_id_used(0),
   start_time=(time_t) 0;
   current_linfo =  0;
   slave_thread = 0;
+  slave_proxy_id = 0;
   last_nx_table = last_nx_db = 0;
   inactive_timeout=net_wait_timeout;
   open_options=ha_open_options;
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 4003b057c06..f90c731ad6b 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -275,6 +275,10 @@ public:
   // if we do a purge of binary logs, log index info of the threads
   // that are currently reading it needs to be adjusted. To do that
   // each thread that is using LOG_INFO needs to adjust the pointer to it
+
+  ulong slave_proxy_id; // in slave thread we need to know in behalf of which
+  // thread the query is being run to replicate temp tables properly 
+  
   THD();
   ~THD();
   bool store_globals();
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 195a7a4f525..06335b36284 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -860,7 +860,7 @@ mysql_execute_command(void)
   TABLE_LIST *tables=(TABLE_LIST*) lex->table_list.first;
   DBUG_ENTER("mysql_execute_command");
 
-  if(thd->slave_thread && table_rules_on && tables && !tables_ok(thd,tables))
+  if(table_rules_on && thd->slave_thread && tables && !tables_ok(thd,tables))
     DBUG_VOID_RETURN; // skip if we are in the slave thread, some table
   // rules have been given and the table list says the query should not be
   // replicated
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 2c59f4b3482..a300808e6c3 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -1437,7 +1437,7 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name,
     }
     /* Remove link to old table and rename the new one */
     close_temporary_table(thd,table->table_cache_key,table_name);
-    if (rename_temporary_table(new_table, new_db, new_name))
+    if (rename_temporary_table(thd, new_table, new_db, new_name))
     {						// Fatal error
       close_temporary_table(thd,new_db,tmp_name);
       my_free((gptr) new_table,MYF(0));
@@ -1615,6 +1615,8 @@ copy_data_between_tables(TABLE *from,TABLE *to,
       (copy_end++)->set(*ptr,def->field,0);
   }
 
+  found_count=delete_count=0;
+
   if(order) {
     from->io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE),
                                          MYF(MY_FAE | MY_ZEROFILL));
@@ -1632,7 +1634,6 @@ copy_data_between_tables(TABLE *from,TABLE *to,
 
   init_read_record(&info, thd, from, (SQL_SELECT *) 0, 1,1);
 
-  found_count=delete_count=0;
   next_field=to->next_number_field;
   while (!(error=info.read_record(&info)))
   {
diff --git a/sql/unireg.h b/sql/unireg.h
index c293433dd42..9f078ef3766 100644
--- a/sql/unireg.h
+++ b/sql/unireg.h
@@ -41,7 +41,8 @@
 
 #define ERRMAPP 1				/* Errormap f|r my_error */
 #define LIBLEN FN_REFLEN-FN_LEN			/* Max l{ngd p} dev */
-#define MAX_DBKEY_LENGTH (FN_LEN*2+2)
+#define MAX_DBKEY_LENGTH (FN_LEN*2+6)           /* extra 4 bytes for slave tmp
+						 * tables */
 #define MAX_FIELD_NAME 34			/* Max colum name length +2 */
 #define MAX_KEY 32				/* Max used keys */
 #define MAX_REF_PARTS 16			/* Max parts used as ref */