Remove usage of !$ from mysql-tests

Added protocol::flush() for easier embedded-server code
Increase block allocation variables a bit as they where a bit too small for MySQL 4.1
Added option --silent to client_test


client/mysqltest.c:
  Removed compiler warning
  Fixed identation & comments from earlier push
  Renamed variable 'disable_abort_on_error' to 'abort_on_error'
  Ensure that '$mysql_errno' also with --ps-protocol
include/mysql_com.h:
  Removed special handling of net_flush for embedded server
mysql-test/r/mysqltest.result:
  Remove usage of !$ in tests
mysql-test/t/client_test.test:
  Use --silent
mysql-test/t/comments.test:
  Remove usage of !$ in tests
mysql-test/t/join_outer.test:
  Remove usage of !$ in tests
mysql-test/t/key.test:
  Remove usage of !$ in tests
mysql-test/t/mysqltest.test:
  Remove usage of !$ in tests
mysql-test/t/show_check.test:
  Remove usage of !$ in tests
mysql-test/t/temp_table.test:
  Remove usage of !$ in tests
mysql-test/t/type_ranges.test:
  Remove usage of !$ in tests
sql/mysqld.cc:
  Increase block allocation variables a bit as they where a bit too small for MySQL 4.1
sql/net_serv.cc:
  Remove special usage of net_flush in embedded server
sql/protocol.cc:
  Added protocol::flush() for easier embedded-server code
sql/protocol.h:
  Added protocol::flush() for easier embedded-server code
sql/sql_prepare.cc:
  Added protocol::flush() for easier embedded-server code
  Remove one extra flush() for prepared statements
sql/sql_show.cc:
  Added protocol::flush() for easier embedded-server code
tests/client_test.c:
  Added option --silent

client/mysqltest.c

@@ -42,7 +42,7 @@
 
 **********************************************************************/
 
-#define MTEST_VERSION "2.3"
+#define MTEST_VERSION "2.4"
 
 #include <my_global.h>
 #include <mysql_embed.h>
@@ -243,8 +243,7 @@ VAR var_reg[10];
 HASH var_hash;
 my_bool disable_query_log=0, disable_result_log=0, disable_warnings=0;
 my_bool disable_info= 1;			/* By default off */
-/* default for disable_abort_on_error: false = abort on unmasked error */
-my_bool disable_abort_on_error= 0;
+my_bool abort_on_error= 1;
 
 struct connection cons[MAX_CONS];
 struct connection* cur_con, *next_con, *cons_end;
@@ -370,7 +369,7 @@ const char *command_names[]=
 };
 
 TYPELIB command_typelib= {array_elements(command_names),"",
-			  command_names};
+			  command_names, 0};
 
 DYNAMIC_STRING ds_res;
 static void die(const char *fmt, ...);
@@ -744,7 +743,7 @@ VAR* var_get(const char* var_name, const char** var_name_end, my_bool raw,
   DBUG_RETURN(0);
 }
 
-static VAR* var_obtain(char* name, int len)
+static VAR *var_obtain(const char* name, int len)
 {
   VAR* v;
   if ((v = (VAR*)hash_search(&var_hash, name, len)))
@@ -754,28 +753,33 @@ static VAR* var_obtain(char* name, int len)
   return v;
 }
 
-int var_set(char* var_name, char* var_name_end, char* var_val,
-	    char* var_val_end)
+int var_set(const char *var_name, const char *var_name_end,
+            const char *var_val, const char *var_val_end)
 {
   int digit;
   VAR* v;
+  DBUG_ENTER("var_set");
+  DBUG_PRINT("enter", ("var_name: '%.*s' = '%.*s' (length: %d)",
+                       (int) (var_name_end - var_name), var_name,
+                       (int) (var_val_end - var_val), var_val,
+                       (int) (var_val_end - var_val)));
+
   if (*var_name++ != '$')
   {
-      --var_name;
-      *var_name_end = 0;
+    var_name--;
     die("Variable name in %s does not start with '$'", var_name);
   }
   digit = *var_name - '0';
   if (!(digit < 10 && digit >= 0))
   {
-      v = var_obtain(var_name, var_name_end - var_name);
+    v = var_obtain(var_name, (uint) (var_name_end - var_name));
   }
   else
     v = var_reg + digit;
-
   return eval_expr(v, var_val, (const char**)&var_val_end);
 }
 
+
 int open_file(const char* name)
 {
   char buff[FN_REFLEN];
@@ -1244,18 +1248,22 @@ int do_let(struct st_query* q)
   return var_set(var_name, var_name_end, var_val_start, q->end);
 }
 
-/* Store an integer (typically the returncode of the last SQL)  */
-/* statement in the mysqltest builtin variable $mysql_errno, by */
-/* simulating of a user statement "let $mysql_errno= <integer>" */
-int var_set_errno(int sql_errno )
+
+/*
+  Store an integer (typically the returncode of the last SQL)
+  statement in the mysqltest builtin variable $mysql_errno, by
+  simulating of a user statement "let $mysql_errno= <integer>"
+*/
+
+int var_set_errno(int sql_errno)
 {
-  char var_name[] = "$mysql_errno", var_val[30];
-  sprintf(var_val, "%d", sql_errno);
-  /* On some odd systems, the return value from sprintf() isn't */
-  /* always the length of the string, so we use strlen()        */
-   return var_set(var_name, var_name + 12, var_val, var_val + strlen(var_val));
+  const char *var_name= "$mysql_errno";
+  char var_val[21];
+  uint length= my_sprintf(var_val, (var_val, "%d", sql_errno));
+  return var_set(var_name, var_name + 12, var_val, var_val + length);
 }
 
+
 int do_rpl_probe(struct st_query* q __attribute__((unused)))
 {
   DBUG_ENTER("do_rpl_probe");
@@ -1264,12 +1272,14 @@ int do_rpl_probe(struct st_query* q __attribute__((unused)))
   DBUG_RETURN(0);
 }
 
+
 int do_enable_rpl_parse(struct st_query* q __attribute__((unused)))
 {
   mysql_enable_rpl_parse(&cur_con->mysql);
   return 0;
 }
 
+
 int do_disable_rpl_parse(struct st_query* q __attribute__((unused)))
 {
   mysql_disable_rpl_parse(&cur_con->mysql);
@@ -2013,7 +2023,7 @@ int read_query(struct st_query** q_ptr)
   memcpy((gptr) q->expected_errno, (gptr) global_expected_errno,
 	 sizeof(global_expected_errno));
   q->expected_errors= global_expected_errors;
-  q->abort_on_error= (global_expected_errors == 0 && !disable_abort_on_error);
+  q->abort_on_error= (global_expected_errors == 0 && abort_on_error);
   bzero((gptr) global_expected_errno, sizeof(global_expected_errno));
   global_expected_errors=0;
   if (p[0] == '-' && p[1] == '-')
@@ -2422,7 +2432,7 @@ static int run_query(MYSQL *mysql, struct st_query *q, int flags)
 
   if (ps_protocol_enabled && disable_info &&
       (flags & QUERY_SEND) && (flags & QUERY_REAP) && ps_match_re(q->query))
-    return run_query_stmt  (mysql, q, flags);
+    return run_query_stmt(mysql, q, flags);
   return run_query_normal(mysql, q, flags);
 }
 
@@ -2659,9 +2669,12 @@ static int run_query_normal(MYSQL* mysql, struct st_query* q, int flags)
     dynstr_free(&ds_tmp);
   if (q->type == Q_EVAL)
     dynstr_free(&eval_query);
-  /* We save the return code (mysql_errno(mysql)) from the last call sent */
-  /* to the server into the mysqltest builtin variable $mysql_errno. This */
-  /* variable then can be used from the test case itself.                 */
+
+  /*
+    We save the return code (mysql_errno(mysql)) from the last call sent
+    to the server into the mysqltest builtin variable $mysql_errno. This
+    variable then can be used from the test case itself.
+  */
   var_set_errno(mysql_errno(mysql));
   DBUG_RETURN(error);
 }
@@ -3012,6 +3025,7 @@ static int run_query_stmt(MYSQL *mysql, struct st_query *q, int flags)
     dynstr_free(&ds_tmp);
   if (q->type == Q_EVAL)
     dynstr_free(&eval_query);
+  var_set_errno(mysql_stmt_errno(stmt));
   mysql_stmt_close(stmt);
   DBUG_RETURN(error);
 }
@@ -3319,7 +3333,7 @@ static VAR* var_from_env(const char *name, const char *def_val)
   if (!(tmp = getenv(name)))
     tmp = def_val;
 
-  v = var_init(0, name, 0, tmp, 0);
+  v = var_init(0, name, strlen(name), tmp, strlen(tmp));
   my_hash_insert(&var_hash, (byte*)v);
   return v;
 }
@@ -3416,9 +3430,11 @@ int main(int argc, char **argv)
 
   init_var_hash(&cur_con->mysql);
 
-  /* Initialize $mysql_errno with -1, so we can                  */
-  /* - distinguish it from valid values ( >= 0 )   and           */
-  /* - detect if there was never a command sent to the server    */
+  /*
+    Initialize $mysql_errno with -1, so we can
+    - distinguish it from valid values ( >= 0 ) and
+    - detect if there was never a command sent to the server
+  */
   var_set_errno(-1);
 
   while (!read_query(&q))
@@ -3440,8 +3456,8 @@ int main(int argc, char **argv)
       case Q_DISABLE_RPL_PARSE:  do_disable_rpl_parse(q); break;
       case Q_ENABLE_QUERY_LOG:	 disable_query_log=0; break;
       case Q_DISABLE_QUERY_LOG:  disable_query_log=1; break;
-      case Q_ENABLE_ABORT_ON_ERROR:  disable_abort_on_error=0; break;
-      case Q_DISABLE_ABORT_ON_ERROR: disable_abort_on_error=1; break;
+      case Q_ENABLE_ABORT_ON_ERROR:  abort_on_error=1; break;
+      case Q_DISABLE_ABORT_ON_ERROR: abort_on_error=0; break;
       case Q_ENABLE_RESULT_LOG:  disable_result_log=0; break;
       case Q_DISABLE_RESULT_LOG: disable_result_log=1; break;
       case Q_ENABLE_WARNINGS:    disable_warnings=0; break;

include/mysql_com.h

@@ -282,13 +282,7 @@ void	my_net_local_init(NET *net);
 void	net_end(NET *net);
 void	net_clear(NET *net);
 my_bool net_realloc(NET *net, unsigned long length);
-
-#ifndef EMBEDDED_LIBRARY /* To be removed by HF */
 my_bool	net_flush(NET *net);
-#else
-#define net_flush(A)
-#endif
-
 my_bool	my_net_write(NET *net,const char *packet,unsigned long len);
 my_bool	net_write_command(NET *net,unsigned char command,
 			  const char *header, unsigned long head_len,

mysql-test/r/mysqltest.result

@@ -7,11 +7,6 @@ otto
 select otto from (select 1 as otto) as t1;
 otto
 1
-select otto from (select 1 as otto) as t1;
-otto
-1
-select friedrich from (select 1 as otto) as t1;
-ERROR 42S22: Unknown column 'friedrich' in 'field list'
 select friedrich from (select 1 as otto) as t1;
 ERROR 42S22: Unknown column 'friedrich' in 'field list'
 select otto from (select 1 as otto) as t1;
@@ -147,5 +142,3 @@ after_--enable_abort_on_error
 1064
 select 3 from t1 ;
 ERROR 42S02: Table 'test.t1' doesn't exist
-select 3 from t1 ;
-ERROR 42S02: Table 'test.t1' doesn't exist

mysql-test/t/client_test.test

 --disable_result_log
---exec $TESTS_BINDIR/client_test --testcase --user=root --socket=$MASTER_MYSOCK --port=$MYSQL_TCP_PORT
+--exec $TESTS_BINDIR/client_test --testcase --user=root --socket=$MASTER_MYSOCK --port=$MYSQL_TCP_PORT --silent

mysql-test/t/comments.test

@@ -5,7 +5,8 @@
 select 1+2/*hello*/+3;
 select 1 /* long
 multi line comment */;
-!$1065 ;
+--error 1065
+ ;
 select 1 /*!32301 +1 */;
 select 1 /*!52301 +1 */;
 select 1--1;

mysql-test/t/join_outer.test

@@ -34,11 +34,14 @@ explain select t1.*,t2.* from t1 left join t2 on t1.a=t2.a where isnull(t2.a)=1;
 select t1.*,t2.*,t3.a from t1 left join t2 on (t1.a=t2.a) left join t1 as t3 on (t2.a=t3.a);
 
 # The next query should rearange the left joins to get this to work
-!$1120 explain select t1.*,t2.*,t3.a from t1 left join t2 on (t3.a=t2.a) left join t1 as t3 on (t1.a=t3.a);
-!$1120 select t1.*,t2.*,t3.a from t1 left join t2 on (t3.a=t2.a) left join t1 as t3 on (t1.a=t3.a);
+--error 1120
+explain select t1.*,t2.*,t3.a from t1 left join t2 on (t3.a=t2.a) left join t1 as t3 on (t1.a=t3.a);
+--error 1120
+select t1.*,t2.*,t3.a from t1 left join t2 on (t3.a=t2.a) left join t1 as t3 on (t1.a=t3.a);
 
 # The next query should give an error in MySQL
-!$1120 select t1.*,t2.*,t3.a from t1 left join t2 on (t3.a=t2.a) left join t1 as t3 on (t2.a=t3.a);
+--error 1120
+select t1.*,t2.*,t3.a from t1 left join t2 on (t3.a=t2.a) left join t1 as t3 on (t2.a=t3.a);
 
 # Test of inner join
 select t1.*,t2.* from t1 inner join t2 using (a);
@@ -94,7 +97,8 @@ WHERE t1.uniq_id = 4
 ORDER BY t2.c_amount;
 
 INSERT INTO t2 VALUES (2,3,3000,6000,0,0,746584,837484,'yes');
-!$1062 INSERT INTO t2 VALUES (2,3,3000,6000,0,0,746584,837484,'yes');
+--error 1062
+INSERT INTO t2 VALUES (2,3,3000,6000,0,0,746584,837484,'yes');
 INSERT INTO t2 VALUES (7,3,1000,2000,0,0,746294,937484,'yes');
 
 #3rd select should show that one record is returned with null entries for the
@@ -288,7 +292,8 @@ insert into t3 values (1);
 insert into t4 values (1,1);
 insert into t5 values (1,1);
 
-!$1120 explain select * from t3 left join t4 on t4.seq_1_id = t2.t2_id left join t1 on t1.t1_id = t4.seq_0_id left join t5 on t5.seq_0_id = t1.t1_id left join t2 on t2.t2_id = t5.seq_1_id where t3.t3_id = 23;
+--error 1120
+explain select * from t3 left join t4 on t4.seq_1_id = t2.t2_id left join t1 on t1.t1_id = t4.seq_0_id left join t5 on t5.seq_0_id = t1.t1_id left join t2 on t2.t2_id = t5.seq_1_id where t3.t3_id = 23;
 
 drop table t1,t2,t3,t4,t5;
 

mysql-test/t/key.test

@@ -146,7 +146,8 @@ create table t1
 );
 INSERT INTO t1 VALUES (1, 1, 1, 1, 'a'); 
 INSERT INTO t1 VALUES (1, 1, 1, 1, 'b'); 
-!$1062 INSERT INTO t1 VALUES (1, 1, 1, 1, 'a');
+--error 1062
+INSERT INTO t1 VALUES (1, 1, 1, 1, 'a');
 drop table t1;
 
 #

mysql-test/t/mysqltest.test

@@ -20,12 +20,10 @@ eval select $mysql_errno as "before_use_test" ;
 
 select otto from (select 1 as otto) as t1;
 # expectation = response
-!$0 select otto from (select 1 as otto) as t1;
 --error 0
 select otto from (select 1 as otto) as t1;
 
 # expectation <> response
--- // !$1054 select otto from (select 1 as otto) as t1;
 -- // --error 1054
 -- // select otto from (select 1 as otto) as t1;
 
@@ -38,12 +36,10 @@ select otto from (select 1 as otto) as t1;
 # ----------------------------------------------------------------------------
 
 # expectation <> response
-#!$0 select friedrich from (select 1 as otto) as t1;
 #--error 0
 #select friedrich from (select 1 as otto) as t1;
 
 # expectation = response
-!$1054 select friedrich from (select 1 as otto) as t1;
 --error 1054
 select friedrich from (select 1 as otto) as t1;
 
@@ -94,130 +90,130 @@ select friedrich from (select 1 as otto) as t1;
 #
 #      The following test cases often initialize $mysql_errno to 1064 by 
 #      a command with wrong syntax.
-#      Example: !$1064      To prevent the abort after the error.
+#      Example: --error 1064      To prevent the abort after the error.
 #               garbage ;
 # ----------------------------------------------------------------------------
 
 # ----------------------------------------------------------------------------
-# 1. check mysql_errno = 0 after successful statement
+# check mysql_errno = 0 after successful statement
 # ----------------------------------------------------------------------------
 select otto from (select 1 as otto) as t1;
 eval select $mysql_errno as "after_successful_stmt_errno" ;
 
 #----------------------------------------------------------------------------
-# 2. check mysql_errno = 1064 after statement with wrong syntax
+# check mysql_errno = 1064 after statement with wrong syntax
 # ----------------------------------------------------------------------------
-!$1064
+--error 1064
 garbage ;
 eval select $mysql_errno as "after_wrong_syntax_errno" ;
 
 # ----------------------------------------------------------------------------
-# 3. check if let $my_var= 'abc' ; affects $mysql_errno
+# check if let $my_var= 'abc' ; affects $mysql_errno
 # ----------------------------------------------------------------------------
-!$1064
+--error 1064
 garbage ;
 let $my_var= 'abc' ;
 eval select $mysql_errno as "after_let_var_equal_value" ;
 
 # ----------------------------------------------------------------------------
-# 4. check if set @my_var= 'abc' ; affects $mysql_errno
+# check if set @my_var= 'abc' ; affects $mysql_errno
 # ----------------------------------------------------------------------------
-!$1064
+--error 1064
 garbage ;
 set @my_var= 'abc' ;
 eval select $mysql_errno as "after_set_var_equal_value" ;
 
 # ----------------------------------------------------------------------------
-# 5. check if the setting of --disable-warnings itself affects $mysql_errno
+#  check if the setting of --disable-warnings itself affects $mysql_errno
 #  (May be --<whatever> modifies $mysql_errno.)
 # ----------------------------------------------------------------------------
-!$1064
+--error 1064
 garbage ;
 --disable_warnings
 eval select $mysql_errno as "after_disable_warnings_command" ;
 
 # ----------------------------------------------------------------------------
-# 6. check if --disable-warnings + command with warning affects the errno
+# check if --disable-warnings + command with warning affects the errno
 # stored within $mysql_errno
 # (May be disabled warnings affect $mysql_errno.)
 # ----------------------------------------------------------------------------
 drop table if exists t1 ;
-!$1064
+--error 1064
 garbage ;
 drop table if exists t1 ;
 eval select $mysql_errno as "after_disable_warnings" ;
 --enable_warnings
 
 # ----------------------------------------------------------------------------
-# 7. check if masked errors affect $mysql_errno
+# check if masked errors affect $mysql_errno
 # ----------------------------------------------------------------------------
-!$1064
+--error 1064
 garbage ;
 --error 1146
 select 3 from t1 ;
 eval select $mysql_errno as "after_minus_masked" ;
-!$1064
+--error 1064
 garbage ;
-!$1146
+--error 1146
 select 3 from t1 ;
 eval select $mysql_errno as "after_!_masked" ;
 
 # ----------------------------------------------------------------------------
-# 8. Will manipulations of $mysql_errno be possible and visible ?
+# Will manipulations of $mysql_errno be possible and visible ?
 # ----------------------------------------------------------------------------
-!$1064
+--error 1064
 garbage ;
 let $mysql_errno= -1;
 eval select $mysql_errno as "after_let_errno_equal_value" ;
 
 # ----------------------------------------------------------------------------
-# 9. How affect actions on prepared statements $mysql_errno ?
+# How affect actions on prepared statements $mysql_errno ?
 # ----------------------------------------------------------------------------
 # failing prepare
-!$1064
+--error 1064
 garbage ;
-!$1146
+--error 1146
 prepare stmt from "select 3 from t1" ;
 eval select $mysql_errno as "after_failing_prepare" ;
 create table t1 ( f1 char(10));
 
 # successful prepare
-!$1064
+--error 1064
 garbage ;
 prepare stmt from "select 3 from t1" ;
 eval select $mysql_errno as "after_successful_prepare" ;
 
 # successful execute
-!$1064
+--error 1064
 garbage ;
 execute stmt;
 eval select $mysql_errno as "after_successful_execute" ;
 
 # failing execute (table dropped)
 drop table t1;
-!$1064
+--error 1064
 garbage ;
-!$1146
+--error 1146
 execute stmt;
 eval select $mysql_errno as "after_failing_execute" ;
 
 # failing execute (unknown statement)
-!$1064
+--error 1064
 garbage ;
-!$1243
+--error 1243
 execute __stmt_;
 eval select $mysql_errno as "after_failing_execute" ;
 
 # successful deallocate
-!$1064
+--error 1064
 garbage ;
 deallocate prepare stmt;
 eval select $mysql_errno as "after_successful_deallocate" ;
 
 # failing deallocate ( statement handle does not exist )
-!$1064
+--error 1064
 garbage ;
-!$1243
+--error 1243
 deallocate prepare __stmt_;
 eval select $mysql_errno as "after_failing_deallocate" ;
 
@@ -231,7 +227,7 @@ eval select $mysql_errno as "after_failing_deallocate" ;
 # The default is "--enable_abort_on_error".
 #
 # "Maskings" are
-#   !$<error number>  and  --error <error number>
+#   --error <error number>  and  --error <error number>
 # in the line before the failing statement.
 #
 # There are some additional test case for $mysql_errno
@@ -240,58 +236,53 @@ eval select $mysql_errno as "after_failing_deallocate" ;
 # ----------------------------------------------------------------------------
 
 # ----------------------------------------------------------------------------
-# 1. Switch the abort on error off and check the effect on $mysql_errno
+# Switch the abort on error off and check the effect on $mysql_errno
 # ----------------------------------------------------------------------------
-!$1064
+--error 1064
 garbage ;
 --disable_abort_on_error
 eval select $mysql_errno as "after_--disable_abort_on_error" ;
 
 # ----------------------------------------------------------------------------
-# 2. "unmasked" failing statement should not cause an abort
+# "unmasked" failing statement should not cause an abort
 # ----------------------------------------------------------------------------
 select 3 from t1 ;
 
 # ----------------------------------------------------------------------------
-# 3. masked failing statements
+# masked failing statements
 # ----------------------------------------------------------------------------
 # expected error = response
 --error 1146
 select 3 from t1 ;
-!$1146
+--error 1146
 select 3 from t1 ;
 eval select $mysql_errno as "after_!errno_masked_error" ;
 # expected error <> response
 # --error 1000
 # select 3 from t1 ;
-# !$1000
+# --error 1000
 # select 3 from t1 ;
 
 # ----------------------------------------------------------------------------
-# 4. Switch the abort on error on and check the effect on $mysql_errno
+# Switch the abort on error on and check the effect on $mysql_errno
 # ----------------------------------------------------------------------------
-!$1064
+--error 1064
 garbage ;
 --enable_abort_on_error
 eval select $mysql_errno as "after_--enable_abort_on_error" ;
 
 # ----------------------------------------------------------------------------
-# 5. masked failing statements
+# masked failing statements
 # ----------------------------------------------------------------------------
 # expected error = response
 --error 1146
 select 3 from t1 ;
-!$1146
-select 3 from t1 ;
 
 # ----------------------------------------------------------------------------
-# 6. check that the old default behaviour is not changed
+# check that the old default behaviour is not changed
 # Please remove the '#' to get the abort on error
 # ----------------------------------------------------------------------------
 #--error 1064
 #select 3 from t1 ;
 #
-#!$1064
-#select 3 from t1 ;
-#
 #select 3 from t1 ;

mysql-test/t/show_check.test

@@ -21,7 +21,8 @@ check table t1 changed;
 check table t1 medium;
 check table t1 extended;
 show index from t1;
-!$1062 insert into t1 values (5,5,5);
+--error 1062
+insert into t1 values (5,5,5);
 optimize table t1;
 optimize table t1;
 drop table t1;

mysql-test/t/temp_table.test

@@ -20,8 +20,10 @@ create TEMPORARY TABLE t2 engine=heap select * from t1;
 create TEMPORARY TABLE IF NOT EXISTS t2 (a int) engine=heap;
 
 # This should give errors
-!$1050 CREATE TEMPORARY TABLE t1 (a int not null, b char (10) not null);
-!$1050 ALTER TABLE t1 RENAME t2;
+--error 1050
+CREATE TEMPORARY TABLE t1 (a int not null, b char (10) not null);
+--error 1050
+ALTER TABLE t1 RENAME t2;
 
 select * from t2;
 alter table t2 add primary key (a,b);

mysql-test/t/type_ranges.test

@@ -135,7 +135,8 @@ drop table t1,t2;
 create table t1 (c int);
 insert into t1 values(1),(2);
 create table t2 select * from t1;
-!$1060 create table t3 select * from t1, t2; # Should give an error
+--error 1060
+create table t3 select * from t1, t2; # Should give an error
 create table t3 select t1.c AS c1, t2.c AS c2,1 as "const" from t1, t2;
 show full columns from t3;
 drop table t1,t2,t3;

sql/mysqld.cc

@@ -5026,12 +5026,12 @@ The minimum value for this variable is 4096.",
    "Persistent buffer for query parsing and execution",
    (gptr*) &global_system_variables.query_prealloc_size,
    (gptr*) &max_system_variables.query_prealloc_size, 0, GET_ULONG,
-   REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, 1024, ~0L, 0, 1024, 0},
+   REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, 16384, ~0L, 0, 1024, 0},
   {"range_alloc_block_size", OPT_RANGE_ALLOC_BLOCK_SIZE,
    "Allocation block size for storing ranges during optimization",
    (gptr*) &global_system_variables.range_alloc_block_size,
    (gptr*) &max_system_variables.range_alloc_block_size, 0, GET_ULONG,
-   REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, 1024, ~0L, 0, 1024, 0},
+   REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, 4096, ~0L, 0, 1024, 0},
   {"read_buffer_size", OPT_RECORD_BUFFER,
    "Each thread that does a sequential scan allocates a buffer of this size for each table it scans. If you do many sequential scans, you may want to increase this value.",
    (gptr*) &global_system_variables.read_buff_size,

sql/net_serv.cc

@@ -53,19 +53,9 @@
 #include <errno.h>
 
 #ifdef EMBEDDED_LIBRARY
-
 #undef MYSQL_SERVER
-
-#ifndef MYSQL_CLIENT
+#undef MYSQL_CLIENT
 #define MYSQL_CLIENT
-#endif
-
-#undef net_flush
-
-extern "C" {
-my_bool	net_flush(NET *net);
-}
-
 #endif /*EMBEDDED_LIBRARY */
 
 

sql/protocol.cc

@@ -470,6 +470,15 @@ void Protocol::init(THD *thd_arg)
 }
 
 
+bool Protocol::flush()
+{
+#ifndef EMBEDDED_LIBRARY
+  return net_flush(&thd->net);
+#else
+  return 0;
+#endif
+}
+
 /*
   Send name and type of result to client.
 

sql/protocol.h

@@ -75,6 +75,7 @@ class Protocol
     field_count=item_list->elements;
     return 0;
   }
+  virtual bool flush();
   virtual void prepare_for_resend()=0;
 
   virtual bool store_null()=0;

sql/sql_prepare.cc

@@ -153,6 +153,8 @@ static bool send_prep_stmt(Prepared_statement *stmt, uint columns)
 {
   NET *net= &stmt->thd->net;
   char buff[9];
+  DBUG_ENTER("send_prep_stmt");
+
   buff[0]= 0;                                   /* OK packet indicator */
   int4store(buff+1, stmt->id);
   int2store(buff+5, columns);
@@ -161,12 +163,11 @@ static bool send_prep_stmt(Prepared_statement *stmt, uint columns)
     Send types and names of placeholders to the client
     XXX: fix this nasty upcast from List<Item_param> to List<Item>
   */
-  return my_net_write(net, buff, sizeof(buff)) || 
+  DBUG_RETURN(my_net_write(net, buff, sizeof(buff)) || 
               (stmt->param_count &&
                stmt->thd->protocol_simple.send_fields((List<Item> *)
-                                                 &stmt->lex->param_list, 0)) ||
-         net_flush(net);
-  return 0;
+                                                      &stmt->lex->param_list,
+                                                      0)));
 }
 #else
 static bool send_prep_stmt(Prepared_statement *stmt,
@@ -1088,7 +1089,7 @@ static int mysql_test_select(Prepared_statement *stmt,
   {
     if (lex->describe)
     {
-      if (send_prep_stmt(stmt, 0))
+      if (send_prep_stmt(stmt, 0) || thd->protocol->flush())
         goto err_prep;
     }
     else
@@ -1106,11 +1107,8 @@ static int mysql_test_select(Prepared_statement *stmt,
         prepared in unit->prepare call above.
       */
       if (send_prep_stmt(stmt, lex->result->field_count(fields)) ||
-          lex->result->send_fields(fields, 0)
-#ifndef EMBEDDED_LIBRARY
-          || net_flush(&thd->net)
-#endif
-         )
+          lex->result->send_fields(fields, 0) ||
+          thd->protocol->flush())
         goto err_prep;
     }
   }
@@ -1389,7 +1387,6 @@ static int send_prepare_results(Prepared_statement *stmt, bool text_protocol)
   enum enum_sql_command sql_command= lex->sql_command;
   int res= 0;
   DBUG_ENTER("send_prepare_results");
-
   DBUG_PRINT("enter",("command: %d, param_count: %ld",
                       sql_command, stmt->param_count));
 
@@ -1475,7 +1472,8 @@ static int send_prepare_results(Prepared_statement *stmt, bool text_protocol)
     goto error;
   }
   if (res == 0)
-    DBUG_RETURN(text_protocol? 0 : send_prep_stmt(stmt, 0));
+    DBUG_RETURN(text_protocol? 0 : (send_prep_stmt(stmt, 0) ||
+                                    thd->protocol->flush()));
 error:
   if (res < 0)
     send_error(thd, thd->killed ? ER_SERVER_SHUTDOWN : 0);

sql/sql_show.cc

@@ -1081,7 +1081,7 @@ mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild)
   restore_record(table,default_values);              // Get empty record
   if (thd->protocol->send_fields(&field_list,2))
     DBUG_VOID_RETURN;
-  net_flush(&thd->net);
+  thd->protocol->flush();
   DBUG_VOID_RETURN;
 }
 
@@ -1098,13 +1098,11 @@ mysqld_dump_create_info(THD *thd, TABLE *table, int fd)
   if (store_create_info(thd, table, packet))
     DBUG_RETURN(-1);
 
-  //if (protocol->convert)
-  //  protocol->convert->convert((char*) packet->ptr(), packet->length());
   if (fd < 0)
   {
     if (protocol->write())
       DBUG_RETURN(-1);
-    net_flush(&thd->net);
+    protocol->flush();
   }
   else
   {