merged

sql/field.cc:
  Auto merged
sql/item.cc:
  Auto merged
sql/log_event.cc:
  Auto merged
sql/opt_range.cc:
  Auto merged
sql/sql_acl.cc:
  Auto merged
sql/sql_insert.cc:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_handler.cc:
  ur

46 files changed, 436 insertions, 299 deletions

diff --git a/include/config-win.h b/include/config-win.h
index b825d34f1ee..53483f3f39d 100644
--- a/include/config-win.h
+++ b/include/config-win.h
@@ -22,6 +22,11 @@ functions */
 #define _WIN32_WINNT     0x0500
 #endif
 
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+/* Avoid endless warnings about sprintf() etc. being unsafe. */
+#define _CRT_SECURE_NO_DEPRECATE 1
+#endif
+
 #include <sys/locking.h>
 #include <windows.h>
 #include <math.h>			/* Because of rint() */
@@ -329,6 +334,11 @@ inline double ulonglong2double(ulonglong value)
 #define HAVE_SETFILEPOINTER
 #define HAVE_VIO_READ_BUFF
 
+#if defined(_WIN64) && defined(_M_X64)
+/* Avoid type conflicts with built-in functions. */
+#define HAVE_STRNLEN
+#endif
+
 #ifndef __NT__
 #undef FILE_SHARE_DELETE
 #define FILE_SHARE_DELETE 0     /* Not implemented on Win 98/ME */
diff --git a/include/hash.h b/include/hash.h
index 9a6d91036e1..8f5ff21ae5e 100644
--- a/include/hash.h
+++ b/include/hash.h
@@ -33,7 +33,7 @@ typedef void (*hash_free_key)(void *);
 
 typedef struct st_hash {
   uint key_offset,key_length;		/* Length of key if const length */
-  uint records,blength,current_record;
+  uint records, blength;
   uint flags;
   DYNAMIC_ARRAY array;				/* Place for hash_keys */
   hash_get_key get_key;
@@ -41,6 +41,9 @@ typedef struct st_hash {
   CHARSET_INFO *charset;
 } HASH;
 
+/* A search iterator state */
+typedef uint HASH_SEARCH_STATE;
+
 #define hash_init(A,B,C,D,E,F,G,H) _hash_init(A,B,C,D,E,F,G, H CALLER_INFO)
 my_bool _hash_init(HASH *hash, CHARSET_INFO *charset,
 		   uint default_array_elements, uint key_offset,
@@ -49,12 +52,15 @@ my_bool _hash_init(HASH *hash, CHARSET_INFO *charset,
 void hash_free(HASH *tree);
 void my_hash_reset(HASH *hash);
 byte *hash_element(HASH *hash,uint idx);
-gptr hash_search(HASH *info,const byte *key,uint length);
-gptr hash_next(HASH *info,const byte *key,uint length);
+gptr hash_search(const HASH *info, const byte *key, uint length);
+gptr hash_first(const HASH *info, const byte *key, uint length,
+                HASH_SEARCH_STATE *state);
+gptr hash_next(const HASH *info, const byte *key, uint length,
+               HASH_SEARCH_STATE *state);
 my_bool my_hash_insert(HASH *info,const byte *data);
 my_bool hash_delete(HASH *hash,byte *record);
 my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length);
-void hash_replace(HASH *hash, uint idx, byte *new_row);
+void hash_replace(HASH *hash, HASH_SEARCH_STATE *state, byte *new_row);
 my_bool hash_check(HASH *hash);			/* Only in debug library */
 
 #define hash_clear(H) bzero((char*) (H),sizeof(*(H)))
diff --git a/include/my_global.h b/include/my_global.h
index e62f6c269aa..0df9ac78eb2 100644
--- a/include/my_global.h
+++ b/include/my_global.h
@@ -862,6 +862,7 @@ typedef off_t os_off_t;
 #define SOCKET_EAGAIN	WSAEINPROGRESS
 #define SOCKET_ETIMEDOUT WSAETIMEDOUT
 #define SOCKET_EWOULDBLOCK WSAEWOULDBLOCK
+#define SOCKET_EADDRINUSE WSAEADDRINUSE
 #define SOCKET_ENFILE	ENFILE
 #define SOCKET_EMFILE	EMFILE
 #elif defined(OS2)
@@ -870,6 +871,7 @@ typedef off_t os_off_t;
 #define SOCKET_EAGAIN	SOCEINPROGRESS
 #define SOCKET_ETIMEDOUT SOCKET_EINTR
 #define SOCKET_EWOULDBLOCK SOCEWOULDBLOCK
+#define SOCKET_EADDRINUSE SOCEADDRINUSE
 #define SOCKET_ENFILE	SOCENFILE
 #define SOCKET_EMFILE	SOCEMFILE
 #define closesocket(A)	soclose(A)
@@ -880,6 +882,7 @@ typedef off_t os_off_t;
 #define SOCKET_EAGAIN	EAGAIN
 #define SOCKET_ETIMEDOUT SOCKET_EINTR
 #define SOCKET_EWOULDBLOCK EWOULDBLOCK
+#define SOCKET_EADDRINUSE EADDRINUSE
 #define SOCKET_ENFILE	ENFILE
 #define SOCKET_EMFILE	EMFILE
 #endif
diff --git a/mysql-test/lib/mtr_process.pl b/mysql-test/lib/mtr_process.pl
index b3a243444c1..4d88c9b3322 100644
--- a/mysql-test/lib/mtr_process.pl
+++ b/mysql-test/lib/mtr_process.pl
@@ -890,7 +890,14 @@ sub mtr_exit ($) {
 #  cluck("Called mtr_exit()");
   mtr_timer_stop_all($::glob_timers);
   local $SIG{HUP} = 'IGNORE';
-  kill('HUP', -$$);
+  # ToDo: Signalling -$$ will only work if we are the process group
+  # leader (in fact on QNX it will signal our session group leader,
+  # which might be Do-compile or Pushbuild, causing tests to be
+  # aborted). So we only do it if we are the group leader. We might
+  # set ourselves as the group leader at startup (with
+  # POSIX::setpgrp(0,0)), but then care must be needed to always do
+  # proper child process cleanup.
+  kill('HUP', -$$) if $$ == getpgrp();
   sleep 2;
   exit($code);
 }
diff --git a/mysql-test/mysql-test-run.pl b/mysql-test/mysql-test-run.pl
index d64a487758d..2c53b94a248 100755
--- a/mysql-test/mysql-test-run.pl
+++ b/mysql-test/mysql-test-run.pl
@@ -804,6 +804,12 @@ sub command_line_setup () {
     }
   }
 
+  # On QNX, /tmp/dir/master.sock and /tmp/dir//master.sock seem to be
+  # considered different, so avoid the extra slash (/) in the socket
+  # paths.
+  my $sockdir = $opt_tmpdir;
+  $sockdir =~ s|/+$||;
+
   # Put this into a hash, will be a C struct
 
   $master->[0]=
@@ -812,7 +818,7 @@ sub command_line_setup () {
    path_myerr    => "$opt_vardir/log/master.err",
    path_mylog    => "$opt_vardir/log/master.log",
    path_mypid    => "$opt_vardir/run/master.pid",
-   path_mysock   => "$opt_tmpdir/master.sock",
+   path_mysock   => "$sockdir/master.sock",
    path_myport   =>  $opt_master_myport,
    start_timeout =>  400, # enough time create innodb tables
 
@@ -825,7 +831,7 @@ sub command_line_setup () {
    path_myerr    => "$opt_vardir/log/master1.err",
    path_mylog    => "$opt_vardir/log/master1.log",
    path_mypid    => "$opt_vardir/run/master1.pid",
-   path_mysock   => "$opt_tmpdir/master1.sock",
+   path_mysock   => "$sockdir/master1.sock",
    path_myport   => $opt_master_myport + 1,
    start_timeout => 400, # enough time create innodb tables
   };
@@ -836,7 +842,7 @@ sub command_line_setup () {
    path_myerr    => "$opt_vardir/log/slave.err",
    path_mylog    => "$opt_vardir/log/slave.log",
    path_mypid    => "$opt_vardir/run/slave.pid",
-   path_mysock   => "$opt_tmpdir/slave.sock",
+   path_mysock   => "$sockdir/slave.sock",
    path_myport   => $opt_slave_myport,
    start_timeout => 400,
   };
@@ -847,7 +853,7 @@ sub command_line_setup () {
    path_myerr    => "$opt_vardir/log/slave1.err",
    path_mylog    => "$opt_vardir/log/slave1.log",
    path_mypid    => "$opt_vardir/run/slave1.pid",
-   path_mysock   => "$opt_tmpdir/slave1.sock",
+   path_mysock   => "$sockdir/slave1.sock",
    path_myport   => $opt_slave_myport + 1,
    start_timeout => 300,
   };
@@ -858,7 +864,7 @@ sub command_line_setup () {
    path_myerr    => "$opt_vardir/log/slave2.err",
    path_mylog    => "$opt_vardir/log/slave2.log",
    path_mypid    => "$opt_vardir/run/slave2.pid",
-   path_mysock   => "$opt_tmpdir/slave2.sock",
+   path_mysock   => "$sockdir/slave2.sock",
    path_myport   => $opt_slave_myport + 2,
    start_timeout => 300,
   };
@@ -868,7 +874,7 @@ sub command_line_setup () {
    path_err =>        "$opt_vardir/log/im.err",
    path_log =>        "$opt_vardir/log/im.log",
    path_pid =>        "$opt_vardir/run/im.pid",
-   path_sock =>       "$opt_tmpdir/im.sock",
+   path_sock =>       "$sockdir/im.sock",
    port =>            $im_port,
    start_timeout =>   $master->[0]->{'start_timeout'},
    admin_login =>     'im_admin',
@@ -883,7 +889,7 @@ sub command_line_setup () {
    server_id    => 1,
    port         => $im_mysqld1_port,
    path_datadir => "$opt_vardir/im_mysqld_1.data",
-   path_sock    => "$opt_tmpdir/mysqld_1.sock",
+   path_sock    => "$sockdir/mysqld_1.sock",
    path_pid     => "$opt_vardir/run/mysqld_1.pid",
   };
 
@@ -892,7 +898,7 @@ sub command_line_setup () {
    server_id    => 2,
    port         => $im_mysqld2_port,
    path_datadir => "$opt_vardir/im_mysqld_2.data",
-   path_sock    => "$opt_tmpdir/mysqld_2.sock",
+   path_sock    => "$sockdir/mysqld_2.sock",
    path_pid     => "$opt_vardir/run/mysqld_2.pid",
    nonguarded   => 1,
   };
diff --git a/mysql-test/r/create.result b/mysql-test/r/create.result
index 7dabdfe0ef5..bbd4a60c5b1 100644
--- a/mysql-test/r/create.result
+++ b/mysql-test/r/create.result
@@ -272,7 +272,6 @@ a	b
 create table if not exists t1 select 3 as 'a',4 as 'b';
 Warnings:
 Note	1050	Table 't1' already exists
-Warning	1364	Field 'a' doesn't have a default value
 create table if not exists t1 select 3 as 'a',3 as 'b';
 ERROR 23000: Duplicate entry '3' for key 1
 select * from t1;
@@ -630,8 +629,6 @@ create table t1 (
 a varchar(112) charset utf8 collate utf8_bin not null,
 primary key (a)
 ) select 'test' as a ;
-Warnings:
-Warning	1364	Field 'a' doesn't have a default value
 show create table t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -647,14 +644,39 @@ create table t1 (
 a varchar(12) charset utf8 collate utf8_bin not null, 
 b int not null, primary key (a)
 ) select a, 1 as b from t2 ;
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` varchar(12) character set utf8 collate utf8_bin NOT NULL,
+  `b` int(11) NOT NULL,
+  PRIMARY KEY  (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+drop table t1;
+create table t1 ( 
+a varchar(12) charset utf8 collate utf8_bin not null, 
+b int not null, primary key (a)
+) select a, 1 as c from t2 ;
 Warnings:
-Warning	1364	Field 'a' doesn't have a default value
 Warning	1364	Field 'b' doesn't have a default value
 show create table t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
-  `a` varchar(12) character set utf8 collate utf8_bin NOT NULL,
   `b` int(11) NOT NULL,
+  `a` varchar(12) character set utf8 collate utf8_bin NOT NULL,
+  `c` bigint(1) NOT NULL default '0',
+  PRIMARY KEY  (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+drop table t1;
+create table t1 ( 
+a varchar(12) charset utf8 collate utf8_bin not null, 
+b int null, primary key (a)
+) select a, 1 as c from t2 ;
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `b` int(11) default NULL,
+  `a` varchar(12) character set utf8 collate utf8_bin NOT NULL,
+  `c` bigint(1) NOT NULL default '0',
   PRIMARY KEY  (`a`)
 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
 drop table t1;
@@ -662,9 +684,6 @@ create table t1 (
 a varchar(12) charset utf8 collate utf8_bin not null,
 b int not null, primary key (a)
 ) select 'a' as a , 1 as b from t2 ;
-Warnings:
-Warning	1364	Field 'a' doesn't have a default value
-Warning	1364	Field 'b' doesn't have a default value
 show create table t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -677,8 +696,6 @@ create table t1 (
 a varchar(12) charset utf8 collate utf8_bin,
 b int not null, primary key (a)
 ) select 'a' as a , 1 as b from t2 ;
-Warnings:
-Warning	1364	Field 'b' doesn't have a default value
 show create table t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -697,8 +714,6 @@ a1 varchar(12) charset utf8 collate utf8_bin not null,
 a2 int, a3 int, a4 int, a5 int, a6 int, a7 int, a8 int, a9 int,
 primary key (a1)
 ) select a1,a2,a3,a4,a5,a6,a7,a8,a9 from t1 ;
-Warnings:
-Warning	1364	Field 'a1' doesn't have a default value
 drop table t2;
 create table t2 ( 
 a1 varchar(12) charset utf8 collate utf8_bin,
@@ -714,8 +729,6 @@ a1 varchar(12) charset utf8 collate utf8_bin not null,
 a2 int, a3 int, a4 int, a5 int, a6 int, a7 int, a8 int, a9 int,
 primary key (a1)
 ) select a1,a2,a3,a4,a5,a6,a7,a8,a9 from t1 ;
-Warnings:
-Warning	1364	Field 'a1' doesn't have a default value
 drop table t2;
 create table t2 ( a int default 3, b int default 3)
 select a1,a2 from t1;
diff --git a/mysql-test/r/handler.result b/mysql-test/r/handler.result
index 133683fb273..104025e83eb 100644
--- a/mysql-test/r/handler.result
+++ b/mysql-test/r/handler.result
@@ -1,4 +1,4 @@
-drop table if exists t1;
+drop table if exists t1,t3,t4,t5;
 create table t1 (a int, b char(10), key a(a), key b(a,b));
 insert into t1 values
 (17,"ddd"),(18,"eee"),(19,"fff"),(19,"yyy"),
diff --git a/mysql-test/r/kill.result b/mysql-test/r/kill.result
index 754568093ff..2413834be4f 100644
--- a/mysql-test/r/kill.result
+++ b/mysql-test/r/kill.result
@@ -5,8 +5,6 @@ select ((@id := kill_id) - kill_id) from t1;
 ((@id := kill_id) - kill_id)
 0
 kill @id;
-select 1;
-Got one of the listed errors
 select ((@id := kill_id) - kill_id) from t1;
 ((@id := kill_id) - kill_id)
 0
diff --git a/mysql-test/r/mysqlshow.result b/mysql-test/r/mysqlshow.result
index 355c20fdad3..942cde83f21 100644
--- a/mysql-test/r/mysqlshow.result
+++ b/mysql-test/r/mysqlshow.result
@@ -1,4 +1,4 @@
-DROP TABLE IF EXISTS t1,t2;
+DROP TABLE IF EXISTS t1,t2,test1,test2;
 CREATE TABLE t1 (a int);
 INSERT INTO t1 VALUES (1),(2),(3);
 CREATE TABLE t2 (a int, b int);
diff --git a/mysql-test/r/rpl_sp.result b/mysql-test/r/rpl_sp.result
index 41bcfc7d72c..c9a9e162fa6 100644
--- a/mysql-test/r/rpl_sp.result
+++ b/mysql-test/r/rpl_sp.result
@@ -57,6 +57,9 @@ insert into t1 values (15);
 grant CREATE ROUTINE, EXECUTE on mysqltest1.* to "zedjzlcsjhd"@127.0.0.1;
 grant SELECT on mysqltest1.t1 to "zedjzlcsjhd"@127.0.0.1;
 grant SELECT, INSERT on mysqltest1.t2 to "zedjzlcsjhd"@127.0.0.1;
+SELECT 1;
+1
+1
 create procedure foo4()
 deterministic
 begin
diff --git a/mysql-test/r/trigger.result b/mysql-test/r/trigger.result
index e0048515fed..38dff6f8ca5 100644
--- a/mysql-test/r/trigger.result
+++ b/mysql-test/r/trigger.result
@@ -767,8 +767,7 @@ deallocate prepare stmt1;
 drop procedure p1;
 drop table t1, t2, t3;
 create table t1 (a int);
-drop procedure if exists p2;
-CREATE PROCEDURE `p2`()
+CREATE PROCEDURE `p1`()
 begin
 insert into t1 values (1);
 end//
@@ -777,8 +776,8 @@ begin
 declare done int default 0;
 set done= not done;
 end//
-CALL p2();
-drop procedure p2;
+CALL p1();
+drop procedure p1;
 drop table t1;
 create trigger t1_bi before insert on test.t1 for each row set @a:=0;
 ERROR 3D000: No database selected
diff --git a/mysql-test/r/view.result b/mysql-test/r/view.result
index 7e7d0617b51..b9380dcf033 100644
--- a/mysql-test/r/view.result
+++ b/mysql-test/r/view.result
@@ -2423,6 +2423,9 @@ drop view v1;
 drop table t1;
 create table t1(f1 int, f2 int);
 insert into t1 values (null, 10), (null,2);
+select f1, sum(f2) from t1 group by f1;
+f1	sum(f2)
+NULL	12
 create view v1 as select * from t1;
 select f1, sum(f2) from v1 group by f1;
 f1	sum(f2)
diff --git a/mysql-test/t/create.test b/mysql-test/t/create.test
index 4e99b0c4b8b..162db3d0c0a 100644
--- a/mysql-test/t/create.test
+++ b/mysql-test/t/create.test
@@ -566,6 +566,22 @@ drop table t1;
 
 --warning 1364
 create table t1 ( 
+  a varchar(12) charset utf8 collate utf8_bin not null, 
+  b int not null, primary key (a)
+) select a, 1 as c from t2 ;
+show create table t1;
+drop table t1;
+
+--warning 1364
+create table t1 ( 
+  a varchar(12) charset utf8 collate utf8_bin not null, 
+  b int null, primary key (a)
+) select a, 1 as c from t2 ;
+show create table t1;
+drop table t1;
+
+--warning 1364
+create table t1 ( 
   a varchar(12) charset utf8 collate utf8_bin not null,
   b int not null, primary key (a)
 ) select 'a' as a , 1 as b from t2 ;
diff --git a/mysql-test/t/disabled.def b/mysql-test/t/disabled.def
index 0e7eabbed6d..a209088f202 100644
--- a/mysql-test/t/disabled.def
+++ b/mysql-test/t/disabled.def
@@ -11,6 +11,5 @@
 ##############################################################################
 
 sp-goto         : GOTO is currently is disabled - will be fixed in the future
-kill            : Unstable test case, bug#9712
 subselect       : Bug#15706
 type_time       : Bug#15805
diff --git a/mysql-test/t/handler.test b/mysql-test/t/handler.test
index f3e14c3cd2b..3fb09df5f2f 100644
--- a/mysql-test/t/handler.test
+++ b/mysql-test/t/handler.test
@@ -3,7 +3,7 @@
 #
 
 --disable_warnings
-drop table if exists t1;
+drop table if exists t1,t3,t4,t5;
 --enable_warnings
 
 create table t1 (a int, b char(10), key a(a), key b(a,b));
diff --git a/mysql-test/t/kill.test b/mysql-test/t/kill.test
index 7f3a9932d31..c50c35825fc 100644
--- a/mysql-test/t/kill.test
+++ b/mysql-test/t/kill.test
@@ -25,11 +25,18 @@ select ((@id := kill_id) - kill_id) from t1;
 kill @id;
 
 connection con1;
---sleep 1
+--sleep 2
 
-# this statement should fail
---error 2006,2013
+--disable_query_log
+--disable_result_log
+# One of the following statements should fail
+--error 0,2006,2013
 select 1;
+--error 0,2006,2013
+select 1;
+--enable_query_log
+--enable_result_log
+
 --enable_reconnect
 # this should work, and we should have a new connection_id()
 select ((@id := kill_id) - kill_id) from t1;
diff --git a/mysql-test/t/mysqlshow.test b/mysql-test/t/mysqlshow.test
index 1e2e97a4e07..78c4ae2b531 100644
--- a/mysql-test/t/mysqlshow.test
+++ b/mysql-test/t/mysqlshow.test
@@ -2,7 +2,7 @@
 -- source include/not_embedded.inc
 
 --disable_warnings
-DROP TABLE IF EXISTS t1,t2;
+DROP TABLE IF EXISTS t1,t2,test1,test2;
 --enable_warnings
 
 #
diff --git a/mysql-test/t/rpl_sp.test b/mysql-test/t/rpl_sp.test
index 386582f8f1b..8fa330584e2 100644
--- a/mysql-test/t/rpl_sp.test
+++ b/mysql-test/t/rpl_sp.test
@@ -87,6 +87,14 @@ grant CREATE ROUTINE, EXECUTE on mysqltest1.* to "zedjzlcsjhd"@127.0.0.1;
 grant SELECT on mysqltest1.t1 to "zedjzlcsjhd"@127.0.0.1;
 grant SELECT, INSERT on mysqltest1.t2 to "zedjzlcsjhd"@127.0.0.1;
 
+# ToDo: BUG#14931: There is a race between the last grant binlogging, and
+# the binlogging in the new connection made below, causing sporadic test
+# failures due to switched statement order in binlog. To fix this we do
+# SELECT 1 in the first connection before starting the second, ensuring
+# that binlogging is done in the expected order.
+# Please remove this SELECT 1 when BUG#14931 is fixed.
+SELECT 1;
+
 connect (con1,127.0.0.1,zedjzlcsjhd,,mysqltest1,$MASTER_MYPORT,);
 connection con1;
 
diff --git a/mysql-test/t/trigger.test b/mysql-test/t/trigger.test
index b4074897689..f2d9bb6c856 100644
--- a/mysql-test/t/trigger.test
+++ b/mysql-test/t/trigger.test
@@ -930,11 +930,8 @@ drop table t1, t2, t3;
 # operator.
 #
 create table t1 (a int);
---disable_warnings
-drop procedure if exists p2;
---enable_warnings
 DELIMITER //;
-CREATE PROCEDURE `p2`()
+CREATE PROCEDURE `p1`()
 begin
   insert into t1 values (1);
 end//
@@ -944,8 +941,8 @@ begin
   set done= not done;
 end//
 DELIMITER ;//
-CALL p2();
-drop procedure p2;
+CALL p1();
+drop procedure p1;
 drop table t1;
 
 #
diff --git a/mysql-test/t/view.test b/mysql-test/t/view.test
index 718e1a9932b..db6c12fdacb 100644
--- a/mysql-test/t/view.test
+++ b/mysql-test/t/view.test
@@ -2275,6 +2275,7 @@ drop table t1;
 #
 create table t1(f1 int, f2 int);
 insert into t1 values (null, 10), (null,2);
+select f1, sum(f2) from t1 group by f1;
 create view v1 as select * from t1;
 select f1, sum(f2) from v1 group by f1;
 drop view v1;
diff --git a/mysys/hash.c b/mysys/hash.c
index 45cf7d5ff1d..99479ef6769 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -36,9 +36,10 @@ typedef struct st_hash_info {
 
 static uint hash_mask(uint hashnr,uint buffmax,uint maxlength);
 static void movelink(HASH_LINK *array,uint pos,uint next_link,uint newlink);
-static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length);
+static int hashcmp(const HASH *hash, HASH_LINK *pos, const byte *key,
+                   uint length);
 
-static uint calc_hash(HASH *hash,const byte *key,uint length)
+static uint calc_hash(const HASH *hash, const byte *key, uint length)
 {
   ulong nr1=1, nr2=4;
   hash->charset->coll->hash_sort(hash->charset,(uchar*) key,length,&nr1,&nr2);
@@ -63,7 +64,6 @@ _hash_init(HASH *hash,CHARSET_INFO *charset,
   hash->key_offset=key_offset;
   hash->key_length=key_length;
   hash->blength=1;
-  hash->current_record= NO_RECORD;		/* For the future */
   hash->get_key=get_key;
   hash->free=free_element;
   hash->flags=flags;
@@ -135,7 +135,6 @@ void my_hash_reset(HASH *hash)
   reset_dynamic(&hash->array);
   /* Set row pointers so that the hash can be reused at once */
   hash->blength= 1;
-  hash->current_record= NO_RECORD;
   DBUG_VOID_RETURN;
 }
 
@@ -147,7 +146,8 @@ void my_hash_reset(HASH *hash)
 */
 
 static inline char*
-hash_key(HASH *hash,const byte *record,uint *length,my_bool first)
+hash_key(const HASH *hash, const byte *record, uint *length,
+         my_bool first)
 {
   if (hash->get_key)
     return (*hash->get_key)(record,length,first);
@@ -163,8 +163,8 @@ static uint hash_mask(uint hashnr,uint buffmax,uint maxlength)
   return (hashnr & ((buffmax >> 1) -1));
 }
 
-static uint hash_rec_mask(HASH *hash,HASH_LINK *pos,uint buffmax,
-			  uint maxlength)
+static uint hash_rec_mask(const HASH *hash, HASH_LINK *pos,
+                          uint buffmax, uint maxlength)
 {
   uint length;
   byte *key= (byte*) hash_key(hash,pos->data,&length,0);
@@ -186,14 +186,25 @@ unsigned int rec_hashnr(HASH *hash,const byte *record)
 }
 
 
-	/* Search after a record based on a key */
-	/* Sets info->current_ptr to found record */
+gptr hash_search(const HASH *hash, const byte *key, uint length)
+{
+  HASH_SEARCH_STATE state;
+  return hash_first(hash, key, length, &state);
+}
+
+/*
+  Search after a record based on a key
+
+  NOTE
+   Assigns the number of the found record to HASH_SEARCH_STATE state
+*/
 
-gptr hash_search(HASH *hash,const byte *key,uint length)
+gptr hash_first(const HASH *hash, const byte *key, uint length,
+                HASH_SEARCH_STATE *current_record)
 {
   HASH_LINK *pos;
   uint flag,idx;
-  DBUG_ENTER("hash_search");
+  DBUG_ENTER("hash_first");
 
   flag=1;
   if (hash->records)
@@ -206,7 +217,7 @@ gptr hash_search(HASH *hash,const byte *key,uint length)
       if (!hashcmp(hash,pos,key,length))
       {
 	DBUG_PRINT("exit",("found key at %d",idx));
-	hash->current_record= idx;
+	*current_record= idx;
 	DBUG_RETURN (pos->data);
       }
       if (flag)
@@ -218,31 +229,32 @@ gptr hash_search(HASH *hash,const byte *key,uint length)
     }
     while ((idx=pos->next) != NO_RECORD);
   }
-  hash->current_record= NO_RECORD;
+  *current_record= NO_RECORD;
   DBUG_RETURN(0);
 }
 
 	/* Get next record with identical key */
 	/* Can only be called if previous calls was hash_search */
 
-gptr hash_next(HASH *hash,const byte *key,uint length)
+gptr hash_next(const HASH *hash, const byte *key, uint length,
+               HASH_SEARCH_STATE *current_record)
 {
   HASH_LINK *pos;
   uint idx;
 
-  if (hash->current_record != NO_RECORD)
+  if (*current_record != NO_RECORD)
   {
     HASH_LINK *data=dynamic_element(&hash->array,0,HASH_LINK*);
-    for (idx=data[hash->current_record].next; idx != NO_RECORD ; idx=pos->next)
+    for (idx=data[*current_record].next; idx != NO_RECORD ; idx=pos->next)
     {
       pos=data+idx;
       if (!hashcmp(hash,pos,key,length))
       {
-	hash->current_record= idx;
+	*current_record= idx;
 	return pos->data;
       }
     }
-    hash->current_record=NO_RECORD;
+    *current_record= NO_RECORD;
   }
   return 0;
 }
@@ -281,7 +293,8 @@ static void movelink(HASH_LINK *array,uint find,uint next_link,uint newlink)
     != 0 key of record != key
  */
 
-static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length)
+static int hashcmp(const HASH *hash, HASH_LINK *pos, const byte *key,
+                   uint length)
 {
   uint rec_keylength;
   byte *rec_key= (byte*) hash_key(hash,pos->data,&rec_keylength,1);
@@ -307,7 +320,6 @@ my_bool my_hash_insert(HASH *info,const byte *record)
   if (!(empty=(HASH_LINK*) alloc_dynamic(&info->array)))
     return(TRUE);				/* No more memory */
 
-  info->current_record= NO_RECORD;
   data=dynamic_element(&info->array,0,HASH_LINK*);
   halfbuff= info->blength >> 1;
 
@@ -450,7 +462,6 @@ my_bool hash_delete(HASH *hash,byte *record)
   }
 
   if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
-  hash->current_record= NO_RECORD;
   lastpos=data+hash->records;
 
   /* Remove link to record */
@@ -543,7 +554,6 @@ my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length)
     if ((idx=pos->next) == NO_RECORD)
       DBUG_RETURN(1);			/* Not found in links */
   }
-  hash->current_record= NO_RECORD;
   org_link= *pos;
   empty=idx;
 
@@ -593,10 +603,10 @@ byte *hash_element(HASH *hash,uint idx)
   isn't changed
 */
 
-void hash_replace(HASH *hash, uint idx, byte *new_row)
+void hash_replace(HASH *hash, HASH_SEARCH_STATE *current_record, byte *new_row)
 {
-  if (idx != NO_RECORD)				/* Safety */
-    dynamic_element(&hash->array,idx,HASH_LINK*)->data=new_row;
+  if (*current_record != NO_RECORD)            /* Safety */
+    dynamic_element(&hash->array, *current_record, HASH_LINK*)->data= new_row;
 }
 
 
diff --git a/mysys/testhash.c b/mysys/testhash.c
index 72badffdbcd..d15016113cd 100644
--- a/mysys/testhash.c
+++ b/mysys/testhash.c
@@ -74,7 +74,7 @@ static int do_test()
   bzero((char*) key1,sizeof(key1[0])*1000);
 
   printf("- Creating hash\n");
-  if (hash_init(&hash,recant/2,0,6,0,free_record,0))
+  if (hash_init(&hash, default_charset_info, recant/2, 0, 6, 0, free_record, 0))
     goto err;
   printf("- Writing records:\n");
 
@@ -172,15 +172,16 @@ static int do_test()
       break;
   if (key1[j] > 1)
   {
+    HASH_SEARCH_STATE state;
     printf("- Testing identical read\n");
     sprintf(key,"%6d",j);
     pos=1;
-    if (!(recpos=hash_search(&hash,key,0)))
+    if (!(recpos= hash_first(&hash, key, 0, &state)))
     {
       printf("can't find key1: \"%s\"\n",key);
       goto err;
     }
-    while (hash_next(&hash,key,0) && pos < (ulong) (key1[j]+10))
+    while (hash_next(&hash, key, 0, &state) && pos < (ulong) (key1[j]+10))
       pos++;
     if (pos != (ulong) key1[j])
     {
@@ -189,7 +190,7 @@ static int do_test()
     }
   }
   printf("- Creating output heap-file 2\n");
-  if (hash_init(&hash2,hash.records,0,0,hash2_key,free_record,0))
+  if (hash_init(&hash2, default_charset_info, hash.records, 0, 0, hash2_key, free_record,0))
     goto err;
 
   printf("- Copying and removing records\n");
diff --git a/sql-bench/bench-init.pl.sh b/sql-bench/bench-init.pl.sh
index d61551ffb3b..31282d06abf 100644
--- a/sql-bench/bench-init.pl.sh
+++ b/sql-bench/bench-init.pl.sh
@@ -447,7 +447,7 @@ All benchmarks takes the following options:
 --create-options=#
   Extra argument to all create statements.  If you for example want to
   create all MySQL tables as BDB tables use:
-  --create-options=TYPE=BDB
+  --create-options=ENGINE=BDB
 
 --database (Default $opt_database)
   In which database the test tables are created.
diff --git a/sql-bench/server-cfg.sh b/sql-bench/server-cfg.sh
index b0c40102a6b..75528b24b77 100644
--- a/sql-bench/server-cfg.sh
+++ b/sql-bench/server-cfg.sh
@@ -174,29 +174,29 @@ sub new
 
   # Some fixes that depends on the environment
   if (defined($main::opt_create_options) &&
-      $main::opt_create_options =~ /type=heap/i)
+      $main::opt_create_options =~ /engine=heap/i)
   {
     $limits{'working_blobs'}	= 0; # HEAP tables can't handle BLOB's
   }
   if (defined($main::opt_create_options) &&
-      $main::opt_create_options =~ /type=innodb/i)
+      $main::opt_create_options =~ /engine=innodb/i)
   {
     $self->{'transactions'}	= 1;	# Transactions enabled
   }
   if (defined($main::opt_create_options) &&
-      $main::opt_create_options =~ /type=ndb/i)
+      $main::opt_create_options =~ /engine=ndb/i)
   {
     $self->{'transactions'}	= 1;	# Transactions enabled
     $limits{'max_columns'}	= 90;	# Max number of columns in table
     $limits{'max_tables'}	= 32;   # No comments
   }
   if (defined($main::opt_create_options) &&
-      $main::opt_create_options =~ /type=bdb/i)
+      $main::opt_create_options =~ /engine=bdb/i)
   {
     $self->{'transactions'}	= 1;	# Transactions enabled
   }
   if (defined($main::opt_create_options) &&
-      $main::opt_create_options =~ /type=gemini/i)
+      $main::opt_create_options =~ /engine=gemini/i)
   {
     $limits{'working_blobs'}	= 0; # Blobs not implemented yet
     $limits{'max_tables'}	= 500;
diff --git a/sql/field.cc b/sql/field.cc
index da2ed7429ef..808cf317437 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -6209,8 +6209,8 @@ Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table)
     This is done to ensure that ALTER TABLE will convert old VARCHAR fields
     to now VARCHAR fields.
   */
-  if (new_field= new Field_varstring(field_length, maybe_null(),
-                                     field_name, new_table, charset()))
+  if ((new_field= new Field_varstring(field_length, maybe_null(),
+                                      field_name, new_table, charset())))
   {
     /*
       delayed_insert::get_local_table() needs a ptr copied from old table.
diff --git a/sql/ha_federated.cc b/sql/ha_federated.cc
index d2f827989f5..14b79a9a418 100644
--- a/sql/ha_federated.cc
+++ b/sql/ha_federated.cc
@@ -2616,8 +2616,7 @@ int ha_federated::stash_remote_error()
 {
   DBUG_ENTER("ha_federated::stash_remote_error()");
   remote_error_number= mysql_errno(mysql);
-  my_snprintf(remote_error_buf, sizeof(remote_error_buf), "%s",
-              mysql_error(mysql));
+  strmake(remote_error_buf, mysql_error(mysql), sizeof(remote_error_buf)-1);
   DBUG_RETURN(HA_FEDERATED_ERROR_WITH_REMOTE_SYSTEM);
 }
 
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index 0552eded9b6..5d10a758f86 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -300,7 +300,8 @@ Thd_ndb::~Thd_ndb()
   if (ndb)
   {
 #ifndef DBUG_OFF
-    Ndb::Free_list_usage tmp; tmp.m_name= 0;
+    Ndb::Free_list_usage tmp;
+    tmp.m_name= 0;
     while (ndb->get_free_list_usage(&tmp))
     {
       uint leaked= (uint) tmp.m_created - tmp.m_free;
@@ -312,8 +313,8 @@ Thd_ndb::~Thd_ndb()
     }
 #endif
     delete ndb;
+    ndb= NULL;
   }
-  ndb= NULL;
   changed_tables.empty();
 }
 
@@ -4903,7 +4904,8 @@ bool ndbcluster_end()
   if (g_ndb)
   {
 #ifndef DBUG_OFF
-    Ndb::Free_list_usage tmp; tmp.m_name= 0;
+    Ndb::Free_list_usage tmp;
+    tmp.m_name= 0;
     while (g_ndb->get_free_list_usage(&tmp))
     {
       uint leaked= (uint) tmp.m_created - tmp.m_free;
@@ -4915,10 +4917,9 @@ bool ndbcluster_end()
     }
 #endif
     delete g_ndb;
+    g_ndb= NULL;
   }
-  g_ndb= NULL;
-  if (g_ndb_cluster_connection)
-    delete g_ndb_cluster_connection;
+  delete g_ndb_cluster_connection;
   g_ndb_cluster_connection= NULL;
 
   hash_free(&ndbcluster_open_tables);
@@ -7463,7 +7464,8 @@ ndbcluster_show_status(THD* thd)
   if (have_ndbcluster != SHOW_OPTION_YES) 
   {
     my_message(ER_NOT_SUPPORTED_YET,
-	       "Cannot call SHOW NDBCLUSTER STATUS because skip-ndbcluster is defined",
+	       "Cannot call SHOW NDBCLUSTER STATUS because skip-ndbcluster is "
+               "defined",
 	       MYF(0));
     DBUG_RETURN(TRUE);
   }
@@ -7474,13 +7476,15 @@ ndbcluster_show_status(THD* thd)
   field_list.push_back(new Item_return_int("free", 10,MYSQL_TYPE_LONG));
   field_list.push_back(new Item_return_int("sizeof", 10,MYSQL_TYPE_LONG));
 
-  if (protocol->send_fields(&field_list, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
+  if (protocol->send_fields(&field_list,
+                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
     DBUG_RETURN(TRUE);
   
   if (get_thd_ndb(thd) && get_thd_ndb(thd)->ndb)
   {
     Ndb* ndb= (get_thd_ndb(thd))->ndb;
-    Ndb::Free_list_usage tmp; tmp.m_name= 0;
+    Ndb::Free_list_usage tmp;
+    tmp.m_name= 0;
     while (ndb->get_free_list_usage(&tmp))
     {
       protocol->prepare_for_resend();
diff --git a/sql/handler.cc b/sql/handler.cc
index 4c60f460a23..4b4c446f09b 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -300,39 +300,56 @@ handler *get_new_handler(TABLE *table, MEM_ROOT *alloc, enum db_type db_type)
   case DB_TYPE_HASH:
     return new (alloc) ha_hash(table);
 #endif
+  case DB_TYPE_MRG_MYISAM:
   case DB_TYPE_MRG_ISAM:
     return new (alloc) ha_myisammrg(table);
 #ifdef HAVE_BERKELEY_DB
   case DB_TYPE_BERKELEY_DB:
-    return new (alloc) ha_berkeley(table);
+    if (have_berkeley_db == SHOW_OPTION_YES)
+      return new (alloc) ha_berkeley(table);
+    return NULL;
 #endif
 #ifdef HAVE_INNOBASE_DB
   case DB_TYPE_INNODB:
-    return new (alloc) ha_innobase(table);
+    if (have_innodb == SHOW_OPTION_YES)
+      return new (alloc) ha_innobase(table);
+    return NULL;
 #endif
 #ifdef HAVE_EXAMPLE_DB
   case DB_TYPE_EXAMPLE_DB:
-    return new (alloc) ha_example(table);
+    if (have_example_db == SHOW_OPTION_YES)
+      return new (alloc) ha_example(table);
+    return NULL;
 #endif
 #if defined(HAVE_ARCHIVE_DB)
   case DB_TYPE_ARCHIVE_DB:
-    return new (alloc) ha_archive(table);
+    if (have_archive_db == SHOW_OPTION_YES)
+      return new (alloc) ha_archive(table);
+    return NULL;
 #endif
 #ifdef HAVE_BLACKHOLE_DB
   case DB_TYPE_BLACKHOLE_DB:
-    return new (alloc) ha_blackhole(table);
+    if (have_blackhole_db == SHOW_OPTION_YES)
+      return new (alloc) ha_blackhole(table);
+    return NULL;
 #endif
 #ifdef HAVE_FEDERATED_DB
   case DB_TYPE_FEDERATED_DB:
-    return new (alloc) ha_federated(table);
+    if (have_federated_db == SHOW_OPTION_YES)
+      return new (alloc) ha_federated(table);
+    return NULL;
 #endif
 #ifdef HAVE_CSV_DB
   case DB_TYPE_CSV_DB:
-    return new (alloc) ha_tina(table);
+    if (have_csv_db == SHOW_OPTION_YES)
+      return new (alloc) ha_tina(table);
+    return NULL;
 #endif
 #ifdef HAVE_NDBCLUSTER_DB
   case DB_TYPE_NDBCLUSTER:
-    return new (alloc) ha_ndbcluster(table);
+    if (have_ndbcluster == SHOW_OPTION_YES)
+      return new (alloc) ha_ndbcluster(table);
+    return NULL;
 #endif
   case DB_TYPE_HEAP:
     return new (alloc) ha_heap(table);
@@ -346,8 +363,6 @@ handler *get_new_handler(TABLE *table, MEM_ROOT *alloc, enum db_type db_type)
   /* Fall back to MyISAM */
   case DB_TYPE_MYISAM:
     return new (alloc) ha_myisam(table);
-  case DB_TYPE_MRG_MYISAM:
-    return new (alloc) ha_myisammrg(table);
   }
 }
 
diff --git a/sql/item.cc b/sql/item.cc
index 595e88b1086..45a23322ef2 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -4890,6 +4890,12 @@ int Item_ref::save_in_field(Field *to, bool no_conversions)
 }
 
 
+void Item_ref::save_org_in_field(Field *field)
+{
+  (*ref)->save_org_in_field(field);
+}
+
+
 void Item_ref::make_field(Send_field *field)
 {
   (*ref)->make_field(field);
diff --git a/sql/item.h b/sql/item.h
index 4b49ff907d3..eee9bc5b284 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -1745,11 +1745,7 @@ public:
   void make_field(Send_field *field);
   bool fix_fields(THD *, Item **);
   int save_in_field(Field *field, bool no_conversions);
-  void save_org_in_field(Field *field)
-  {
-    (*ref)->save_org_in_field(field);
-    null_value= (*ref)->null_value;
-  }
+  void save_org_in_field(Field *field);
   enum Item_result result_type () const { return (*ref)->result_type(); }
   enum_field_types field_type() const   { return (*ref)->field_type(); }
   Field *get_tmp_table_field()
diff --git a/sql/lock.cc b/sql/lock.cc
index 947fa4ea53f..d0bfcfd7272 100644
--- a/sql/lock.cc
+++ b/sql/lock.cc
@@ -723,6 +723,7 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list)
   char  key[MAX_DBKEY_LENGTH];
   char *db= table_list->db;
   uint  key_length;
+  HASH_SEARCH_STATE state;
   DBUG_ENTER("lock_table_name");
   DBUG_PRINT("enter",("db: %s  name: %s", db, table_list->table_name));
 
@@ -733,9 +734,9 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list)
 
 
   /* Only insert the table if we haven't insert it already */
-  for (table=(TABLE*) hash_search(&open_cache,(byte*) key,key_length) ;
+  for (table=(TABLE*) hash_first(&open_cache, (byte*)key, key_length, &state);
        table ;
-       table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
+       table = (TABLE*) hash_next(&open_cache, (byte*)key, key_length, &state))
     if (table->in_use == thd)
       DBUG_RETURN(0);
 
diff --git a/sql/log_event.cc b/sql/log_event.cc
index e977016ea21..a07411971ce 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -114,13 +114,24 @@ static char *pretty_print_str(char *packet, char *str, int len)
 
 
 /*
-  slave_load_file_stem()
+  Creates a temporary name for load data infile:
+
+  SYNOPSIS
+    slave_load_file_stem()
+    buf		      Store new filename here
+    file_id	      File_id (part of file name)
+    event_server_id   Event_id (part of file name)
+    ext		      Extension for file name
+
+  RETURN
+    Pointer to start of extension
 */
 
 #if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
-static inline char* slave_load_file_stem(char*buf, uint file_id,
-					 int event_server_id)
+static char *slave_load_file_stem(char *buf, uint file_id,
+                                  int event_server_id, const char *ext)
 {
+  char *res;
   fn_format(buf,"SQL_LOAD-",slave_load_tmpdir, "", MY_UNPACK_FILENAME);
   to_unix_path(buf);
 
@@ -129,7 +140,9 @@ static inline char* slave_load_file_stem(char*buf, uint file_id,
   *buf++ = '-';
   buf = int10_to_str(event_server_id, buf, 10);
   *buf++ = '-';
-  return int10_to_str(file_id, buf, 10);
+  res= int10_to_str(file_id, buf, 10);
+  strmov(res, ext);                             // Add extension last
+  return res;                                   // Pointer to extension
 }
 #endif
 
@@ -901,7 +914,6 @@ void Log_event::print_header(FILE* file, PRINT_EVENT_INFO* print_event_info)
     /* Pretty-print event common header if header is exactly 19 bytes */
     if (print_event_info->common_header_len == LOG_EVENT_MINIMAL_HEADER_LEN)
     {
-      DBUG_ASSERT(hexdump_from == (unsigned long) hexdump_from);
       fprintf(file, "# Position  Timestamp   Type   Master ID        "
 	      "Size      Master Pos    Flags \n");
       fprintf(file, "# %8.8lx %02x %02x %02x %02x   %02x   "
@@ -927,7 +939,6 @@ void Log_event::print_header(FILE* file, PRINT_EVENT_INFO* print_event_info)
 
       if (i % 16 == 15)
       {
-        DBUG_ASSERT(hexdump_from == (unsigned long) hexdump_from);
 	fprintf(file, "# %8.8lx %-48.48s |%16s|\n",
 		(unsigned long) (hexdump_from + (i & 0xfffffff0)),
                 hex_string, char_string);
@@ -941,12 +952,10 @@ void Log_event::print_header(FILE* file, PRINT_EVENT_INFO* print_event_info)
     *c= '\0';
 
     /* Non-full last line */
-    if (hex_string[0]) {
-      DBUG_ASSERT(hexdump_from == (unsigned long) hexdump_from);
+    if (hex_string[0])
       fprintf(file, "# %8.8lx %-48.48s |%s|\n# ",
 	     (unsigned long) (hexdump_from + (i & 0xfffffff0)),
              hex_string, char_string);
-    }
   }
 }
 
@@ -4164,16 +4173,15 @@ void Create_file_log_event::pack_info(Protocol *protocol)
 #if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
 int Create_file_log_event::exec_event(struct st_relay_log_info* rli)
 {
-  char proc_info[17+FN_REFLEN+10], *fname_buf= proc_info+17;
-  char *p;
+  char proc_info[17+FN_REFLEN+10], *fname_buf;
+  char *ext;
   int fd = -1;
   IO_CACHE file;
   int error = 1;
 
   bzero((char*)&file, sizeof(file));
-  p = slave_load_file_stem(fname_buf, file_id, server_id);
-  strmov(p, ".info");			// strmov takes less code than memcpy
-  strnmov(proc_info, STRING_WITH_LEN("Making temp file ")); // no end 0
+  fname_buf= strmov(proc_info, "Making temp file ");
+  ext= slave_load_file_stem(fname_buf, file_id, server_id, ".info");
   thd->proc_info= proc_info;
   my_delete(fname_buf, MYF(0)); // old copy may exist already
   if ((fd= my_create(fname_buf, CREATE_MODE,
@@ -4182,19 +4190,21 @@ int Create_file_log_event::exec_event(struct st_relay_log_info* rli)
       init_io_cache(&file, fd, IO_SIZE, WRITE_CACHE, (my_off_t)0, 0,
 		    MYF(MY_WME|MY_NABP)))
   {
-    slave_print_error(rli,my_errno, "Error in Create_file event: could not open file '%s'", fname_buf);
+    slave_print_error(rli,my_errno,
+                      "Error in Create_file event: could not open file '%s'",
+                      fname_buf);
     goto err;
   }
   
   // a trick to avoid allocating another buffer
-  strmov(p, ".data");
-  fname = fname_buf;
-  fname_len = (uint)(p-fname) + 5;
+  fname= fname_buf;
+  fname_len= (uint) (strmov(ext, ".data") - fname);
   if (write_base(&file))
   {
-    strmov(p, ".info"); // to have it right in the error message
+    strmov(ext, ".info"); // to have it right in the error message
     slave_print_error(rli,my_errno,
-		      "Error in Create_file event: could not write to file '%s'",
+		      "Error in Create_file event: could not write to file "
+                      "'%s'",
 		      fname_buf);
     goto err;
   }
@@ -4207,12 +4217,16 @@ int Create_file_log_event::exec_event(struct st_relay_log_info* rli)
 		     O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
 		     MYF(MY_WME))) < 0)
   {
-    slave_print_error(rli,my_errno, "Error in Create_file event: could not open file '%s'", fname_buf);
+    slave_print_error(rli,my_errno,
+                      "Error in Create_file event: could not open file '%s'",
+                      fname_buf);
     goto err;
   }
   if (my_write(fd, (byte*) block, block_len, MYF(MY_WME+MY_NABP)))
   {
-    slave_print_error(rli,my_errno, "Error in Create_file event: write to '%s' failed", fname_buf);
+    slave_print_error(rli,my_errno,
+                      "Error in Create_file event: write to '%s' failed",
+                      fname_buf);
     goto err;
   }
   error=0;					// Everything is ok
@@ -4336,13 +4350,12 @@ int Append_block_log_event::get_create_or_append() const
 int Append_block_log_event::exec_event(struct st_relay_log_info* rli)
 {
   char proc_info[17+FN_REFLEN+10], *fname= proc_info+17;
-  char *p= slave_load_file_stem(fname, file_id, server_id);
   int fd;
   int error = 1;
   DBUG_ENTER("Append_block_log_event::exec_event");
 
-  memcpy(p, ".data", 6);
-  strnmov(proc_info, STRING_WITH_LEN("Making temp file ")); // no end 0
+  fname= strmov(proc_info, "Making temp file ");
+  slave_load_file_stem(fname, file_id, server_id, ".data");
   thd->proc_info= proc_info;
   if (get_create_or_append())
   {
@@ -4468,10 +4481,9 @@ void Delete_file_log_event::pack_info(Protocol *protocol)
 int Delete_file_log_event::exec_event(struct st_relay_log_info* rli)
 {
   char fname[FN_REFLEN+10];
-  char *p= slave_load_file_stem(fname, file_id, server_id);
-  memcpy(p, ".data", 6);
+  char *ext= slave_load_file_stem(fname, file_id, server_id, ".data");
   (void) my_delete(fname, MYF(MY_WME));
-  memcpy(p, ".info", 6);
+  strmov(ext, ".info");
   (void) my_delete(fname, MYF(MY_WME));
   return Log_event::exec_event(rli);
 }
@@ -4564,19 +4576,21 @@ void Execute_load_log_event::pack_info(Protocol *protocol)
 int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
 {
   char fname[FN_REFLEN+10];
-  char *p= slave_load_file_stem(fname, file_id, server_id);
+  char *ext;
   int fd;
-  int error = 1;
+  int error= 1;
   IO_CACHE file;
-  Load_log_event* lev = 0;
+  Load_log_event *lev= 0;
 
-  memcpy(p, ".info", 6);
+  ext= slave_load_file_stem(fname, file_id, server_id, ".info");
   if ((fd = my_open(fname, O_RDONLY | O_BINARY | O_NOFOLLOW,
                     MYF(MY_WME))) < 0 ||
       init_io_cache(&file, fd, IO_SIZE, READ_CACHE, (my_off_t)0, 0,
 		    MYF(MY_WME|MY_NABP)))
   {
-    slave_print_error(rli,my_errno, "Error in Exec_load event: could not open file '%s'", fname);
+    slave_print_error(rli,my_errno,
+                      "Error in Exec_load event: could not open file '%s'",
+                      fname);
     goto err;
   }
   if (!(lev = (Load_log_event*)Log_event::read_log_event(&file,
@@ -4584,7 +4598,9 @@ int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
                                                          rli->relay_log.description_event_for_exec)) ||
       lev->get_type_code() != NEW_LOAD_EVENT)
   {
-    slave_print_error(rli,0, "Error in Exec_load event: file '%s' appears corrupted", fname);
+    slave_print_error(rli,0,
+                      "Error in Exec_load event: file '%s' appears corrupted",
+                      fname);
     goto err;
   }
 
@@ -4629,7 +4645,7 @@ int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
     fd= -1;
   }
   (void) my_delete(fname, MYF(MY_WME));
-  memcpy(p, ".data", 6);
+  memcpy(ext, ".data", 6);
   (void) my_delete(fname, MYF(MY_WME));
   error = 0;
 
@@ -4827,11 +4843,10 @@ Execute_load_query_log_event::exec_event(struct st_relay_log_info* rli)
   memcpy(p, query, fn_pos_start);
   p+= fn_pos_start;
   fname= (p= strmake(p, STRING_WITH_LEN(" INFILE \'")));
-  p= slave_load_file_stem(p, file_id, server_id);
-  fname_end= (p= strmake(p, STRING_WITH_LEN(".data")));
+  p= slave_load_file_stem(p, file_id, server_id, ".data");
+  fname_end= p= strend(p);                      // Safer than p=p+5
   *(p++)='\'';
-  switch (dup_handling)
-  {
+  switch (dup_handling) {
   case LOAD_DUP_IGNORE:
     p= strmake(p, STRING_WITH_LEN(" IGNORE"));
     break;
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 14cbaf28ae3..1f32a8285d1 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -1401,7 +1401,7 @@ static void network_init(void)
     {
       if (((ret= bind(ip_sock, my_reinterpret_cast(struct sockaddr *) (&IPaddr),
                       sizeof(IPaddr))) >= 0) ||
-          (socket_errno != EADDRINUSE) ||
+          (socket_errno != SOCKET_EADDRINUSE) ||
           (waited >= mysqld_port_timeout))
         break;
       sql_print_information("Retrying bind on TCP/IP port %u", mysqld_port);
@@ -1613,7 +1613,7 @@ void end_thread(THD *thd, bool put_in_cache)
       wake_thread--;
       thd=thread_cache.get();
       thd->real_id=pthread_self();
-      thd->thread_stack= (char *) &thd;
+      thd->thread_stack= (char*) &thd;          // For store_globals
       (void) thd->store_globals();
       thd->thr_create_time= time(NULL);
       threads.append(thd);
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 515e9723f1d..7c4f5fbe218 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -5737,6 +5737,7 @@ bool QUICK_ROR_UNION_SELECT::check_if_keys_used(List<Item> *fields)
 
 /*
   Create quick select from ref/ref_or_null scan.
+
   SYNOPSIS
     get_quick_select_for_ref()
       thd      Thread handle
@@ -5756,15 +5757,18 @@ bool QUICK_ROR_UNION_SELECT::check_if_keys_used(List<Item> *fields)
 QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table,
                                              TABLE_REF *ref, ha_rows records)
 {
-  MEM_ROOT *old_root= thd->mem_root;
-  /* The following call may change thd->mem_root */
-  QUICK_RANGE_SELECT *quick= new QUICK_RANGE_SELECT(thd, table, ref->key, 0);
-  /* save mem_root set by QUICK_RANGE_SELECT constructor */
-  MEM_ROOT *alloc= thd->mem_root;
+  MEM_ROOT *old_root, *alloc;
+  QUICK_RANGE_SELECT *quick;
   KEY *key_info = &table->key_info[ref->key];
   KEY_PART *key_part;
   QUICK_RANGE *range;
   uint part;
+
+  old_root= thd->mem_root;
+  /* The following call may change thd->mem_root */
+  quick= new QUICK_RANGE_SELECT(thd, table, ref->key, 0);
+  /* save mem_root set by QUICK_RANGE_SELECT constructor */
+  alloc= thd->mem_root;
   /*
     return back default mem_root (thd->mem_root) changed by
     QUICK_RANGE_SELECT constructor
diff --git a/sql/parse_file.cc b/sql/parse_file.cc
index 69757e0be06..041b770ac0b 100644
--- a/sql/parse_file.cc
+++ b/sql/parse_file.cc
@@ -944,6 +944,6 @@ File_parser_dummy_hook::process_unknown_string(char *&unknown_key,
                                                char *end)
 {
   DBUG_ENTER("file_parser_dummy_hook::process_unknown_string");
-  DBUG_PRINT("info", ("unknown key:%60s", unknown_key));
+  DBUG_PRINT("info", ("Unknown key: '%60s'", unknown_key));
   DBUG_RETURN(FALSE);
 }
diff --git a/sql/sp.cc b/sql/sp.cc
index d5b93f0d2f2..a9b1a462d5f 100644
--- a/sql/sp.cc
+++ b/sql/sp.cc
@@ -399,14 +399,14 @@ db_load_routine(THD *thd, int type, sp_name *name, sp_head **sphp,
                 const char *body, st_sp_chistics &chistics,
                 const char *definer, longlong created, longlong modified)
 {
-  LEX *oldlex= thd->lex, newlex;
-  sp_rcontext *save_spcont= thd->spcont;
+  LEX *old_lex= thd->lex, newlex;
   String defstr;
   char olddb[128];
   bool dbchanged;
   ulong old_sql_mode= thd->variables.sql_mode;
-  ha_rows select_limit= thd->variables.select_limit;
-  int ret= SP_INTERNAL_ERROR;
+  ha_rows old_select_limit= thd->variables.select_limit;
+  sp_rcontext *old_spcont= thd->spcont;
+  int ret;
 
   thd->variables.sql_mode= sql_mode;
   thd->variables.select_limit= HA_POS_ERROR;
@@ -422,7 +422,10 @@ db_load_routine(THD *thd, int type, sp_name *name, sp_head **sphp,
 		     returns, strlen(returns),
 		     body, strlen(body),
 		     &chistics))
+  {
+    ret= SP_INTERNAL_ERROR;
     goto end;
+  }
 
   dbchanged= FALSE;
   if ((ret= sp_use_new_db(thd, name->m_db.str, olddb, sizeof(olddb),
@@ -451,10 +454,10 @@ db_load_routine(THD *thd, int type, sp_name *name, sp_head **sphp,
     (*sphp)->optimize();
   }
 end:
-  thd->spcont= save_spcont;
+  thd->spcont= old_spcont;
   thd->variables.sql_mode= old_sql_mode;
-  thd->variables.select_limit= select_limit;
-  thd->lex= oldlex;
+  thd->variables.select_limit= old_select_limit;
+  thd->lex= old_lex;
   return ret;
 }
 
@@ -926,7 +929,6 @@ sp_find_routine(THD *thd, int type, sp_name *name, sp_cache **cp,
   ulong depth= (type == TYPE_ENUM_PROCEDURE ?
                 thd->variables.max_sp_recursion_depth :
                 0);
-
   DBUG_ENTER("sp_find_routine");
   DBUG_PRINT("enter", ("name:  %.*s.%.*s, type: %d, cache only %d",
                        name->m_db.length, name->m_db.str,
@@ -936,6 +938,11 @@ sp_find_routine(THD *thd, int type, sp_name *name, sp_cache **cp,
   if ((sp= sp_cache_lookup(cp, name)))
   {
     ulong level;
+    sp_head *new_sp;
+    const char *returns= "";
+    char definer[HOSTNAME_LENGTH+USERNAME_LENGTH+2];
+    String retstr(64);
+
     DBUG_PRINT("info", ("found: 0x%lx", (ulong)sp));
     if (sp->m_first_free_instance)
     {
@@ -946,7 +953,7 @@ sp_find_routine(THD *thd, int type, sp_name *name, sp_cache **cp,
       DBUG_ASSERT(!(sp->m_first_free_instance->m_flags & sp_head::IS_INVOKED));
       if (sp->m_first_free_instance->m_recursion_level > depth)
       {
-        sp->recursion_level_error();
+        sp->recursion_level_error(thd);
         DBUG_RETURN(0);
       }
       DBUG_RETURN(sp->m_first_free_instance);
@@ -954,37 +961,32 @@ sp_find_routine(THD *thd, int type, sp_name *name, sp_cache **cp,
     level= sp->m_last_cached_sp->m_recursion_level + 1;
     if (level > depth)
     {
-      sp->recursion_level_error();
+      sp->recursion_level_error(thd);
       DBUG_RETURN(0);
     }
+
+    strxmov(definer, sp->m_definer_user.str, "@",
+            sp->m_definer_host.str, NullS);
+    if (type == TYPE_ENUM_FUNCTION)
     {
-      sp_head *new_sp;
-      const char *returns= "";
-      char definer[HOSTNAME_LENGTH+USERNAME_LENGTH+2];
-      String retstr(64);
-      strxmov(definer, sp->m_definer_user.str, "@",
-                       sp->m_definer_host.str, NullS);
-      if (type == TYPE_ENUM_FUNCTION)
-      {
-        sp_returns_type(thd, retstr, sp);
-        returns= retstr.ptr();
-      }
-      if (db_load_routine(thd, type, name, &new_sp,
-                          sp->m_sql_mode, sp->m_params.str, returns,
-                          sp->m_body.str, *sp->m_chistics, definer,
-                          sp->m_created, sp->m_modified) == SP_OK)
-      {
-        sp->m_last_cached_sp->m_next_cached_sp= new_sp;
-        new_sp->m_recursion_level= level;
-        new_sp->m_first_instance= sp;
-        sp->m_last_cached_sp= sp->m_first_free_instance= new_sp;
-        DBUG_PRINT("info", ("added level: 0x%lx, level: %lu, flags %x",
+      sp_returns_type(thd, retstr, sp);
+      returns= retstr.ptr();
+    }
+    if (db_load_routine(thd, type, name, &new_sp,
+                        sp->m_sql_mode, sp->m_params.str, returns,
+                        sp->m_body.str, *sp->m_chistics, definer,
+                        sp->m_created, sp->m_modified) == SP_OK)
+    {
+      sp->m_last_cached_sp->m_next_cached_sp= new_sp;
+      new_sp->m_recursion_level= level;
+      new_sp->m_first_instance= sp;
+      sp->m_last_cached_sp= sp->m_first_free_instance= new_sp;
+      DBUG_PRINT("info", ("added level: 0x%lx, level: %lu, flags %x",
                           (ulong)new_sp, new_sp->m_recursion_level,
                           new_sp->m_flags));
-        DBUG_RETURN(new_sp);
-      }
-      DBUG_RETURN(0);
+      DBUG_RETURN(new_sp);
     }
+    DBUG_RETURN(0);
   }
   if (!cache_only)
   {
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index 88d3ed83278..12f9260e7b1 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -24,6 +24,13 @@
 #include "sp_rcontext.h"
 #include "sp_cache.h"
 
+/*
+  Sufficient max length of printed destinations and frame offsets (all uints).
+*/
+#define SP_INSTR_UINT_MAXLEN  8
+#define SP_STMT_PRINT_MAXLEN 40
+
+
 Item_result
 sp_map_result_type(enum enum_field_types type)
 {
@@ -867,17 +874,17 @@ subst_spvars(THD *thd, sp_instr *instr, LEX_STRING *query_str)
 
   SYNOPSIS
     sp_head::recursion_level_error()
+    thd		Thread handle
 
   NOTE
     For functions and triggers we return error about prohibited recursion.
     For stored procedures we return about reaching recursion limit.
 */
 
-void sp_head::recursion_level_error()
+void sp_head::recursion_level_error(THD *thd)
 {
   if (m_type == TYPE_ENUM_PROCEDURE)
   {
-    THD *thd= current_thd;
     my_error(ER_SP_RECURSION_LIMIT, MYF(0),
              thd->variables.max_sp_recursion_depth,
              m_name.str);
@@ -928,14 +935,15 @@ sp_head::execute(THD *thd)
   DBUG_ASSERT(!(m_flags & IS_INVOKED));
   m_flags|= IS_INVOKED;
   m_first_instance->m_first_free_instance= m_next_cached_sp;
-  DBUG_PRINT("info", ("first free for 0x%lx ++: 0x%lx->0x%lx, level: %lu, flags %x",
-                      (ulong)m_first_instance, this, m_next_cached_sp,
-                      (m_next_cached_sp ?
-                       m_next_cached_sp->m_recursion_level :
-                       0),
-                      (m_next_cached_sp ?
-                       m_next_cached_sp->m_flags :
-                       0)));
+  if (m_next_cached_sp)
+  {
+    DBUG_PRINT("info",
+               ("first free for 0x%lx ++: 0x%lx->0x%lx  level: %lu  flags %x",
+                (ulong)m_first_instance, (ulong) this,
+                (ulong) m_next_cached_sp,
+                m_next_cached_sp->m_recursion_level,
+                m_next_cached_sp->m_flags));
+  }
   /*
     Check that if there are not any instances after this one then
     pointer to the last instance points on this instance or if there are
@@ -1103,13 +1111,15 @@ sp_head::execute(THD *thd)
   state= EXECUTED;
 
  done:
-  DBUG_PRINT("info", ("err_status=%d killed=%d query_error=%d",
+  DBUG_PRINT("info", ("err_status: %d  killed: %d  query_error: %d",
 		      err_status, thd->killed, thd->query_error));
 
   if (thd->killed)
     err_status= TRUE;
-  /* If the DB has changed, the pointer has changed too, but the
-     original thd->db will then have been freed */
+  /*
+    If the DB has changed, the pointer has changed too, but the
+    original thd->db will then have been freed
+  */
   if (dbchanged)
   {
     /*
@@ -1120,10 +1130,11 @@ sp_head::execute(THD *thd)
       err_status|= mysql_change_db(thd, olddb, 1);
   }
   m_flags&= ~IS_INVOKED;
-  DBUG_PRINT("info", ("first free for 0x%lx --: 0x%lx->0x%lx, level: %lu, flags %x",
-                      (ulong)m_first_instance,
-                      m_first_instance->m_first_free_instance, this,
-                      m_recursion_level, m_flags));
+  DBUG_PRINT("info",
+             ("first free for 0x%lx --: 0x%lx->0x%lx, level: %lu, flags %x",
+              (ulong) m_first_instance,
+              (ulong) m_first_instance->m_first_free_instance,
+              (ulong) this, m_recursion_level, m_flags));
   /*
     Check that we have one of following:
 
@@ -1133,7 +1144,7 @@ sp_head::execute(THD *thd)
 
     2) There are some free instances which mean that first free instance
     should go just after this one and recursion level of that free instance
-    should be on 1 more then recursion leven of this instance.
+    should be on 1 more then recursion level of this instance.
   */
   DBUG_ASSERT((m_first_instance->m_first_free_instance == 0 &&
                this == m_first_instance->m_last_cached_sp &&
@@ -1741,16 +1752,16 @@ sp_head::set_info(longlong created, longlong modified,
 
 
 void
-sp_head::set_definer(char *definer, uint definerlen)
+
+sp_head::set_definer(const char *definer, uint definerlen)
 {
-  char *p= strrchr(definer, '@');
+  const char *p= strrchr(definer, '@');
 
   if (!p)
   {
-    m_definer_user.str= strmake_root(mem_root, "", 0);
+    m_definer_user.str= (char*) "";
     m_definer_user.length= 0;
-    
-    m_definer_host.str= strmake_root(mem_root, "", 0);
+    m_definer_host.str= (char*) "";
     m_definer_host.length= 0;
   }
   else
@@ -1845,9 +1856,9 @@ sp_head::show_create_procedure(THD *thd)
   byte *sql_mode_str;
   ulong sql_mode_len;
   bool full_access;
-
   DBUG_ENTER("sp_head::show_create_procedure");
   DBUG_PRINT("info", ("procedure %s", m_name.str));
+
   LINT_INIT(sql_mode_str);
   LINT_INIT(sql_mode_len);
 
@@ -2200,12 +2211,7 @@ sp_instr_stmt::execute(THD *thd, uint *nextp)
   DBUG_RETURN(res);
 }
 
-/* 
-   Sufficient max length of printed destinations and frame offsets (all uints).
-*/
-#define SP_INSTR_UINT_MAXLEN  8
 
-#define SP_STMT_PRINT_MAXLEN 40
 void
 sp_instr_stmt::print(String *str)
 {
@@ -2227,16 +2233,16 @@ sp_instr_stmt::print(String *str)
   /* Copy the query string and replace '\n' with ' ' in the process */
   for (i= 0 ; i < len ; i++)
   {
-    if (m_query.str[i] == '\n')
-      str->qs_append(' ');
-    else
-      str->qs_append(m_query.str[i]);
+    char c= m_query.str[i];
+    if (c == '\n')
+      c= ' ';
+    str->qs_append(c);
   }
   if (m_query.length > SP_STMT_PRINT_MAXLEN)
     str->qs_append(STRING_WITH_LEN("...")); /* Indicate truncated string */
   str->qs_append('"');
 }
-#undef SP_STMT_PRINT_MAXLEN
+
 
 int
 sp_instr_stmt::exec_core(THD *thd, uint *nextp)
@@ -2602,6 +2608,7 @@ sp_instr_hpush_jump::execute(THD *thd, uint *nextp)
   DBUG_RETURN(0);
 }
 
+
 void
 sp_instr_hpush_jump::print(String *str)
 {
@@ -2612,8 +2619,7 @@ sp_instr_hpush_jump::print(String *str)
   str->qs_append(m_dest);
   str->qs_append(' ');
   str->qs_append(m_frame);
-  switch (m_type)
-  {
+  switch (m_type) {
   case SP_HANDLER_NONE:
     str->qs_append(STRING_WITH_LEN(" NONE")); // This would be a bug
     break;
@@ -2627,11 +2633,13 @@ sp_instr_hpush_jump::print(String *str)
     str->qs_append(STRING_WITH_LEN(" UNDO"));
     break;
   default:
-    str->qs_append(STRING_WITH_LEN(" UNKNOWN:")); // This would be a bug as well
+    // This would be a bug as well
+    str->qs_append(STRING_WITH_LEN(" UNKNOWN:"));
     str->qs_append(m_type);
   }
 }
 
+
 uint
 sp_instr_hpush_jump::opt_mark(sp_head *sp)
 {
diff --git a/sql/sp_head.h b/sql/sp_head.h
index ad747b3466f..2eebd35f6dc 100644
--- a/sql/sp_head.h
+++ b/sql/sp_head.h
@@ -285,7 +285,7 @@ public:
   void set_info(longlong created, longlong modified,
 		st_sp_chistics *chistics, ulong sql_mode);
 
-  void set_definer(char *definer, uint definerlen);
+  void set_definer(const char *definer, uint definerlen);
 
   void reset_thd_mem_root(THD *thd);
 
@@ -294,7 +294,7 @@ public:
   void optimize();
   void opt_mark(uint ip);
 
-  void recursion_level_error();
+  void recursion_level_error(THD *thd);
 
   inline sp_instr *
   get_instr(uint i)
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index 5d03524f531..57ed943e66a 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -2244,14 +2244,14 @@ static GRANT_NAME *name_hash_search(HASH *name_hash,
   char helping [NAME_LEN*2+USERNAME_LENGTH+3];
   uint len;
   GRANT_NAME *grant_name,*found=0;
+  HASH_SEARCH_STATE state;
 
   len  = (uint) (strmov(strmov(strmov(helping,user)+1,db)+1,tname)-helping)+ 1;
-  for (grant_name=(GRANT_NAME*) hash_search(name_hash,
-					      (byte*) helping,
-					      len) ;
+  for (grant_name= (GRANT_NAME*) hash_first(name_hash, (byte*) helping,
+                                            len, &state);
        grant_name ;
        grant_name= (GRANT_NAME*) hash_next(name_hash,(byte*) helping,
-					     len))
+                                           len, &state))
   {
     if (exact)
     {
@@ -3553,7 +3553,7 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables,
     of other queries). For simple queries first_not_own_table is 0.
   */
   for (i= 0, table= tables;
-       table && table != first_not_own_table && i < number;
+       table != first_not_own_table && i < number;
        table= table->next_global, i++)
   {
     /* Remove SHOW_VIEW_ACL, because it will be checked during making view */
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index cae77756012..be3b64a5ef6 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -1085,6 +1085,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
   char	key[MAX_DBKEY_LENGTH];
   uint	key_length;
   char	*alias= table_list->alias;
+  HASH_SEARCH_STATE state;
   DBUG_ENTER("open_table");
 
   /* find a unused table in the open table cache */
@@ -1247,9 +1248,11 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
   if (thd->handler_tables)
     mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);
 
-  for (table=(TABLE*) hash_search(&open_cache,(byte*) key,key_length) ;
+  for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
+                                  &state);
        table && table->in_use ;
-       table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
+       table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
+                                 &state))
   {
     if (table->s->version != refresh_version)
     {
@@ -1621,10 +1624,12 @@ bool table_is_used(TABLE *table, bool wait_for_name_lock)
   {
     char *key= table->s->table_cache_key;
     uint key_length= table->s->key_length;
-    for (TABLE *search=(TABLE*) hash_search(&open_cache,
-					    (byte*) key,key_length) ;
+    HASH_SEARCH_STATE state;
+    for (TABLE *search= (TABLE*) hash_first(&open_cache, (byte*) key,
+                                             key_length, &state);
 	 search ;
-	 search = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
+         search= (TABLE*) hash_next(&open_cache, (byte*) key,
+                                    key_length, &state))
     {
       if (search->locked_by_flush ||
 	  search->locked_by_name && wait_for_name_lock ||
@@ -5059,15 +5064,17 @@ bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
   bool result=0, signalled= 0;
   DBUG_ENTER("remove_table_from_cache");
 
-
   key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
   for (;;)
   {
+    HASH_SEARCH_STATE state;
     result= signalled= 0;
 
-    for (table=(TABLE*) hash_search(&open_cache,(byte*) key,key_length) ;
+    for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
+                                    &state);
          table;
-         table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
+         table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
+                                   &state))
     {
       THD *in_use;
       table->s->version=0L;		/* Free when thread is ready */
diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc
index 0a01832bb39..cf3ba9c8c40 100644
--- a/sql/sql_cache.cc
+++ b/sql/sql_cache.cc
@@ -3050,6 +3050,7 @@ my_bool Query_cache::move_by_type(byte **border,
   }
   case Query_cache_block::TABLE:
   {
+    HASH_SEARCH_STATE record_idx;
     DBUG_PRINT("qcache", ("block 0x%lx TABLE", (ulong) block));
     if (*border == 0)
       break;
@@ -3067,7 +3068,7 @@ my_bool Query_cache::move_by_type(byte **border,
     byte *key;
     uint key_length;
     key=query_cache_table_get_key((byte*) block, &key_length, 0);
-    hash_search(&tables, (byte*) key, key_length);
+    hash_first(&tables, (byte*) key, key_length, &record_idx);
 
     block->destroy();
     new_block->init(len);
@@ -3101,7 +3102,7 @@ my_bool Query_cache::move_by_type(byte **border,
     /* Fix pointer to table name */
     new_block->table()->table(new_block->table()->db() + tablename_offset);
     /* Fix hash to point at moved block */
-    hash_replace(&tables, tables.current_record, (byte*) new_block);
+    hash_replace(&tables, &record_idx, (byte*) new_block);
 
     DBUG_PRINT("qcache", ("moved %lu bytes to 0x%lx, new gap at 0x%lx",
 			len, (ulong) new_block, (ulong) *border));
@@ -3109,6 +3110,7 @@ my_bool Query_cache::move_by_type(byte **border,
   }
   case Query_cache_block::QUERY:
   {
+    HASH_SEARCH_STATE record_idx;
     DBUG_PRINT("qcache", ("block 0x%lx QUERY", (ulong) block));
     if (*border == 0)
       break;
@@ -3126,7 +3128,7 @@ my_bool Query_cache::move_by_type(byte **border,
     byte *key;
     uint key_length;
     key=query_cache_query_get_key((byte*) block, &key_length, 0);
-    hash_search(&queries, (byte*) key, key_length);
+    hash_first(&queries, (byte*) key, key_length, &record_idx);
     // Move table of used tables 
     memmove((char*) new_block->table(0), (char*) block->table(0),
 	   ALIGN_SIZE(n_tables*sizeof(Query_cache_block_table)));
@@ -3194,7 +3196,7 @@ my_bool Query_cache::move_by_type(byte **border,
       net->query_cache_query= (gptr) new_block;
     }
     /* Fix hash to point at moved block */
-    hash_replace(&queries, queries.current_record, (byte*) new_block);
+    hash_replace(&queries, &record_idx, (byte*) new_block);
     DBUG_PRINT("qcache", ("moved %lu bytes to 0x%lx, new gap at 0x%lx",
 			len, (ulong) new_block, (ulong) *border));
     break;
diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc
index ef0f4243d89..fae48c7d164 100644
--- a/sql/sql_handler.cc
+++ b/sql/sql_handler.cc
@@ -227,6 +227,7 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, bool reopen)
     /* add to hash */
     if (my_hash_insert(&thd->handler_tables_hash, (byte*) hash_tables))
     {
+      my_free((char*) hash_tables, MYF(0));
       mysql_ha_close(thd, tables);
       goto err;
     }
@@ -369,26 +370,6 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables,
     DBUG_PRINT("info-in-hash",("'%s'.'%s' as '%s' tab %p",
                                hash_tables->db, hash_tables->table_name,
                                hash_tables->alias, table));
-    /* Table might have been flushed. */
-    if (table && (table->s->version != refresh_version))
-    {
-      /*
-        We must follow the thd->handler_tables chain, as we need the
-        address of the 'next' pointer referencing this table
-        for close_thread_table().
-      */
-      for (table_ptr= &(thd->handler_tables); *table_ptr != table;
-           table_ptr= &(*table_ptr)->next) /* no-op */ ;
-      (*table_ptr)->file->ha_index_or_rnd_end();
-      VOID(pthread_mutex_lock(&LOCK_open));
-      if (close_thread_table(thd, table_ptr))
-      {
-        /* Tell threads waiting for refresh that something has happened */
-        VOID(pthread_cond_broadcast(&COND_refresh));
-      }
-      VOID(pthread_mutex_unlock(&LOCK_open));
-      table= hash_tables->table= NULL;
-    }
     if (!table)
     {
       /*
@@ -433,6 +414,13 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables,
   }
   tables->table=table;
 
+  HANDLER_TABLES_HACK(thd);
+  lock= mysql_lock_tables(thd, &tables->table, 1, 0, &not_used);
+  HANDLER_TABLES_HACK(thd);
+
+  if (!lock)
+    goto err0; // mysql_lock_tables() printed error message already
+
   if (cond && ((!cond->fixed &&
                 cond->fix_fields(thd, &cond)) || cond->check_cols(1)))
     goto err0;
@@ -452,13 +440,6 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables,
 
   protocol->send_fields(&list, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);
 
-  HANDLER_TABLES_HACK(thd);
-  lock= mysql_lock_tables(thd, &tables->table, 1, 0, &not_used);
-  HANDLER_TABLES_HACK(thd);
-
-  if (!lock)
-    goto err0; // mysql_lock_tables() printed error message already
-
   /*
     In ::external_lock InnoDB resets the fields which tell it that
     the handle is used in the HANDLER interface. Tell it again that
@@ -748,7 +729,7 @@ static int mysql_ha_flush_table(THD *thd, TABLE **table_ptr, uint mode_flags)
       /* Mark table as closed, ready for re-open. */
       hash_tables->table= NULL;
     }
-  }
+  }    
 
   safe_mutex_assert_owner(&LOCK_open);
   (*table_ptr)->file->ha_index_or_rnd_end();
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index 04b48a7e059..eb74144c1ea 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -2435,7 +2435,11 @@ select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
   }
 
   /* First field to copy */
-  field=table->field+table->s->fields - values.elements;
+  field= table->field+table->s->fields - values.elements;
+
+  /* Mark all fields that are given values */
+  for (Field **f= field ; *f ; f++)
+    (*f)->query_id= thd->query_id;
 
   /* Don't set timestamp if used */
   table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 4ea2ad00421..e98aac27ca9 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -1185,6 +1185,7 @@ end_thread:
       or this thread has been schedule to handle the next query
     */
     thd= current_thd;
+    thd->thread_stack= (char*) &thd;
   } while (!(test_flags & TEST_NO_THREADS));
   /* The following is only executed if we are not using --one-thread */
   return(0);					/* purecov: deadcode */
@@ -4853,7 +4854,6 @@ end_with_restore_list:
   if (thd->one_shot_set && lex->sql_command != SQLCOM_SET_OPTION)
     reset_one_shot_variables(thd);
 
-
   /*
     The return value for ROW_COUNT() is "implementation dependent" if the
     statement is not DELETE, INSERT or UPDATE, but -1 is what JDBC and ODBC
@@ -4865,13 +4865,10 @@ end_with_restore_list:
   if (lex->sql_command != SQLCOM_CALL && lex->sql_command != SQLCOM_EXECUTE &&
       uc_update_queries[lex->sql_command]<2)
     thd->row_count_func= -1;
-  goto cleanup;
+  DBUG_RETURN(res || thd->net.report_error);
 
 error:
-  res= 1;
-
-cleanup:
-  DBUG_RETURN(res || thd->net.report_error);
+  DBUG_RETURN(1);
 }
 
 
@@ -5094,7 +5091,7 @@ check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
     the given table list refers to the list for prelocking (contains tables
     of other queries). For simple queries first_not_own_table is 0.
   */
-  for (; tables && tables != first_not_own_table; tables= tables->next_global)
+  for (; tables != first_not_own_table; tables= tables->next_global)
   {
     if (tables->schema_table && 
         (want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
@@ -7258,7 +7255,7 @@ LEX_USER *create_definer(THD *thd, LEX_STRING *user_name, LEX_STRING *host_name)
 
   /* Create and initialize. */
 
-  if (! (definer= (LEX_USER*) thd->alloc(sizeof (LEX_USER))))
+  if (! (definer= (LEX_USER*) thd->alloc(sizeof(LEX_USER))))
     return 0;
 
   definer->user= *user_name;
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 1485f88610a..ad6375290cd 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -10700,7 +10700,7 @@ end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
     item->save_org_in_field(group->field);
     /* Store in the used key if the field was 0 */
     if (item->maybe_null)
-      group->buff[-1]=item->null_value ? 1 : 0;
+      group->buff[-1]= (char) group->field->is_null();
   }
   if (!table->file->index_read(table->record[1],
 			       join->tmp_table_param.group_buff,0,
diff --git a/sql/sql_trigger.cc b/sql/sql_trigger.cc
index 8a26c2bafa2..bbc32950c2d 100644
--- a/sql/sql_trigger.cc
+++ b/sql/sql_trigger.cc
@@ -51,6 +51,13 @@ static File_option triggers_file_parameters[]=
   { { 0, 0 }, 0, FILE_OPTIONS_STRING }
 };
 
+File_option sql_modes_parameters=
+{
+  {(char*) STRING_WITH_LEN("sql_modes") },
+  offsetof(class Table_triggers_list, definition_modes_list),
+  FILE_OPTIONS_ULLLIST
+};
+
 /*
   This must be kept up to date whenever a new option is added to the list
   above, as it specifies the number of required parameters of the trigger in
@@ -436,7 +443,7 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables,
 
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
   if (!is_acl_user(lex->definer->host.str,
-      lex->definer->user.str))
+                   lex->definer->user.str))
   {
     push_warning_printf(thd,
                         MYSQL_ERROR::WARN_LEVEL_NOTE,
@@ -779,7 +786,7 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db,
                                                     sizeof(LEX_STRING))))
           DBUG_RETURN(1); // EOM
 
-        trg_definer->str= "";
+        trg_definer->str= (char*) "";
         trg_definer->length= 0;
 
         while (it++)
@@ -1171,7 +1178,7 @@ bool Table_triggers_list::process_triggers(THD *thd, trg_event_type event,
     
     if (is_special_var_used(event, time_type))
     {
-      TABLE_LIST table_list;
+      TABLE_LIST table_list, **save_query_tables_own_last;
       bzero((char *) &table_list, sizeof (table_list));
       table_list.db= (char *) table->s->db;
       table_list.db_length= strlen(table_list.db);
@@ -1179,8 +1186,13 @@ bool Table_triggers_list::process_triggers(THD *thd, trg_event_type event,
       table_list.table_name_length= strlen(table_list.table_name);
       table_list.alias= (char *) table->alias;
       table_list.table= table;
+      save_query_tables_own_last= thd->lex->query_tables_own_last;
+      thd->lex->query_tables_own_last= 0;
 
-      if (check_table_access(thd, SELECT_ACL | UPDATE_ACL, &table_list, 0))
+      err_status= check_table_access(thd, SELECT_ACL | UPDATE_ACL,
+                                     &table_list, 0);
+      thd->lex->query_tables_own_last= save_query_tables_own_last;
+      if (err_status)
       {
         sp_restore_security_context(thd, save_ctx);
         return TRUE;
@@ -1222,32 +1234,29 @@ bool Table_triggers_list::process_triggers(THD *thd, trg_event_type event,
     TRUE  Error
 */
 
+#define INVALID_SQL_MODES_LENGTH 13
+
 bool
 Handle_old_incorrect_sql_modes_hook::process_unknown_string(char *&unknown_key,
                                                             gptr base,
                                                             MEM_ROOT *mem_root,
                                                             char *end)
 {
-#define INVALID_SQL_MODES_LENGTH 13
   DBUG_ENTER("handle_old_incorrect_sql_modes");
   DBUG_PRINT("info", ("unknown key:%60s", unknown_key));
+
   if (unknown_key + INVALID_SQL_MODES_LENGTH + 1 < end &&
       unknown_key[INVALID_SQL_MODES_LENGTH] == '=' &&
       !memcmp(unknown_key, STRING_WITH_LEN("sql_modes")))
   {
+    char *ptr= unknown_key + INVALID_SQL_MODES_LENGTH + 1;
+
     DBUG_PRINT("info", ("sql_modes affected by BUG#14090 detected"));
     push_warning_printf(current_thd,
                         MYSQL_ERROR::WARN_LEVEL_NOTE,
                         ER_OLD_FILE_FORMAT,
                         ER(ER_OLD_FILE_FORMAT),
                         (char *)path, "TRIGGER");
-    File_option sql_modes_parameters=
-      {
-        {(char *) STRING_WITH_LEN("sql_modes") },
-        offsetof(class Table_triggers_list, definition_modes_list),
-        FILE_OPTIONS_ULLLIST
-      };
-    char *ptr= unknown_key + INVALID_SQL_MODES_LENGTH + 1;
     if (get_file_options_ulllist(ptr, end, unknown_key, base,
                                  &sql_modes_parameters, mem_root))
     {