From d953bc7a648b57dd138fb558a3de4e3858415275 Mon Sep 17 00:00:00 2001
From: unknown <sasha@asksasha.com>
Date: Tue, 2 Aug 2005 15:13:56 -0600
Subject: [PATCH 1/9] Added a test case for BUG#10456

mysql-test/r/rpl_insert_select.result:
  New BitKeeper file ``mysql-test/r/rpl_insert_select.result''
---
 mysql-test/r/rpl_insert_select.result | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 mysql-test/r/rpl_insert_select.result

diff --git a/mysql-test/r/rpl_insert_select.result b/mysql-test/r/rpl_insert_select.result
new file mode 100644
index 00000000000..1aff39e0026
--- /dev/null
+++ b/mysql-test/r/rpl_insert_select.result
@@ -0,0 +1,17 @@
+stop slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+reset master;
+reset slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+start slave;
+create table t1 (n int not null primary key);
+insert into t1 values (1);
+create table t2 (n int);
+insert into t2 values (1);
+insert ignore into t1 select * from t2;
+insert into t1 values (2);
+select * from t1;
+n
+1
+2
+drop table t1,t2;

From bbb2bfe1b7386ea7c87e671d06175dc1b1e4c760 Mon Sep 17 00:00:00 2001
From: unknown <sasha@asksasha.com>
Date: Tue, 2 Aug 2005 15:15:28 -0600
Subject: [PATCH 2/9] The earlier commit for BUG#10456 did not add the test
 file

mysql-test/t/rpl_insert_select.test:
  New BitKeeper file ``mysql-test/t/rpl_insert_select.test''
---
 mysql-test/t/rpl_insert_select.test | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 mysql-test/t/rpl_insert_select.test

diff --git a/mysql-test/t/rpl_insert_select.test b/mysql-test/t/rpl_insert_select.test
new file mode 100644
index 00000000000..677be526982
--- /dev/null
+++ b/mysql-test/t/rpl_insert_select.test
@@ -0,0 +1,19 @@
+# Testcase for BUG#10456 - INSERT INTO ... SELECT violating a primary key
+# breaks replication
+
+-- source include/master-slave.inc
+connection master;
+
+create table t1 (n int not null primary key);
+insert into t1 values (1);
+create table t2 (n int);
+insert into t2 values (1);
+insert ignore into t1 select * from t2;
+insert into t1 values (2);
+sync_slave_with_master;
+connection slave;
+select * from t1;
+
+connection master;
+drop table t1,t2;
+sync_slave_with_master;

From ec657e8d2a350ba94cecc6e6fbf1809682d93fd3 Mon Sep 17 00:00:00 2001
From: unknown <sasha@asksasha.com>
Date: Wed, 3 Aug 2005 18:08:20 -0600
Subject: [PATCH 3/9] patch for BUG#4680 - drop database breaking replication
 if there were extra files in the database directory on the master

mysql-test/r/rpl_drop_db.result:
  New BitKeeper file ``mysql-test/r/rpl_drop_db.result''
mysql-test/t/rpl_drop_db.test:
  New BitKeeper file ``mysql-test/t/rpl_drop_db.test''
---
 mysql-test/r/rpl_drop_db.result | 30 ++++++++++++++++++++++
 mysql-test/t/rpl_drop_db.test   | 39 ++++++++++++++++++++++++++++
 sql/mysql_priv.h                |  2 +-
 sql/sql_db.cc                   | 45 +++++++++++++++++++++++++++++----
 sql/sql_table.cc                | 20 ++++++++++++++-
 5 files changed, 129 insertions(+), 7 deletions(-)
 create mode 100644 mysql-test/r/rpl_drop_db.result
 create mode 100644 mysql-test/t/rpl_drop_db.test

diff --git a/mysql-test/r/rpl_drop_db.result b/mysql-test/r/rpl_drop_db.result
new file mode 100644
index 00000000000..bafbfe3a1ed
--- /dev/null
+++ b/mysql-test/r/rpl_drop_db.result
@@ -0,0 +1,30 @@
+stop slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+reset master;
+reset slave;
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+start slave;
+drop database if exists d1;
+create database d1;
+create table d1.t1 (n int);
+insert into d1.t1 values (1);
+select * from d1.t1 into outfile 'd1/f1.txt';
+create table d1.t2 (n int);
+create table d1.t3 (n int);
+drop database d1;
+ERROR HY000: Error dropping database (can't rmdir './d1/', errno: 17)
+use d1;
+show tables;
+Tables_in_d1
+use test;
+create table t1 (n int);
+insert into t1 values (1234);
+use d1;
+show tables;
+Tables_in_d1
+use test;
+select * from t1;
+n
+1234
+drop table t1;
+stop slave;
diff --git a/mysql-test/t/rpl_drop_db.test b/mysql-test/t/rpl_drop_db.test
new file mode 100644
index 00000000000..ef0ab4be6fd
--- /dev/null
+++ b/mysql-test/t/rpl_drop_db.test
@@ -0,0 +1,39 @@
+# test case for BUG#4680 -- if there are extra files in the db directory
+# dropping the db on the master causes replication problems
+
+-- source include/master-slave.inc
+connection master;
+
+--disable_warnings
+drop database if exists d1;
+--enable_warnings
+create database d1;
+create table d1.t1 (n int);
+insert into d1.t1 values (1);
+select * from d1.t1 into outfile 'd1/f1.txt';
+create table d1.t2 (n int);
+create table d1.t3 (n int);
+--error 1010
+drop database d1;
+use d1;
+show tables;
+use test;
+create table t1 (n int);
+insert into t1 values (1234);
+sync_slave_with_master;
+
+connection slave;
+use d1;
+show tables;
+use test;
+select * from t1;
+
+connection master;
+drop table t1;
+sync_slave_with_master;
+
+#cleanup
+connection slave;
+stop slave;
+system rm -rf var/master-data/d1;
+
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 6969433649f..9d46cc507df 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -441,7 +441,7 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
 			 bool drop_temporary, bool log_query);
 int mysql_rm_table_part2_with_lock(THD *thd, TABLE_LIST *tables,
 				   bool if_exists, bool drop_temporary,
-				   bool log_query);
+				   bool log_query, List<String> *dropped_tables);
 int quick_rm_table(enum db_type base,const char *db,
 		   const char *table_name);
 bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list);
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index ad6845572e1..0155fca0466 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -31,7 +31,7 @@ static TYPELIB deletable_extentions=
 
 static long mysql_rm_known_files(THD *thd, MY_DIR *dirp,
 				 const char *db, const char *path,
-				 uint level);
+				 uint level, List<String> *dropped_tables);
 
 /* Database options hash */
 static HASH dboptions;
@@ -584,6 +584,7 @@ int mysql_rm_db(THD *thd,char *db,bool if_exists, bool silent)
   int error= 0;
   char	path[FN_REFLEN+16], tmp_db[NAME_LEN+1];
   MY_DIR *dirp;
+  List<String> dropped_tables;
   uint length;
   DBUG_ENTER("mysql_rm_db");
 
@@ -621,8 +622,10 @@ int mysql_rm_db(THD *thd,char *db,bool if_exists, bool silent)
     remove_db_from_cache(db);
     pthread_mutex_unlock(&LOCK_open);
 
+    
     error= -1;
-    if ((deleted= mysql_rm_known_files(thd, dirp, db, path, 0)) >= 0)
+    if ((deleted= mysql_rm_known_files(thd, dirp, db, path, 0,
+          &dropped_tables)) >= 0)
     {
       ha_drop_database(path);
       query_cache_invalidate1(db);
@@ -672,6 +675,37 @@ int mysql_rm_db(THD *thd,char *db,bool if_exists, bool silent)
     send_ok(thd, (ulong) deleted);
     thd->server_status&= ~SERVER_STATUS_DB_DROPPED;
   }
+  else if (!dropped_tables.is_empty() && mysql_bin_log.is_open())
+  {
+     List_iterator<String> it(dropped_tables);
+     String* dropped_table;
+     int q_len= 11; /* drop table */ 
+     int db_len= strlen(db);
+     
+     for (;(dropped_table= it++);)
+     {
+       q_len += dropped_table->length() + 2 + db_len;
+     }
+     q_len--; /* no last comma */
+     
+     char* query= thd->alloc(q_len);
+     if (!query)
+       goto exit; /* not much else we can do */
+     char* p= strmov(query,"drop table ");  
+     it.rewind();
+     
+     for (;(dropped_table= it++);)
+     {
+       p= strmov(p,db);
+       *p++ = '.';
+       p= strnmov(p,dropped_table->ptr(),dropped_table->length());
+       *p++ = ',';
+     }
+     *--p= 0;
+     Query_log_event qinfo(thd, query, q_len, 0, 0);
+     qinfo.error_code= 0;
+     mysql_bin_log.write(&qinfo);
+  }
 
 exit:
   start_waiting_global_read_lock(thd);
@@ -716,7 +750,7 @@ exit2:
 */
 
 static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db,
-				 const char *org_path, uint level)
+				 const char *org_path, uint level, List<String> *dropped_tables)
 {
   long deleted=0;
   ulong found_other_files=0;
@@ -758,7 +792,7 @@ static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db,
       if ((new_dirp = my_dir(newpath,MYF(MY_DONT_SORT))))
       {
 	DBUG_PRINT("my",("New subdir found: %s", newpath));
-	if ((mysql_rm_known_files(thd, new_dirp, NullS, newpath,1)) < 0)
+	if ((mysql_rm_known_files(thd, new_dirp, NullS, newpath,1,0)) < 0)
 	  goto err;
 	if (!(copy_of_path= thd->memdup(newpath, length+1)) ||
 	    !(dir= new (thd->mem_root) String(copy_of_path, length,
@@ -805,7 +839,8 @@ static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db,
     }
   }
   if (thd->killed ||
-      (tot_list && mysql_rm_table_part2_with_lock(thd, tot_list, 1, 0, 1)))
+      (tot_list && mysql_rm_table_part2_with_lock(thd, tot_list, 1, 0, 
+           1,dropped_tables)))
     goto err;
 
   /* Remove RAID directories */
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 87b864c73fa..e948a65f301 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -156,7 +156,8 @@ int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
 
 int mysql_rm_table_part2_with_lock(THD *thd,
 				   TABLE_LIST *tables, bool if_exists,
-				   bool drop_temporary, bool dont_log_query)
+				   bool drop_temporary, bool dont_log_query,
+           List<String>* dropped_tables)
 {
   int error;
   thd->mysys_var->current_mutex= &LOCK_open;
@@ -165,6 +166,23 @@ int mysql_rm_table_part2_with_lock(THD *thd,
 
   error=mysql_rm_table_part2(thd,tables, if_exists, drop_temporary,
 			     dont_log_query);
+  /*
+    For now we assume that if we got success all the tables in the list 
+    were actually dropped, otherwise, assume none were dropped.
+    TODO: fix it to work with a partial drop - extremely rare case, but
+    can happen.
+  */         
+  if (!error && dropped_tables)
+  {         
+    TABLE_LIST* tbl;
+    
+    for (tbl= tables; tbl; tbl= tbl->next)
+    {
+      String *dropped_table= new (thd->mem_root) 
+         String(tbl->real_name,&my_charset_latin1);
+      dropped_tables->push_back(dropped_table); 
+    } 
+  }        
 
   pthread_mutex_unlock(&LOCK_open);
 

From 4652c6b0539032fe2f3654f8ec95153ac6eb9305 Mon Sep 17 00:00:00 2001
From: unknown <sasha@asksasha.com>
Date: Thu, 18 Aug 2005 21:40:14 -0600
Subject: [PATCH 4/9] updated patch for BUG#4680 (incomplete DROP DATABASE
 breaking replication). We binlog the DROP TABLE for each table that was
 actually dropped. Per Sergei's suggestion a fixed buffer for the DROP TABLE
 query is pre-allocated from THD pool, and logging now is done in batches -
 new batch is started if the buffer becomes full. Reduced memory usage by
 reusing the table list instead of accumulating a list of dropped table names.
 Also fixed the problem if the table was not actually dropped, eg due to
 permissions. Extended the test case to make sure batched query logging does
 work.

mysql-test/r/rpl_drop_db.result:
  test for query buffer overrun
mysql-test/t/rpl_drop_db.test:
  test for query buffer overrun
sql/mysql_priv.h:
  updated patch for BUG#4680 (incomplete DROP DATABASE breaking replication)
BitKeeper/etc/ignore:
  Added support-files/MacOSX/postflight support-files/MacOSX/preflight to the ignore list
sql/sql_db.cc:
  updated patch for BUG#4680 (incomplete DROP DATABASE breaking replication)
sql/sql_table.cc:
  updated patch for BUG#4680 (incomplete DROP DATABASE breaking replication)
sql/table.h:
  updated patch for BUG#4680 (incomplete DROP DATABASE breaking replication)
---
 .bzrignore                      |    2 +
 mysql-test/r/rpl_drop_db.result | 1005 +++++++++++++++++++++++++++++++
 mysql-test/t/rpl_drop_db.test   |   13 +
 sql/mysql_priv.h                |    2 +-
 sql/sql_db.cc                   |   85 ++-
 sql/sql_table.cc                |   23 +-
 sql/table.h                     |    3 +
 7 files changed, 1085 insertions(+), 48 deletions(-)

diff --git a/.bzrignore b/.bzrignore
index 7a10ce9db69..f9f9c146692 100644
--- a/.bzrignore
+++ b/.bzrignore
@@ -1054,3 +1054,5 @@ vio/test-sslclient
 vio/test-sslserver
 vio/viotest-ssl
 ndb/tools/ndb_config
+support-files/MacOSX/postflight
+support-files/MacOSX/preflight
diff --git a/mysql-test/r/rpl_drop_db.result b/mysql-test/r/rpl_drop_db.result
index bafbfe3a1ed..01a2af5341b 100644
--- a/mysql-test/r/rpl_drop_db.result
+++ b/mysql-test/r/rpl_drop_db.result
@@ -16,6 +16,1011 @@ ERROR HY000: Error dropping database (can't rmdir './d1/', errno: 17)
 use d1;
 show tables;
 Tables_in_d1
+create table d1.t1000(n int);
+create table d1.t999(n int);
+create table d1.t998(n int);
+create table d1.t997(n int);
+create table d1.t996(n int);
+create table d1.t995(n int);
+create table d1.t994(n int);
+create table d1.t993(n int);
+create table d1.t992(n int);
+create table d1.t991(n int);
+create table d1.t990(n int);
+create table d1.t989(n int);
+create table d1.t988(n int);
+create table d1.t987(n int);
+create table d1.t986(n int);
+create table d1.t985(n int);
+create table d1.t984(n int);
+create table d1.t983(n int);
+create table d1.t982(n int);
+create table d1.t981(n int);
+create table d1.t980(n int);
+create table d1.t979(n int);
+create table d1.t978(n int);
+create table d1.t977(n int);
+create table d1.t976(n int);
+create table d1.t975(n int);
+create table d1.t974(n int);
+create table d1.t973(n int);
+create table d1.t972(n int);
+create table d1.t971(n int);
+create table d1.t970(n int);
+create table d1.t969(n int);
+create table d1.t968(n int);
+create table d1.t967(n int);
+create table d1.t966(n int);
+create table d1.t965(n int);
+create table d1.t964(n int);
+create table d1.t963(n int);
+create table d1.t962(n int);
+create table d1.t961(n int);
+create table d1.t960(n int);
+create table d1.t959(n int);
+create table d1.t958(n int);
+create table d1.t957(n int);
+create table d1.t956(n int);
+create table d1.t955(n int);
+create table d1.t954(n int);
+create table d1.t953(n int);
+create table d1.t952(n int);
+create table d1.t951(n int);
+create table d1.t950(n int);
+create table d1.t949(n int);
+create table d1.t948(n int);
+create table d1.t947(n int);
+create table d1.t946(n int);
+create table d1.t945(n int);
+create table d1.t944(n int);
+create table d1.t943(n int);
+create table d1.t942(n int);
+create table d1.t941(n int);
+create table d1.t940(n int);
+create table d1.t939(n int);
+create table d1.t938(n int);
+create table d1.t937(n int);
+create table d1.t936(n int);
+create table d1.t935(n int);
+create table d1.t934(n int);
+create table d1.t933(n int);
+create table d1.t932(n int);
+create table d1.t931(n int);
+create table d1.t930(n int);
+create table d1.t929(n int);
+create table d1.t928(n int);
+create table d1.t927(n int);
+create table d1.t926(n int);
+create table d1.t925(n int);
+create table d1.t924(n int);
+create table d1.t923(n int);
+create table d1.t922(n int);
+create table d1.t921(n int);
+create table d1.t920(n int);
+create table d1.t919(n int);
+create table d1.t918(n int);
+create table d1.t917(n int);
+create table d1.t916(n int);
+create table d1.t915(n int);
+create table d1.t914(n int);
+create table d1.t913(n int);
+create table d1.t912(n int);
+create table d1.t911(n int);
+create table d1.t910(n int);
+create table d1.t909(n int);
+create table d1.t908(n int);
+create table d1.t907(n int);
+create table d1.t906(n int);
+create table d1.t905(n int);
+create table d1.t904(n int);
+create table d1.t903(n int);
+create table d1.t902(n int);
+create table d1.t901(n int);
+create table d1.t900(n int);
+create table d1.t899(n int);
+create table d1.t898(n int);
+create table d1.t897(n int);
+create table d1.t896(n int);
+create table d1.t895(n int);
+create table d1.t894(n int);
+create table d1.t893(n int);
+create table d1.t892(n int);
+create table d1.t891(n int);
+create table d1.t890(n int);
+create table d1.t889(n int);
+create table d1.t888(n int);
+create table d1.t887(n int);
+create table d1.t886(n int);
+create table d1.t885(n int);
+create table d1.t884(n int);
+create table d1.t883(n int);
+create table d1.t882(n int);
+create table d1.t881(n int);
+create table d1.t880(n int);
+create table d1.t879(n int);
+create table d1.t878(n int);
+create table d1.t877(n int);
+create table d1.t876(n int);
+create table d1.t875(n int);
+create table d1.t874(n int);
+create table d1.t873(n int);
+create table d1.t872(n int);
+create table d1.t871(n int);
+create table d1.t870(n int);
+create table d1.t869(n int);
+create table d1.t868(n int);
+create table d1.t867(n int);
+create table d1.t866(n int);
+create table d1.t865(n int);
+create table d1.t864(n int);
+create table d1.t863(n int);
+create table d1.t862(n int);
+create table d1.t861(n int);
+create table d1.t860(n int);
+create table d1.t859(n int);
+create table d1.t858(n int);
+create table d1.t857(n int);
+create table d1.t856(n int);
+create table d1.t855(n int);
+create table d1.t854(n int);
+create table d1.t853(n int);
+create table d1.t852(n int);
+create table d1.t851(n int);
+create table d1.t850(n int);
+create table d1.t849(n int);
+create table d1.t848(n int);
+create table d1.t847(n int);
+create table d1.t846(n int);
+create table d1.t845(n int);
+create table d1.t844(n int);
+create table d1.t843(n int);
+create table d1.t842(n int);
+create table d1.t841(n int);
+create table d1.t840(n int);
+create table d1.t839(n int);
+create table d1.t838(n int);
+create table d1.t837(n int);
+create table d1.t836(n int);
+create table d1.t835(n int);
+create table d1.t834(n int);
+create table d1.t833(n int);
+create table d1.t832(n int);
+create table d1.t831(n int);
+create table d1.t830(n int);
+create table d1.t829(n int);
+create table d1.t828(n int);
+create table d1.t827(n int);
+create table d1.t826(n int);
+create table d1.t825(n int);
+create table d1.t824(n int);
+create table d1.t823(n int);
+create table d1.t822(n int);
+create table d1.t821(n int);
+create table d1.t820(n int);
+create table d1.t819(n int);
+create table d1.t818(n int);
+create table d1.t817(n int);
+create table d1.t816(n int);
+create table d1.t815(n int);
+create table d1.t814(n int);
+create table d1.t813(n int);
+create table d1.t812(n int);
+create table d1.t811(n int);
+create table d1.t810(n int);
+create table d1.t809(n int);
+create table d1.t808(n int);
+create table d1.t807(n int);
+create table d1.t806(n int);
+create table d1.t805(n int);
+create table d1.t804(n int);
+create table d1.t803(n int);
+create table d1.t802(n int);
+create table d1.t801(n int);
+create table d1.t800(n int);
+create table d1.t799(n int);
+create table d1.t798(n int);
+create table d1.t797(n int);
+create table d1.t796(n int);
+create table d1.t795(n int);
+create table d1.t794(n int);
+create table d1.t793(n int);
+create table d1.t792(n int);
+create table d1.t791(n int);
+create table d1.t790(n int);
+create table d1.t789(n int);
+create table d1.t788(n int);
+create table d1.t787(n int);
+create table d1.t786(n int);
+create table d1.t785(n int);
+create table d1.t784(n int);
+create table d1.t783(n int);
+create table d1.t782(n int);
+create table d1.t781(n int);
+create table d1.t780(n int);
+create table d1.t779(n int);
+create table d1.t778(n int);
+create table d1.t777(n int);
+create table d1.t776(n int);
+create table d1.t775(n int);
+create table d1.t774(n int);
+create table d1.t773(n int);
+create table d1.t772(n int);
+create table d1.t771(n int);
+create table d1.t770(n int);
+create table d1.t769(n int);
+create table d1.t768(n int);
+create table d1.t767(n int);
+create table d1.t766(n int);
+create table d1.t765(n int);
+create table d1.t764(n int);
+create table d1.t763(n int);
+create table d1.t762(n int);
+create table d1.t761(n int);
+create table d1.t760(n int);
+create table d1.t759(n int);
+create table d1.t758(n int);
+create table d1.t757(n int);
+create table d1.t756(n int);
+create table d1.t755(n int);
+create table d1.t754(n int);
+create table d1.t753(n int);
+create table d1.t752(n int);
+create table d1.t751(n int);
+create table d1.t750(n int);
+create table d1.t749(n int);
+create table d1.t748(n int);
+create table d1.t747(n int);
+create table d1.t746(n int);
+create table d1.t745(n int);
+create table d1.t744(n int);
+create table d1.t743(n int);
+create table d1.t742(n int);
+create table d1.t741(n int);
+create table d1.t740(n int);
+create table d1.t739(n int);
+create table d1.t738(n int);
+create table d1.t737(n int);
+create table d1.t736(n int);
+create table d1.t735(n int);
+create table d1.t734(n int);
+create table d1.t733(n int);
+create table d1.t732(n int);
+create table d1.t731(n int);
+create table d1.t730(n int);
+create table d1.t729(n int);
+create table d1.t728(n int);
+create table d1.t727(n int);
+create table d1.t726(n int);
+create table d1.t725(n int);
+create table d1.t724(n int);
+create table d1.t723(n int);
+create table d1.t722(n int);
+create table d1.t721(n int);
+create table d1.t720(n int);
+create table d1.t719(n int);
+create table d1.t718(n int);
+create table d1.t717(n int);
+create table d1.t716(n int);
+create table d1.t715(n int);
+create table d1.t714(n int);
+create table d1.t713(n int);
+create table d1.t712(n int);
+create table d1.t711(n int);
+create table d1.t710(n int);
+create table d1.t709(n int);
+create table d1.t708(n int);
+create table d1.t707(n int);
+create table d1.t706(n int);
+create table d1.t705(n int);
+create table d1.t704(n int);
+create table d1.t703(n int);
+create table d1.t702(n int);
+create table d1.t701(n int);
+create table d1.t700(n int);
+create table d1.t699(n int);
+create table d1.t698(n int);
+create table d1.t697(n int);
+create table d1.t696(n int);
+create table d1.t695(n int);
+create table d1.t694(n int);
+create table d1.t693(n int);
+create table d1.t692(n int);
+create table d1.t691(n int);
+create table d1.t690(n int);
+create table d1.t689(n int);
+create table d1.t688(n int);
+create table d1.t687(n int);
+create table d1.t686(n int);
+create table d1.t685(n int);
+create table d1.t684(n int);
+create table d1.t683(n int);
+create table d1.t682(n int);
+create table d1.t681(n int);
+create table d1.t680(n int);
+create table d1.t679(n int);
+create table d1.t678(n int);
+create table d1.t677(n int);
+create table d1.t676(n int);
+create table d1.t675(n int);
+create table d1.t674(n int);
+create table d1.t673(n int);
+create table d1.t672(n int);
+create table d1.t671(n int);
+create table d1.t670(n int);
+create table d1.t669(n int);
+create table d1.t668(n int);
+create table d1.t667(n int);
+create table d1.t666(n int);
+create table d1.t665(n int);
+create table d1.t664(n int);
+create table d1.t663(n int);
+create table d1.t662(n int);
+create table d1.t661(n int);
+create table d1.t660(n int);
+create table d1.t659(n int);
+create table d1.t658(n int);
+create table d1.t657(n int);
+create table d1.t656(n int);
+create table d1.t655(n int);
+create table d1.t654(n int);
+create table d1.t653(n int);
+create table d1.t652(n int);
+create table d1.t651(n int);
+create table d1.t650(n int);
+create table d1.t649(n int);
+create table d1.t648(n int);
+create table d1.t647(n int);
+create table d1.t646(n int);
+create table d1.t645(n int);
+create table d1.t644(n int);
+create table d1.t643(n int);
+create table d1.t642(n int);
+create table d1.t641(n int);
+create table d1.t640(n int);
+create table d1.t639(n int);
+create table d1.t638(n int);
+create table d1.t637(n int);
+create table d1.t636(n int);
+create table d1.t635(n int);
+create table d1.t634(n int);
+create table d1.t633(n int);
+create table d1.t632(n int);
+create table d1.t631(n int);
+create table d1.t630(n int);
+create table d1.t629(n int);
+create table d1.t628(n int);
+create table d1.t627(n int);
+create table d1.t626(n int);
+create table d1.t625(n int);
+create table d1.t624(n int);
+create table d1.t623(n int);
+create table d1.t622(n int);
+create table d1.t621(n int);
+create table d1.t620(n int);
+create table d1.t619(n int);
+create table d1.t618(n int);
+create table d1.t617(n int);
+create table d1.t616(n int);
+create table d1.t615(n int);
+create table d1.t614(n int);
+create table d1.t613(n int);
+create table d1.t612(n int);
+create table d1.t611(n int);
+create table d1.t610(n int);
+create table d1.t609(n int);
+create table d1.t608(n int);
+create table d1.t607(n int);
+create table d1.t606(n int);
+create table d1.t605(n int);
+create table d1.t604(n int);
+create table d1.t603(n int);
+create table d1.t602(n int);
+create table d1.t601(n int);
+create table d1.t600(n int);
+create table d1.t599(n int);
+create table d1.t598(n int);
+create table d1.t597(n int);
+create table d1.t596(n int);
+create table d1.t595(n int);
+create table d1.t594(n int);
+create table d1.t593(n int);
+create table d1.t592(n int);
+create table d1.t591(n int);
+create table d1.t590(n int);
+create table d1.t589(n int);
+create table d1.t588(n int);
+create table d1.t587(n int);
+create table d1.t586(n int);
+create table d1.t585(n int);
+create table d1.t584(n int);
+create table d1.t583(n int);
+create table d1.t582(n int);
+create table d1.t581(n int);
+create table d1.t580(n int);
+create table d1.t579(n int);
+create table d1.t578(n int);
+create table d1.t577(n int);
+create table d1.t576(n int);
+create table d1.t575(n int);
+create table d1.t574(n int);
+create table d1.t573(n int);
+create table d1.t572(n int);
+create table d1.t571(n int);
+create table d1.t570(n int);
+create table d1.t569(n int);
+create table d1.t568(n int);
+create table d1.t567(n int);
+create table d1.t566(n int);
+create table d1.t565(n int);
+create table d1.t564(n int);
+create table d1.t563(n int);
+create table d1.t562(n int);
+create table d1.t561(n int);
+create table d1.t560(n int);
+create table d1.t559(n int);
+create table d1.t558(n int);
+create table d1.t557(n int);
+create table d1.t556(n int);
+create table d1.t555(n int);
+create table d1.t554(n int);
+create table d1.t553(n int);
+create table d1.t552(n int);
+create table d1.t551(n int);
+create table d1.t550(n int);
+create table d1.t549(n int);
+create table d1.t548(n int);
+create table d1.t547(n int);
+create table d1.t546(n int);
+create table d1.t545(n int);
+create table d1.t544(n int);
+create table d1.t543(n int);
+create table d1.t542(n int);
+create table d1.t541(n int);
+create table d1.t540(n int);
+create table d1.t539(n int);
+create table d1.t538(n int);
+create table d1.t537(n int);
+create table d1.t536(n int);
+create table d1.t535(n int);
+create table d1.t534(n int);
+create table d1.t533(n int);
+create table d1.t532(n int);
+create table d1.t531(n int);
+create table d1.t530(n int);
+create table d1.t529(n int);
+create table d1.t528(n int);
+create table d1.t527(n int);
+create table d1.t526(n int);
+create table d1.t525(n int);
+create table d1.t524(n int);
+create table d1.t523(n int);
+create table d1.t522(n int);
+create table d1.t521(n int);
+create table d1.t520(n int);
+create table d1.t519(n int);
+create table d1.t518(n int);
+create table d1.t517(n int);
+create table d1.t516(n int);
+create table d1.t515(n int);
+create table d1.t514(n int);
+create table d1.t513(n int);
+create table d1.t512(n int);
+create table d1.t511(n int);
+create table d1.t510(n int);
+create table d1.t509(n int);
+create table d1.t508(n int);
+create table d1.t507(n int);
+create table d1.t506(n int);
+create table d1.t505(n int);
+create table d1.t504(n int);
+create table d1.t503(n int);
+create table d1.t502(n int);
+create table d1.t501(n int);
+create table d1.t500(n int);
+create table d1.t499(n int);
+create table d1.t498(n int);
+create table d1.t497(n int);
+create table d1.t496(n int);
+create table d1.t495(n int);
+create table d1.t494(n int);
+create table d1.t493(n int);
+create table d1.t492(n int);
+create table d1.t491(n int);
+create table d1.t490(n int);
+create table d1.t489(n int);
+create table d1.t488(n int);
+create table d1.t487(n int);
+create table d1.t486(n int);
+create table d1.t485(n int);
+create table d1.t484(n int);
+create table d1.t483(n int);
+create table d1.t482(n int);
+create table d1.t481(n int);
+create table d1.t480(n int);
+create table d1.t479(n int);
+create table d1.t478(n int);
+create table d1.t477(n int);
+create table d1.t476(n int);
+create table d1.t475(n int);
+create table d1.t474(n int);
+create table d1.t473(n int);
+create table d1.t472(n int);
+create table d1.t471(n int);
+create table d1.t470(n int);
+create table d1.t469(n int);
+create table d1.t468(n int);
+create table d1.t467(n int);
+create table d1.t466(n int);
+create table d1.t465(n int);
+create table d1.t464(n int);
+create table d1.t463(n int);
+create table d1.t462(n int);
+create table d1.t461(n int);
+create table d1.t460(n int);
+create table d1.t459(n int);
+create table d1.t458(n int);
+create table d1.t457(n int);
+create table d1.t456(n int);
+create table d1.t455(n int);
+create table d1.t454(n int);
+create table d1.t453(n int);
+create table d1.t452(n int);
+create table d1.t451(n int);
+create table d1.t450(n int);
+create table d1.t449(n int);
+create table d1.t448(n int);
+create table d1.t447(n int);
+create table d1.t446(n int);
+create table d1.t445(n int);
+create table d1.t444(n int);
+create table d1.t443(n int);
+create table d1.t442(n int);
+create table d1.t441(n int);
+create table d1.t440(n int);
+create table d1.t439(n int);
+create table d1.t438(n int);
+create table d1.t437(n int);
+create table d1.t436(n int);
+create table d1.t435(n int);
+create table d1.t434(n int);
+create table d1.t433(n int);
+create table d1.t432(n int);
+create table d1.t431(n int);
+create table d1.t430(n int);
+create table d1.t429(n int);
+create table d1.t428(n int);
+create table d1.t427(n int);
+create table d1.t426(n int);
+create table d1.t425(n int);
+create table d1.t424(n int);
+create table d1.t423(n int);
+create table d1.t422(n int);
+create table d1.t421(n int);
+create table d1.t420(n int);
+create table d1.t419(n int);
+create table d1.t418(n int);
+create table d1.t417(n int);
+create table d1.t416(n int);
+create table d1.t415(n int);
+create table d1.t414(n int);
+create table d1.t413(n int);
+create table d1.t412(n int);
+create table d1.t411(n int);
+create table d1.t410(n int);
+create table d1.t409(n int);
+create table d1.t408(n int);
+create table d1.t407(n int);
+create table d1.t406(n int);
+create table d1.t405(n int);
+create table d1.t404(n int);
+create table d1.t403(n int);
+create table d1.t402(n int);
+create table d1.t401(n int);
+create table d1.t400(n int);
+create table d1.t399(n int);
+create table d1.t398(n int);
+create table d1.t397(n int);
+create table d1.t396(n int);
+create table d1.t395(n int);
+create table d1.t394(n int);
+create table d1.t393(n int);
+create table d1.t392(n int);
+create table d1.t391(n int);
+create table d1.t390(n int);
+create table d1.t389(n int);
+create table d1.t388(n int);
+create table d1.t387(n int);
+create table d1.t386(n int);
+create table d1.t385(n int);
+create table d1.t384(n int);
+create table d1.t383(n int);
+create table d1.t382(n int);
+create table d1.t381(n int);
+create table d1.t380(n int);
+create table d1.t379(n int);
+create table d1.t378(n int);
+create table d1.t377(n int);
+create table d1.t376(n int);
+create table d1.t375(n int);
+create table d1.t374(n int);
+create table d1.t373(n int);
+create table d1.t372(n int);
+create table d1.t371(n int);
+create table d1.t370(n int);
+create table d1.t369(n int);
+create table d1.t368(n int);
+create table d1.t367(n int);
+create table d1.t366(n int);
+create table d1.t365(n int);
+create table d1.t364(n int);
+create table d1.t363(n int);
+create table d1.t362(n int);
+create table d1.t361(n int);
+create table d1.t360(n int);
+create table d1.t359(n int);
+create table d1.t358(n int);
+create table d1.t357(n int);
+create table d1.t356(n int);
+create table d1.t355(n int);
+create table d1.t354(n int);
+create table d1.t353(n int);
+create table d1.t352(n int);
+create table d1.t351(n int);
+create table d1.t350(n int);
+create table d1.t349(n int);
+create table d1.t348(n int);
+create table d1.t347(n int);
+create table d1.t346(n int);
+create table d1.t345(n int);
+create table d1.t344(n int);
+create table d1.t343(n int);
+create table d1.t342(n int);
+create table d1.t341(n int);
+create table d1.t340(n int);
+create table d1.t339(n int);
+create table d1.t338(n int);
+create table d1.t337(n int);
+create table d1.t336(n int);
+create table d1.t335(n int);
+create table d1.t334(n int);
+create table d1.t333(n int);
+create table d1.t332(n int);
+create table d1.t331(n int);
+create table d1.t330(n int);
+create table d1.t329(n int);
+create table d1.t328(n int);
+create table d1.t327(n int);
+create table d1.t326(n int);
+create table d1.t325(n int);
+create table d1.t324(n int);
+create table d1.t323(n int);
+create table d1.t322(n int);
+create table d1.t321(n int);
+create table d1.t320(n int);
+create table d1.t319(n int);
+create table d1.t318(n int);
+create table d1.t317(n int);
+create table d1.t316(n int);
+create table d1.t315(n int);
+create table d1.t314(n int);
+create table d1.t313(n int);
+create table d1.t312(n int);
+create table d1.t311(n int);
+create table d1.t310(n int);
+create table d1.t309(n int);
+create table d1.t308(n int);
+create table d1.t307(n int);
+create table d1.t306(n int);
+create table d1.t305(n int);
+create table d1.t304(n int);
+create table d1.t303(n int);
+create table d1.t302(n int);
+create table d1.t301(n int);
+create table d1.t300(n int);
+create table d1.t299(n int);
+create table d1.t298(n int);
+create table d1.t297(n int);
+create table d1.t296(n int);
+create table d1.t295(n int);
+create table d1.t294(n int);
+create table d1.t293(n int);
+create table d1.t292(n int);
+create table d1.t291(n int);
+create table d1.t290(n int);
+create table d1.t289(n int);
+create table d1.t288(n int);
+create table d1.t287(n int);
+create table d1.t286(n int);
+create table d1.t285(n int);
+create table d1.t284(n int);
+create table d1.t283(n int);
+create table d1.t282(n int);
+create table d1.t281(n int);
+create table d1.t280(n int);
+create table d1.t279(n int);
+create table d1.t278(n int);
+create table d1.t277(n int);
+create table d1.t276(n int);
+create table d1.t275(n int);
+create table d1.t274(n int);
+create table d1.t273(n int);
+create table d1.t272(n int);
+create table d1.t271(n int);
+create table d1.t270(n int);
+create table d1.t269(n int);
+create table d1.t268(n int);
+create table d1.t267(n int);
+create table d1.t266(n int);
+create table d1.t265(n int);
+create table d1.t264(n int);
+create table d1.t263(n int);
+create table d1.t262(n int);
+create table d1.t261(n int);
+create table d1.t260(n int);
+create table d1.t259(n int);
+create table d1.t258(n int);
+create table d1.t257(n int);
+create table d1.t256(n int);
+create table d1.t255(n int);
+create table d1.t254(n int);
+create table d1.t253(n int);
+create table d1.t252(n int);
+create table d1.t251(n int);
+create table d1.t250(n int);
+create table d1.t249(n int);
+create table d1.t248(n int);
+create table d1.t247(n int);
+create table d1.t246(n int);
+create table d1.t245(n int);
+create table d1.t244(n int);
+create table d1.t243(n int);
+create table d1.t242(n int);
+create table d1.t241(n int);
+create table d1.t240(n int);
+create table d1.t239(n int);
+create table d1.t238(n int);
+create table d1.t237(n int);
+create table d1.t236(n int);
+create table d1.t235(n int);
+create table d1.t234(n int);
+create table d1.t233(n int);
+create table d1.t232(n int);
+create table d1.t231(n int);
+create table d1.t230(n int);
+create table d1.t229(n int);
+create table d1.t228(n int);
+create table d1.t227(n int);
+create table d1.t226(n int);
+create table d1.t225(n int);
+create table d1.t224(n int);
+create table d1.t223(n int);
+create table d1.t222(n int);
+create table d1.t221(n int);
+create table d1.t220(n int);
+create table d1.t219(n int);
+create table d1.t218(n int);
+create table d1.t217(n int);
+create table d1.t216(n int);
+create table d1.t215(n int);
+create table d1.t214(n int);
+create table d1.t213(n int);
+create table d1.t212(n int);
+create table d1.t211(n int);
+create table d1.t210(n int);
+create table d1.t209(n int);
+create table d1.t208(n int);
+create table d1.t207(n int);
+create table d1.t206(n int);
+create table d1.t205(n int);
+create table d1.t204(n int);
+create table d1.t203(n int);
+create table d1.t202(n int);
+create table d1.t201(n int);
+create table d1.t200(n int);
+create table d1.t199(n int);
+create table d1.t198(n int);
+create table d1.t197(n int);
+create table d1.t196(n int);
+create table d1.t195(n int);
+create table d1.t194(n int);
+create table d1.t193(n int);
+create table d1.t192(n int);
+create table d1.t191(n int);
+create table d1.t190(n int);
+create table d1.t189(n int);
+create table d1.t188(n int);
+create table d1.t187(n int);
+create table d1.t186(n int);
+create table d1.t185(n int);
+create table d1.t184(n int);
+create table d1.t183(n int);
+create table d1.t182(n int);
+create table d1.t181(n int);
+create table d1.t180(n int);
+create table d1.t179(n int);
+create table d1.t178(n int);
+create table d1.t177(n int);
+create table d1.t176(n int);
+create table d1.t175(n int);
+create table d1.t174(n int);
+create table d1.t173(n int);
+create table d1.t172(n int);
+create table d1.t171(n int);
+create table d1.t170(n int);
+create table d1.t169(n int);
+create table d1.t168(n int);
+create table d1.t167(n int);
+create table d1.t166(n int);
+create table d1.t165(n int);
+create table d1.t164(n int);
+create table d1.t163(n int);
+create table d1.t162(n int);
+create table d1.t161(n int);
+create table d1.t160(n int);
+create table d1.t159(n int);
+create table d1.t158(n int);
+create table d1.t157(n int);
+create table d1.t156(n int);
+create table d1.t155(n int);
+create table d1.t154(n int);
+create table d1.t153(n int);
+create table d1.t152(n int);
+create table d1.t151(n int);
+create table d1.t150(n int);
+create table d1.t149(n int);
+create table d1.t148(n int);
+create table d1.t147(n int);
+create table d1.t146(n int);
+create table d1.t145(n int);
+create table d1.t144(n int);
+create table d1.t143(n int);
+create table d1.t142(n int);
+create table d1.t141(n int);
+create table d1.t140(n int);
+create table d1.t139(n int);
+create table d1.t138(n int);
+create table d1.t137(n int);
+create table d1.t136(n int);
+create table d1.t135(n int);
+create table d1.t134(n int);
+create table d1.t133(n int);
+create table d1.t132(n int);
+create table d1.t131(n int);
+create table d1.t130(n int);
+create table d1.t129(n int);
+create table d1.t128(n int);
+create table d1.t127(n int);
+create table d1.t126(n int);
+create table d1.t125(n int);
+create table d1.t124(n int);
+create table d1.t123(n int);
+create table d1.t122(n int);
+create table d1.t121(n int);
+create table d1.t120(n int);
+create table d1.t119(n int);
+create table d1.t118(n int);
+create table d1.t117(n int);
+create table d1.t116(n int);
+create table d1.t115(n int);
+create table d1.t114(n int);
+create table d1.t113(n int);
+create table d1.t112(n int);
+create table d1.t111(n int);
+create table d1.t110(n int);
+create table d1.t109(n int);
+create table d1.t108(n int);
+create table d1.t107(n int);
+create table d1.t106(n int);
+create table d1.t105(n int);
+create table d1.t104(n int);
+create table d1.t103(n int);
+create table d1.t102(n int);
+create table d1.t101(n int);
+create table d1.t100(n int);
+create table d1.t99(n int);
+create table d1.t98(n int);
+create table d1.t97(n int);
+create table d1.t96(n int);
+create table d1.t95(n int);
+create table d1.t94(n int);
+create table d1.t93(n int);
+create table d1.t92(n int);
+create table d1.t91(n int);
+create table d1.t90(n int);
+create table d1.t89(n int);
+create table d1.t88(n int);
+create table d1.t87(n int);
+create table d1.t86(n int);
+create table d1.t85(n int);
+create table d1.t84(n int);
+create table d1.t83(n int);
+create table d1.t82(n int);
+create table d1.t81(n int);
+create table d1.t80(n int);
+create table d1.t79(n int);
+create table d1.t78(n int);
+create table d1.t77(n int);
+create table d1.t76(n int);
+create table d1.t75(n int);
+create table d1.t74(n int);
+create table d1.t73(n int);
+create table d1.t72(n int);
+create table d1.t71(n int);
+create table d1.t70(n int);
+create table d1.t69(n int);
+create table d1.t68(n int);
+create table d1.t67(n int);
+create table d1.t66(n int);
+create table d1.t65(n int);
+create table d1.t64(n int);
+create table d1.t63(n int);
+create table d1.t62(n int);
+create table d1.t61(n int);
+create table d1.t60(n int);
+create table d1.t59(n int);
+create table d1.t58(n int);
+create table d1.t57(n int);
+create table d1.t56(n int);
+create table d1.t55(n int);
+create table d1.t54(n int);
+create table d1.t53(n int);
+create table d1.t52(n int);
+create table d1.t51(n int);
+create table d1.t50(n int);
+create table d1.t49(n int);
+create table d1.t48(n int);
+create table d1.t47(n int);
+create table d1.t46(n int);
+create table d1.t45(n int);
+create table d1.t44(n int);
+create table d1.t43(n int);
+create table d1.t42(n int);
+create table d1.t41(n int);
+create table d1.t40(n int);
+create table d1.t39(n int);
+create table d1.t38(n int);
+create table d1.t37(n int);
+create table d1.t36(n int);
+create table d1.t35(n int);
+create table d1.t34(n int);
+create table d1.t33(n int);
+create table d1.t32(n int);
+create table d1.t31(n int);
+create table d1.t30(n int);
+create table d1.t29(n int);
+create table d1.t28(n int);
+create table d1.t27(n int);
+create table d1.t26(n int);
+create table d1.t25(n int);
+create table d1.t24(n int);
+create table d1.t23(n int);
+create table d1.t22(n int);
+create table d1.t21(n int);
+create table d1.t20(n int);
+create table d1.t19(n int);
+create table d1.t18(n int);
+create table d1.t17(n int);
+create table d1.t16(n int);
+create table d1.t15(n int);
+create table d1.t14(n int);
+create table d1.t13(n int);
+create table d1.t12(n int);
+create table d1.t11(n int);
+create table d1.t10(n int);
+create table d1.t9(n int);
+create table d1.t8(n int);
+create table d1.t7(n int);
+create table d1.t6(n int);
+create table d1.t5(n int);
+create table d1.t4(n int);
+create table d1.t3(n int);
+create table d1.t2(n int);
+create table d1.t1(n int);
+drop database d1;
+ERROR HY000: Error dropping database (can't rmdir './d1/', errno: 17)
+use d1;
+show tables;
+Tables_in_d1
 use test;
 create table t1 (n int);
 insert into t1 values (1234);
diff --git a/mysql-test/t/rpl_drop_db.test b/mysql-test/t/rpl_drop_db.test
index ef0ab4be6fd..71dc22f705f 100644
--- a/mysql-test/t/rpl_drop_db.test
+++ b/mysql-test/t/rpl_drop_db.test
@@ -17,6 +17,19 @@ create table d1.t3 (n int);
 drop database d1;
 use d1;
 show tables;
+
+# test the branch of the code that deals with the query buffer overflow
+
+let $1=1000;
+while ($1)
+{
+  eval create table d1.t$1(n int);
+  dec $1;
+}
+--error 1010
+drop database d1;
+use d1;
+show tables;
 use test;
 create table t1 (n int);
 insert into t1 values (1234);
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 946bb117e9e..0af3ea3af63 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -447,7 +447,7 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
 			 bool drop_temporary, bool log_query);
 int mysql_rm_table_part2_with_lock(THD *thd, TABLE_LIST *tables,
 				   bool if_exists, bool drop_temporary,
-				   bool log_query, List<String> *dropped_tables);
+				   bool log_query);
 int quick_rm_table(enum db_type base,const char *db,
 		   const char *table_name);
 bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list);
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index 0155fca0466..6dcc7be0904 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -25,14 +25,20 @@
 #include <direct.h>
 #endif
 
+#define MAX_DROP_TABLE_Q_LEN      1024
+
 const char *del_exts[]= {".frm", ".BAK", ".TMD",".opt", NullS};
 static TYPELIB deletable_extentions=
 {array_elements(del_exts)-1,"del_exts", del_exts, NULL};
 
 static long mysql_rm_known_files(THD *thd, MY_DIR *dirp,
-				 const char *db, const char *path,
-				 uint level, List<String> *dropped_tables);
+				 const char *db, const char *path, uint level, 
+         TABLE_LIST** dropped_tables);
+         
 
+static inline void write_to_binlog(THD* thd, char* query, uint q_len,
+  char* db, uint db_len);
+          
 /* Database options hash */
 static HASH dboptions;
 static my_bool dboptions_init= 0;
@@ -57,6 +63,19 @@ static byte* dboptions_get_key(my_dbopt_t *opt, uint *length,
   return (byte*) opt->name;
 }
 
+/*
+   Helper function to write a query to binlog used by mysql_rm_db()
+ */
+static inline void write_to_binlog(THD* thd, char* query, uint q_len,
+  char* db, uint db_len)
+{
+   Query_log_event qinfo(thd, query, q_len, 0, 0);
+   qinfo.error_code= 0;
+   qinfo.db= db;
+   qinfo.db_len= db_len;
+   mysql_bin_log.write(&qinfo);
+}  
+
 
 /*
   Function to free dboptions hash element
@@ -584,8 +603,8 @@ int mysql_rm_db(THD *thd,char *db,bool if_exists, bool silent)
   int error= 0;
   char	path[FN_REFLEN+16], tmp_db[NAME_LEN+1];
   MY_DIR *dirp;
-  List<String> dropped_tables;
   uint length;
+  TABLE_LIST* dropped_tables= 0;
   DBUG_ENTER("mysql_rm_db");
 
   VOID(pthread_mutex_lock(&LOCK_mysql_create_db));
@@ -625,7 +644,7 @@ int mysql_rm_db(THD *thd,char *db,bool if_exists, bool silent)
     
     error= -1;
     if ((deleted= mysql_rm_known_files(thd, dirp, db, path, 0,
-          &dropped_tables)) >= 0)
+         &dropped_tables)) >= 0)
     {
       ha_drop_database(path);
       query_cache_invalidate1(db);
@@ -675,36 +694,44 @@ int mysql_rm_db(THD *thd,char *db,bool if_exists, bool silent)
     send_ok(thd, (ulong) deleted);
     thd->server_status&= ~SERVER_STATUS_DB_DROPPED;
   }
-  else if (!dropped_tables.is_empty() && mysql_bin_log.is_open())
+  else if (mysql_bin_log.is_open())
   {
-     List_iterator<String> it(dropped_tables);
-     String* dropped_table;
-     int q_len= 11; /* drop table */ 
-     int db_len= strlen(db);
+     char* query= thd->alloc(MAX_DROP_TABLE_Q_LEN);
      
-     for (;(dropped_table= it++);)
-     {
-       q_len += dropped_table->length() + 2 + db_len;
-     }
-     q_len--; /* no last comma */
-     
-     char* query= thd->alloc(q_len);
      if (!query)
        goto exit; /* not much else we can do */
      char* p= strmov(query,"drop table ");  
-     it.rewind();
+     char* p_end= query + MAX_DROP_TABLE_Q_LEN;
+     TABLE_LIST* tbl;
+     bool last_query_needs_write= 0;
+     uint db_len= strlen(db);
      
-     for (;(dropped_table= it++);)
+     for (tbl= dropped_tables;tbl;tbl= tbl->next)
      {
-       p= strmov(p,db);
-       *p++ = '.';
-       p= strnmov(p,dropped_table->ptr(),dropped_table->length());
+       if (!tbl->was_dropped)
+         continue;
+         
+       /* 3 for the quotes and the comma*/  
+       uint tbl_name_len= strlen(tbl->real_name) + 3; 
+       if (p + tbl_name_len + 1 >= p_end)
+       {
+          *--p= 0; /* kill , */
+          write_to_binlog(thd, query, p - query, db, db_len);
+          p= query + 11; /* reuse the initial "drop table" */
+       }    
+       
+       *p++ = '`';
+       p= strmov(p,tbl->real_name);
+       *p++ = '`';
        *p++ = ',';
+       last_query_needs_write= 1;
      }
-     *--p= 0;
-     Query_log_event qinfo(thd, query, q_len, 0, 0);
-     qinfo.error_code= 0;
-     mysql_bin_log.write(&qinfo);
+     
+     if (last_query_needs_write)
+     {
+       *--p= 0;
+       write_to_binlog(thd, query, p - query, db, db_len);
+     }  
   }
 
 exit:
@@ -750,7 +777,7 @@ exit2:
 */
 
 static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db,
-				 const char *org_path, uint level, List<String> *dropped_tables)
+				 const char *org_path, uint level, TABLE_LIST** dropped_tables)
 {
   long deleted=0;
   ulong found_other_files=0;
@@ -839,8 +866,7 @@ static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db,
     }
   }
   if (thd->killed ||
-      (tot_list && mysql_rm_table_part2_with_lock(thd, tot_list, 1, 0, 
-           1,dropped_tables)))
+      (tot_list && mysql_rm_table_part2_with_lock(thd, tot_list, 1, 0, 1)))
     goto err;
 
   /* Remove RAID directories */
@@ -853,6 +879,9 @@ static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db,
   }
   my_dirend(dirp);  
   
+  if (dropped_tables)
+    *dropped_tables= tot_list;
+  
   /*
     If the directory is a symbolic link, remove the link first, then
     remove the directory the symbolic link pointed at
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index e948a65f301..80ac9e007b9 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -156,8 +156,7 @@ int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
 
 int mysql_rm_table_part2_with_lock(THD *thd,
 				   TABLE_LIST *tables, bool if_exists,
-				   bool drop_temporary, bool dont_log_query,
-           List<String>* dropped_tables)
+				   bool drop_temporary, bool dont_log_query)
 {
   int error;
   thd->mysys_var->current_mutex= &LOCK_open;
@@ -166,23 +165,6 @@ int mysql_rm_table_part2_with_lock(THD *thd,
 
   error=mysql_rm_table_part2(thd,tables, if_exists, drop_temporary,
 			     dont_log_query);
-  /*
-    For now we assume that if we got success all the tables in the list 
-    were actually dropped, otherwise, assume none were dropped.
-    TODO: fix it to work with a partial drop - extremely rare case, but
-    can happen.
-  */         
-  if (!error && dropped_tables)
-  {         
-    TABLE_LIST* tbl;
-    
-    for (tbl= tables; tbl; tbl= tbl->next)
-    {
-      String *dropped_table= new (thd->mem_root) 
-         String(tbl->real_name,&my_charset_latin1);
-      dropped_tables->push_back(dropped_table); 
-    } 
-  }        
 
   pthread_mutex_unlock(&LOCK_open);
 
@@ -238,6 +220,7 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
   for (table=tables ; table ; table=table->next)
   {
     char *db=table->db;
+    table->was_dropped= 0;
     mysql_ha_flush(thd, table, MYSQL_HA_CLOSE_FINAL);
     if (!close_temporary_table(thd, db, table->real_name))
     {
@@ -298,6 +281,8 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
 	wrong_tables.append(',');
       wrong_tables.append(String(table->real_name,system_charset_info));
     }
+    else
+      table->was_dropped= 1;
   }
   thd->tmp_table_used= tmp_table_deleted;
   error= 0;
diff --git a/sql/table.h b/sql/table.h
index 77153e5d8cd..fb742acf804 100644
--- a/sql/table.h
+++ b/sql/table.h
@@ -235,6 +235,9 @@ typedef struct st_table_list
   bool		cacheable_table;	/* stop PS caching */
   /* used in multi-upd privelege check */
   bool		table_in_update_from_clause;
+  
+  /* used for proper partially successful DROP DATABASE binlogging */
+  bool    was_dropped; 
 } TABLE_LIST;
 
 typedef struct st_changed_table_list

From cf312a782dd5d94f1abd7a4cd29486c65d93e76d Mon Sep 17 00:00:00 2001
From: unknown <patg@radha.local>
Date: Fri, 19 Aug 2005 07:51:22 +0200
Subject: [PATCH 5/9] BUG #12498 Fixed mispelling

sql/mysqld.cc:
  BUG #12498 Fixed Mispelled 'type'
---
 sql/mysqld.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 9177703599c..c919614fc88 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -4323,7 +4323,7 @@ Disable with --skip-bdb (will save memory).",
    (gptr*) &default_collation_name, (gptr*) &default_collation_name,
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
   {"default-storage-engine", OPT_STORAGE_ENGINE,
-   "Set the default storage engine (table tyoe) for tables.", 0, 0,
+   "Set the default storage engine (table type) for tables.", 0, 0,
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
   {"default-table-type", OPT_STORAGE_ENGINE,
    "(deprecated) Use --default-storage-engine.", 0, 0,

From 01f4258a02e01f578c0552089ef313ddc4bf95c5 Mon Sep 17 00:00:00 2001
From: unknown <igor@rurik.mysql.com>
Date: Fri, 19 Aug 2005 01:57:22 -0700
Subject: [PATCH 6/9] distinct.test, distinct.result:   Added test cases for
 bug #12625. sql_select.cc:   Fixed bug #12625.   Fixed invalid removal of
 constant items from the DISTINCT   list in the function
 create_distinct_group.

sql/sql_select.cc:
  Fixed bug #12625.
mysql-test/r/distinct.result:
  Added test cases for bug #12625.
mysql-test/t/distinct.test:
  Added test cases for bug #12625.
---
 mysql-test/r/distinct.result | 40 ++++++++++++++++++++++++++++++++++++
 mysql-test/t/distinct.test   | 17 +++++++++++++++
 sql/sql_select.cc            |  4 +---
 3 files changed, 58 insertions(+), 3 deletions(-)

diff --git a/mysql-test/r/distinct.result b/mysql-test/r/distinct.result
index f4bc4263c4d..8932285b5d0 100644
--- a/mysql-test/r/distinct.result
+++ b/mysql-test/r/distinct.result
@@ -464,3 +464,43 @@ SELECT DISTINCT html,SUM(out)/(SUM(rin)+1) as 'prod' FROM t1 GROUP BY rin;
 html	prod
 1	0.00
 drop table t1;
+CREATE TABLE t1 (a int);
+INSERT INTO t1 VALUES (1),(2),(3),(4),(5);
+SELECT DISTINCT a, 1 FROM t1;
+a	1
+1	1
+2	1
+3	1
+4	1
+5	1
+SELECT DISTINCT 1, a FROM t1;
+1	a
+1	1
+1	2
+1	3
+1	4
+1	5
+CREATE TABLE t2 (a int, b int);
+INSERT INTO t2 VALUES (1,1),(2,2),(2,3),(2,4),(3,5);
+SELECT DISTINCT a, b, 2 FROM t2;
+a	b	2
+1	1	2
+2	2	2
+2	3	2
+2	4	2
+3	5	2
+SELECT DISTINCT 2, a, b FROM t2;
+2	a	b
+2	1	1
+2	2	2
+2	2	3
+2	2	4
+2	3	5
+SELECT DISTINCT a, 2, b FROM t2;
+a	2	b
+1	2	1
+2	2	2
+2	2	3
+2	2	4
+3	2	5
+DROP TABLE t1,t2;
diff --git a/mysql-test/t/distinct.test b/mysql-test/t/distinct.test
index f05dd4b75a0..f2fe1ec6372 100644
--- a/mysql-test/t/distinct.test
+++ b/mysql-test/t/distinct.test
@@ -333,4 +333,21 @@ INSERT INTO t1 VALUES ('1',1,0);
 SELECT DISTINCT html,SUM(out)/(SUM(rin)+1) as 'prod' FROM t1 GROUP BY rin;
 drop table t1;
 
+#
+# Test cases for #12625: DISTINCT for a list with constants
+#
+
+CREATE TABLE t1 (a int);
+INSERT INTO t1 VALUES (1),(2),(3),(4),(5);
+SELECT DISTINCT a, 1 FROM t1;
+SELECT DISTINCT 1, a FROM t1;
+
+CREATE TABLE t2 (a int, b int); 
+INSERT INTO t2 VALUES (1,1),(2,2),(2,3),(2,4),(3,5);
+SELECT DISTINCT a, b, 2 FROM t2;
+SELECT DISTINCT 2, a, b FROM t2;
+SELECT DISTINCT a, 2, b FROM t2;
+
+DROP TABLE t1,t2;
+
 # End of 4.1 tests
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 9984cb4138f..3b67af8eea7 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -8517,9 +8517,7 @@ create_distinct_group(THD *thd, Item **ref_pointer_array,
   li.rewind();
   while ((item=li++))
   {
-    if (item->const_item() || item->with_sum_func)
-      continue;
-    if (!item->marker)
+    if (!item->const_item() && !item->with_sum_func && !item->marker)
     {
       ORDER *ord=(ORDER*) thd->calloc(sizeof(ORDER));
       if (!ord)

From 1b970e94e0a736a2056cb94cfcba0b50133da1d6 Mon Sep 17 00:00:00 2001
From: unknown <elliot@mysql.com>
Date: Fri, 19 Aug 2005 14:49:34 -0400
Subject: [PATCH 7/9] Bug#11338 Fixes from review (identical functionality).

include/my_sys.h:
  Fixes from review (use version in log_event.cc instead)
mysql-test/r/ctype_cp932.result:
  Updated test for bug#11338 (logging of prepared statement w/ blob type)
mysql-test/t/ctype_cp932.test:
  udpated test for bug#11338 (logging of prepared statement w/ blob type)
mysys/charset.c:
  Fixes from review (use version in log_event.cc instead)
sql/item.cc:
  Fixes from review (store character_set_client differently so that
  fix can be merged forward to 5.0)
sql/item.h:
  Fixes from review
sql/log_event.cc:
  Fixes from review, str_to_hex is now used by item.cc
sql/log_event.h:
  Added prototype for str_to_hex (now used by item.cc)
sql/sql_prepare.cc:
  Fixes from review, store character_set_client differently so that
  Item_param::query_val_str can use it.
---
 include/my_sys.h                |  1 -
 mysql-test/r/ctype_cp932.result | 14 ++++++++++++++
 mysql-test/t/ctype_cp932.test   | 20 ++++++++++++++++++++
 mysys/charset.c                 | 18 ------------------
 sql/item.cc                     | 15 +++++++--------
 sql/item.h                      |  3 ++-
 sql/log_event.cc                |  2 +-
 sql/log_event.h                 |  2 +-
 sql/sql_prepare.cc              |  9 ++++++---
 9 files changed, 51 insertions(+), 33 deletions(-)

diff --git a/include/my_sys.h b/include/my_sys.h
index eafa41a05c8..8752aa30772 100644
--- a/include/my_sys.h
+++ b/include/my_sys.h
@@ -788,7 +788,6 @@ extern my_bool init_compiled_charsets(myf flags);
 extern void add_compiled_collation(CHARSET_INFO *cs);
 extern ulong escape_string_for_mysql(CHARSET_INFO *charset_info, char *to,
                                      const char *from, ulong length);
-extern char *bare_str_to_hex(char *to, const char *from, uint len);
 #ifdef __WIN__
 #define BACKSLASH_MBTAIL
 /* File system character set */
diff --git a/mysql-test/r/ctype_cp932.result b/mysql-test/r/ctype_cp932.result
index 0e28edc6df3..85e317481d1 100644
--- a/mysql-test/r/ctype_cp932.result
+++ b/mysql-test/r/ctype_cp932.result
@@ -8576,6 +8576,20 @@ FC4B
 DROP TABLE t1;
 DROP TABLE t2;
 DROP TABLE t3;
+CREATE TABLE t1(f1 blob);
+PREPARE stmt1 FROM 'INSERT INTO t1 VALUES(?)';
+SET @var1= x'8300';
+EXECUTE stmt1 USING @var1;
+SHOW BINLOG EVENTS FROM 27642;
+Log_name	Pos	Event_type	Server_id	Orig_log_pos	Info
+master-bin.000001	27642	Query	1	27642	use `test`; CREATE TABLE t1(f1 blob)
+master-bin.000001	27701	Query	1	27701	use `test`; SET ONE_SHOT CHARACTER_SET_CLIENT=95,COLLATION_CONNECTION=95,COLLATION_DATABASE=95,COLLATION_SERVER=8
+master-bin.000001	27837	User var	1	27837	@`var1`=_binary 0x8300 COLLATE binary
+master-bin.000001	27876	Query	1	27876	use `test`; INSERT INTO t1 VALUES(@'var1')
+SELECT HEX(f1) FROM t1;
+HEX(f1)
+8300
+DROP table t1;
 SET collation_connection='cp932_japanese_ci';
 create table t1 select repeat('a',4000) a;
 delete from t1;
diff --git a/mysql-test/t/ctype_cp932.test b/mysql-test/t/ctype_cp932.test
index 7060d917ab0..34bf7965248 100644
--- a/mysql-test/t/ctype_cp932.test
+++ b/mysql-test/t/ctype_cp932.test
@@ -401,6 +401,26 @@ DROP TABLE t2;
 DROP TABLE t3;
 #DROP TABLE t4;
 
+# Test prepared statement with 0x8300 sequence in parameter while
+# running with cp932 client character set.
+CREATE TABLE t1(f1 blob);
+PREPARE stmt1 FROM 'INSERT INTO t1 VALUES(?)';
+SET @var1= x'8300';
+# TODO: Note that this doesn't actually test the code which was added for
+# bug#11338 because this syntax for prepared statements causes the PS to
+# be replicated differently than if we executed the PS from C or Java.
+# Using this syntax, variable names are inserted into the binlog instead
+# of values. The real goal of this test is to check the code that was
+# added to Item_param::query_val_str() in order to do hex encoding of
+# PS parameters when the client character set is cp932;
+# Bug#11338 has an example java program which can be used to verify this 
+# code (and I have used it to test the fix) until there is some way to
+# exercise this code from mysql-test-run.
+EXECUTE stmt1 USING @var1;
+SHOW BINLOG EVENTS FROM 27642;
+SELECT HEX(f1) FROM t1;
+DROP table t1;
+# end test for bug#11338
 
 SET collation_connection='cp932_japanese_ci';
 -- source include/ctype_filesort.inc
diff --git a/mysys/charset.c b/mysys/charset.c
index df3f1cfa279..3a39fce9437 100644
--- a/mysys/charset.c
+++ b/mysys/charset.c
@@ -663,21 +663,3 @@ CHARSET_INFO *fs_character_set()
   return fs_cset_cache;
 }
 #endif
-
-/*
-  Transforms a string into hex form.
- */
-char *bare_str_to_hex(char *to, const char *from, uint len)
-{
-  char *p= to;
-  uint i;
-  for (i= 0; i < len; i++, p+= 2)
-  {
-    /* val[i] is char. Casting to uchar helps greatly if val[i] < 0 */
-    uint tmp= (uint) (uchar) from[i];
-    p[0]= _dig_vec_upper[tmp >> 4];
-    p[1]= _dig_vec_upper[tmp & 15];
-  }
-  *p= 0;
-  return p; // pointer to end 0 of 'to'
-}
diff --git a/sql/item.cc b/sql/item.cc
index 79579eeeb67..2ae56d17b07 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -1230,7 +1230,7 @@ bool Item_param::set_from_user_var(THD *thd, const user_var_entry *entry)
       CHARSET_INFO *tocs= thd->variables.collation_connection;
       uint32 dummy_offset;
 
-      value.cs_info.character_set_client= fromcs;
+      value.cs_info.character_set_of_placeholder= fromcs;
       /*
         Setup source and destination character sets so that they
         are different only if conversion is necessary: this will
@@ -1443,7 +1443,7 @@ String *Item_param::val_str(String* str)
   and avoid one more memcpy/alloc between str and log string.
 */
 
-const String *Item_param::query_val_str(String* str, THD *thd) const
+const String *Item_param::query_val_str(String* str) const
 {
   switch (state) {
   case INT_VALUE:
@@ -1482,18 +1482,17 @@ const String *Item_param::query_val_str(String* str, THD *thd) const
 
       buf= str->c_ptr_quick();
       ptr= buf;
-      if (thd->charset()->escape_with_backslash_is_dangerous)
+      if (value.cs_info.character_set_client->escape_with_backslash_is_dangerous)
       {
-        ptr= strmov(ptr, "x\'");
-        ptr= bare_str_to_hex(ptr, str_value.ptr(), str_value.length());
+        ptr= str_to_hex(ptr, str_value.ptr(), str_value.length());
       }
       else
       {
         *ptr++= '\'';
         ptr+= escape_string_for_mysql(str_value.charset(), ptr,
                                       str_value.ptr(), str_value.length());
+        *ptr++='\'';
       }
-      *ptr++='\'';
       str->length(ptr - buf);
       break;
     }
@@ -1523,10 +1522,10 @@ bool Item_param::convert_str_value(THD *thd)
       here only if conversion is really necessary.
     */
     if (value.cs_info.final_character_set_of_str_value !=
-        value.cs_info.character_set_client)
+        value.cs_info.character_set_of_placeholder)
     {
       rc= thd->convert_string(&str_value,
-                              value.cs_info.character_set_client,
+                              value.cs_info.character_set_of_placeholder,
                               value.cs_info.final_character_set_of_str_value);
     }
     else
diff --git a/sql/item.h b/sql/item.h
index ff34dfad025..080b804c730 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -532,6 +532,7 @@ public:
     struct CONVERSION_INFO
     {
       CHARSET_INFO *character_set_client;
+      CHARSET_INFO *character_set_of_placeholder;
       /*
         This points at character set of connection if conversion
         to it is required (i. e. if placeholder typecode is not BLOB).
@@ -591,7 +592,7 @@ public:
   */
   void (*set_param_func)(Item_param *param, uchar **pos, ulong len);
 
-  const String *query_val_str(String *str, THD *thd) const;
+  const String *query_val_str(String *str) const;
 
   bool convert_str_value(THD *thd);
 
diff --git a/sql/log_event.cc b/sql/log_event.cc
index 4d260763491..66c732e8cb0 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -207,7 +207,7 @@ static inline int read_str(char * &buf, char *buf_end, char * &str,
 /*
   Transforms a string into "" or its expression in 0x... form.
 */
-static char *str_to_hex(char *to, char *from, uint len)
+char *str_to_hex(char *to, const char *from, uint len)
 {
   char *p= to;
   if (len)
diff --git a/sql/log_event.h b/sql/log_event.h
index 7ae4e863fc2..5c81d0c92f0 100644
--- a/sql/log_event.h
+++ b/sql/log_event.h
@@ -1069,5 +1069,5 @@ public:
   bool is_valid() { return 1; }
 };
 #endif  
-
+char *str_to_hex(char *to, const char *from, uint len);
 #endif /* _log_event_h */
diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc
index d0c06a3eaf7..8a50d0bd50e 100644
--- a/sql/sql_prepare.cc
+++ b/sql/sql_prepare.cc
@@ -528,7 +528,9 @@ static void setup_one_conversion_function(THD *thd, Item_param *param,
   case MYSQL_TYPE_LONG_BLOB:
   case MYSQL_TYPE_BLOB:
     param->set_param_func= set_param_str;
-    param->value.cs_info.character_set_client= &my_charset_bin;
+    param->value.cs_info.character_set_of_placeholder= &my_charset_bin;
+    param->value.cs_info.character_set_client=
+      thd->variables.character_set_client;
     param->value.cs_info.final_character_set_of_str_value= &my_charset_bin;
     param->item_type= Item::STRING_ITEM;
     param->item_result_type= STRING_RESULT;
@@ -544,6 +546,7 @@ static void setup_one_conversion_function(THD *thd, Item_param *param,
       CHARSET_INFO *tocs= thd->variables.collation_connection;
       uint32 dummy_offset;
 
+      param->value.cs_info.character_set_of_placeholder= fromcs;
       param->value.cs_info.character_set_client= fromcs;
 
       /*
@@ -601,7 +604,7 @@ static bool insert_params_withlog(Prepared_statement *stmt, uchar *null_array,
         param->set_param_func(param, &read_pos, data_end - read_pos);
       }
     }
-    res= param->query_val_str(&str, thd);
+    res= param->query_val_str(&str);
     if (param->convert_str_value(thd))
       DBUG_RETURN(1);                           /* out of memory */
 
@@ -749,7 +752,7 @@ static bool emb_insert_params_withlog(Prepared_statement *stmt, String *query)
                               client_param->buffer_length);
       }
     }
-    res= param->query_val_str(&str, thd);
+    res= param->query_val_str(&str);
     if (param->convert_str_value(thd))
       DBUG_RETURN(1);                           /* out of memory */
 

From ab39c1baf1d73fe54e9b96874f3f3cb8b4a67201 Mon Sep 17 00:00:00 2001
From: unknown <elliot@mysql.com>
Date: Fri, 19 Aug 2005 17:55:28 -0400
Subject: [PATCH 8/9] Fix ctype_cp932 test to be deterministic on different
 machines.

mysql-test/r/ctype_cp932.result:
  Update results to make them deterministic
mysql-test/t/ctype_cp932.test:
  Updated test to be deterministic on all machines
---
 mysql-test/r/ctype_cp932.result | 13 ++++++++-----
 mysql-test/t/ctype_cp932.test   |  4 +++-
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/mysql-test/r/ctype_cp932.result b/mysql-test/r/ctype_cp932.result
index 85e317481d1..0711f251a07 100644
--- a/mysql-test/r/ctype_cp932.result
+++ b/mysql-test/r/ctype_cp932.result
@@ -8576,16 +8576,19 @@ FC4B
 DROP TABLE t1;
 DROP TABLE t2;
 DROP TABLE t3;
+RESET MASTER;
 CREATE TABLE t1(f1 blob);
 PREPARE stmt1 FROM 'INSERT INTO t1 VALUES(?)';
 SET @var1= x'8300';
 EXECUTE stmt1 USING @var1;
-SHOW BINLOG EVENTS FROM 27642;
+SHOW BINLOG EVENTS;
 Log_name	Pos	Event_type	Server_id	Orig_log_pos	Info
-master-bin.000001	27642	Query	1	27642	use `test`; CREATE TABLE t1(f1 blob)
-master-bin.000001	27701	Query	1	27701	use `test`; SET ONE_SHOT CHARACTER_SET_CLIENT=95,COLLATION_CONNECTION=95,COLLATION_DATABASE=95,COLLATION_SERVER=8
-master-bin.000001	27837	User var	1	27837	@`var1`=_binary 0x8300 COLLATE binary
-master-bin.000001	27876	Query	1	27876	use `test`; INSERT INTO t1 VALUES(@'var1')
+master-bin.000001	#	Start	1	#	Server ver: 4.1.15-debug-log, Binlog ver: 3
+master-bin.000001	#	Query	1	#	use `test`; SET ONE_SHOT CHARACTER_SET_CLIENT=95,COLLATION_CONNECTION=95,COLLATION_DATABASE=95,COLLATION_SERVER=8
+master-bin.000001	#	Query	1	#	use `test`; CREATE TABLE t1(f1 blob)
+master-bin.000001	#	Query	1	#	use `test`; SET ONE_SHOT CHARACTER_SET_CLIENT=95,COLLATION_CONNECTION=95,COLLATION_DATABASE=95,COLLATION_SERVER=8
+master-bin.000001	#	User var	1	#	@`var1`=_binary 0x8300 COLLATE binary
+master-bin.000001	#	Query	1	#	use `test`; INSERT INTO t1 VALUES(@'var1')
 SELECT HEX(f1) FROM t1;
 HEX(f1)
 8300
diff --git a/mysql-test/t/ctype_cp932.test b/mysql-test/t/ctype_cp932.test
index 34bf7965248..8f471ebb979 100644
--- a/mysql-test/t/ctype_cp932.test
+++ b/mysql-test/t/ctype_cp932.test
@@ -403,6 +403,7 @@ DROP TABLE t3;
 
 # Test prepared statement with 0x8300 sequence in parameter while
 # running with cp932 client character set.
+RESET MASTER;
 CREATE TABLE t1(f1 blob);
 PREPARE stmt1 FROM 'INSERT INTO t1 VALUES(?)';
 SET @var1= x'8300';
@@ -417,7 +418,8 @@ SET @var1= x'8300';
 # code (and I have used it to test the fix) until there is some way to
 # exercise this code from mysql-test-run.
 EXECUTE stmt1 USING @var1;
-SHOW BINLOG EVENTS FROM 27642;
+--replace_column 2 # 5 #
+SHOW BINLOG EVENTS;
 SELECT HEX(f1) FROM t1;
 DROP table t1;
 # end test for bug#11338

From ad8c5c9df914366314cd01832521c818b997a21e Mon Sep 17 00:00:00 2001
From: unknown <pappa@c-4a09e253.1238-1-64736c10.cust.bredbandsbolaget.se>
Date: Sat, 20 Aug 2005 10:07:46 -0400
Subject: [PATCH 9/9] Bug #12460 Table Full On 64 bit platforms the changed
 statement doesn't work so making sure that the larger value is first and
 using subtraction is a quick and backwards-compatible fix of this line.

---
 heap/hp_delete.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/heap/hp_delete.c b/heap/hp_delete.c
index 9cf8b8936b6..90e537081d3 100644
--- a/heap/hp_delete.c
+++ b/heap/hp_delete.c
@@ -80,7 +80,7 @@ int hp_rb_delete_key(HP_INFO *info, register HP_KEYDEF *keyinfo,
   custom_arg.search_flag= SEARCH_SAME;
   old_allocated= keyinfo->rb_tree.allocated;
   res= tree_delete(&keyinfo->rb_tree, info->recbuf, &custom_arg);
-  info->s->index_length+= (keyinfo->rb_tree.allocated-old_allocated);
+  info->s->index_length-= (old_allocated - keyinfo->rb_tree.allocated);
   return res;
 }