Merge bk-internal.mysql.com:/home/bk/mysql-5.1

into  bodhi.local:/opt/local/work/mysql-5.1-runtime-merge


mysql-test/t/disabled.def:
  Auto merged
mysql-test/t/ps.test:
  Auto merged
sql/handler.cc:
  Auto merged
sql/handler.h:
  Auto merged
sql/item_sum.cc:
  Auto merged
sql/log_event.cc:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/mysqld.cc:
  Auto merged
sql/sql_base.cc:
  Auto merged
sql/sql_delete.cc:
  Auto merged
sql/sql_lex.h:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/sql_view.cc:
  Auto merged
sql/sql_yacc.yy:
  Auto merged
sql/table.cc:
  Auto merged
storage/csv/ha_tina.cc:
  Auto merged
storage/myisam/ha_myisam.cc:
  Auto merged
mysql-test/r/ps.result:
  SCCS merged

include/hash.h

@@ -65,6 +65,8 @@ my_bool hash_check(HASH *hash);			/* Only in debug library */
 
 #define hash_clear(H) bzero((char*) (H),sizeof(*(H)))
 #define hash_inited(H) ((H)->array.buffer != 0)
+#define hash_init_opt(A,B,C,D,E,F,G,H) \
+          (!hash_inited(A) && _hash_init(A,B,C,D,E,F,G, H CALLER_INFO))
 
 #ifdef	__cplusplus
 }

include/my_time.h

@@ -100,6 +100,8 @@ int my_TIME_to_str(const MYSQL_TIME *l_time, char *to);
 /*
   The following must be sorted so that simple intervals comes first.
   (get_interval_value() depends on this)
+  When updating this enum please update 
+  LEX_STRING interval_type_to_name[] in sql/time.cc
 */
 
 enum interval_type

mysql-test/include/mix1.inc

@@ -259,6 +259,36 @@ select distinct a1 from t4 where pk_col not in (1,2,3,4);
 
 drop table t1,t4;
 
+
+#
+# BUG#18819: DELETE IGNORE hangs on foreign key parent delete
+#
+# The bug itself does not relate to InnoDB, but we have to use foreign
+# keys to reproduce it.
+#
+--disable_warnings
+DROP TABLE IF EXISTS t2, t1;
+--enable_warnings
+
+CREATE TABLE t1 (i INT NOT NULL PRIMARY KEY) ENGINE= InnoDB;
+CREATE TABLE t2 (
+  i INT NOT NULL,
+  FOREIGN KEY (i) REFERENCES t1 (i) ON DELETE NO ACTION
+) ENGINE= InnoDB;
+
+INSERT INTO t1 VALUES (1);
+INSERT INTO t2 VALUES (1);
+
+DELETE IGNORE FROM t1 WHERE i = 1;
+
+SELECT * FROM t1, t2;
+
+DROP TABLE t2, t1;
+
+
+--echo End of 4.1 tests.
+
+
 #
 # Bug #6142: a problem with the empty innodb table
 # (was part of group_min_max.test)

mysql-test/include/sp-vars.inc

@@ -119,4 +119,13 @@ END|
 
 ---------------------------------------------------------------------------
 
+CREATE FUNCTION sp_vars_div_zero() RETURNS INTEGER
+BEGIN
+  DECLARE div_zero INTEGER;
+  SELECT 1/0 INTO div_zero;
+  RETURN div_zero;
+END|
+
+---------------------------------------------------------------------------
+
 delimiter ;|

mysql-test/mysql-test-run.pl

@@ -1425,6 +1425,7 @@ sub environment_setup () {
 # $ENV{'MYSQL_TCP_PORT'}=     '@MYSQL_TCP_PORT@'; # FIXME
   $ENV{'MYSQL_TCP_PORT'}=     3306;
 
+  $ENV{'EXE_MYSQL'}=          $exe_mysql;
   $ENV{MTR_BUILD_THREAD}= 0 unless $ENV{MTR_BUILD_THREAD}; # Set if not set
 
   # ----------------------------------------------------
@@ -1456,6 +1457,9 @@ sub environment_setup () {
   $ENV{'IM_PORT'}=            $instance_manager->{port};
   $ENV{'IM_DEFAULTS_PATH'}=   $instance_manager->{defaults_file};
   $ENV{'IM_PASSWORD_PATH'}=   $instance_manager->{password_file};
+  $ENV{'IM_PATH_SOCK'}=       $instance_manager->{path_sock};
+  $ENV{'IM_USERNAME'}=        $instance_manager->{admin_login};
+  $ENV{'IM_PASSWORD'}=        $instance_manager->{admin_password};
 
   $ENV{'IM_MYSQLD1_SOCK'}=    $instance_manager->{instances}->[0]->{path_sock};
   $ENV{'IM_MYSQLD1_PORT'}=    $instance_manager->{instances}->[0]->{port};
@@ -1464,9 +1468,9 @@ sub environment_setup () {
   $ENV{'IM_MYSQLD2_PORT'}=    $instance_manager->{instances}->[1]->{port};
   $ENV{'IM_MYSQLD2_PATH_PID'}=$instance_manager->{instances}->[1]->{path_pid};
 
-  # ----------------------------------------------------
+# ----------------------------------------------------
-  # Setup env so childs can execute mysqlcheck
+# Setup env so childs can execute mysqlcheck
-  # ----------------------------------------------------
+# ----------------------------------------------------
   my $cmdline_mysqlcheck=
     "$exe_mysqlcheck --no-defaults -uroot " .
     "--port=$master->[0]->{'port'} " .
@@ -1630,9 +1634,9 @@ sub environment_setup () {
       ($ENV{'LD_LIBRARY_PATH'} ? ":$ENV{'LD_LIBRARY_PATH'}" : "");
 
 
-  # ----------------------------------------------------
+# ----------------------------------------------------
-  # We are nice and report a bit about our settings
+# We are nice and report a bit about our settings
-  # ----------------------------------------------------
+# ----------------------------------------------------
   if (!$opt_extern)
   {
     print "Using MTR_BUILD_THREAD      = $ENV{MTR_BUILD_THREAD}\n";

mysql-test/r/im_daemon_life_cycle.result

@@ -8,6 +8,7 @@ mysqld2	offline
 Killing the process...
 Sleeping...
 Success: the process was restarted.
+Success: server is ready to accept connection on socket.
 
 --------------------------------------------------------------------
 -- Test for BUG#12751

mysql-test/r/innodb_mysql.result

@@ -248,6 +248,22 @@ b
 c
 d
 drop table t1,t4;
+DROP TABLE IF EXISTS t2, t1;
+CREATE TABLE t1 (i INT NOT NULL PRIMARY KEY) ENGINE= InnoDB;
+CREATE TABLE t2 (
+i INT NOT NULL,
+FOREIGN KEY (i) REFERENCES t1 (i) ON DELETE NO ACTION
+) ENGINE= InnoDB;
+INSERT INTO t1 VALUES (1);
+INSERT INTO t2 VALUES (1);
+DELETE IGNORE FROM t1 WHERE i = 1;
+Warnings:
+Error	1451	Cannot delete or update a parent row: a foreign key constraint fails (`test`.`t2`, CONSTRAINT `t2_ibfk_1` FOREIGN KEY (`i`) REFERENCES `t1` (`i`) ON DELETE NO ACTION)
+SELECT * FROM t1, t2;
+i	i
+1	1
+DROP TABLE t2, t1;
+End of 4.1 tests.
 create table t1 (
 a varchar(30), b varchar(30), primary key(a), key(b)
 );

mysql-test/r/log_tables.result

@@ -218,3 +218,71 @@ unlock tables;
 use mysql;
 lock tables general_log read local, help_category read local;
 unlock tables;
+use mysql;
+RENAME TABLE general_log TO renamed_general_log;
+ERROR HY000: Cannot rename 'general_log'. When logging enabled, rename to/from log table must rename two tables: the log table to an archive table and another table back to 'general_log'
+RENAME TABLE slow_log TO renamed_slow_log;
+ERROR HY000: Cannot rename 'slow_log'. When logging enabled, rename to/from log table must rename two tables: the log table to an archive table and another table back to 'slow_log'
+truncate table general_log;
+select * from general_log;
+event_time	user_host	thread_id	server_id	command_type	argument
+TIMESTAMP	USER_HOST	THREAD_ID	1	Query	select * from general_log
+truncate table slow_log;
+select * from slow_log;
+start_time	user_host	query_time	lock_time	rows_sent	rows_examined	db	last_insert_id	insert_id	server_id	sql_text
+create table general_log_new like general_log;
+rename table general_log TO renamed_general_log, general_log_new TO general_log;
+create table slow_log_new like slow_log;
+rename table slow_log TO renamed_slow_log, slow_log_new TO slow_log;
+rename table general_log TO general_log_new, renamed_general_log TO general_log, slow_log to renamed_slow_log;
+ERROR HY000: Cannot rename 'slow_log'. When logging enabled, rename to/from log table must rename two tables: the log table to an archive table and another table back to 'slow_log'
+select * from general_log;
+event_time	user_host	thread_id	server_id	command_type	argument
+TIMESTAMP	USER_HOST	THREAD_ID	1	Query	create table slow_log_new like slow_log
+TIMESTAMP	USER_HOST	THREAD_ID	1	Query	rename table slow_log TO renamed_slow_log, slow_log_new TO slow_log
+TIMESTAMP	USER_HOST	THREAD_ID	1	Query	rename table general_log TO general_log_new, renamed_general_log TO general_log, slow_log to renamed_slow_log
+TIMESTAMP	USER_HOST	THREAD_ID	1	Query	select * from general_log
+select * from renamed_general_log;
+event_time	user_host	thread_id	server_id	command_type	argument
+TIMESTAMP	USER_HOST	THREAD_ID	1	Query	select * from general_log
+TIMESTAMP	USER_HOST	THREAD_ID	1	Query	truncate table slow_log
+TIMESTAMP	USER_HOST	THREAD_ID	1	Query	select * from slow_log
+TIMESTAMP	USER_HOST	THREAD_ID	1	Query	create table general_log_new like general_log
+TIMESTAMP	USER_HOST	THREAD_ID	1	Query	rename table general_log TO renamed_general_log, general_log_new TO general_log
+select * from slow_log;
+start_time	user_host	query_time	lock_time	rows_sent	rows_examined	db	last_insert_id	insert_id	server_id	sql_text
+select * from renamed_slow_log;
+start_time	user_host	query_time	lock_time	rows_sent	rows_examined	db	last_insert_id	insert_id	server_id	sql_text
+set global general_log='OFF';
+RENAME TABLE general_log TO general_log2;
+set global slow_query_log='OFF';
+RENAME TABLE slow_log TO slow_log2;
+set global general_log='ON';
+ERROR HY000: Cannot activate 'general' log
+set global slow_query_log='ON';
+ERROR HY000: Cannot activate 'slow query' log
+RENAME TABLE general_log2 TO general_log;
+RENAME TABLE slow_log2 TO slow_log;
+set global general_log='ON';
+set global slow_query_log='ON';
+flush logs;
+flush logs;
+drop table renamed_general_log, renamed_slow_log;
+use test;
+use mysql;
+repair table general_log;
+Table	Op	Msg_type	Msg_text
+mysql.general_log	repair	status	OK
+repair table slow_log;
+Table	Op	Msg_type	Msg_text
+mysql.slow_log	repair	status	OK
+create table general_log_new like general_log;
+create table slow_log_new like slow_log;
+show tables like "%log%";
+Tables_in_mysql (%log%)
+general_log
+general_log_new
+slow_log
+slow_log_new
+drop table slow_log_new, general_log_new;
+use test;

mysql-test/r/ps.result

@@ -499,6 +499,103 @@ create temporary table if not exists t1 (a1 int);
 execute stmt;
 drop temporary table t1;
 deallocate prepare stmt;
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (i INT, INDEX(i));
+INSERT INTO t1 VALUES (1);
+PREPARE stmt FROM "SELECT (COUNT(i) = 1), COUNT(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(COUNT(i) = 1)	COUNT(i)
+0	0
+SET @a = 1;
+EXECUTE stmt USING @a;
+(COUNT(i) = 1)	COUNT(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(COUNT(i) = 1)	COUNT(i)
+0	0
+PREPARE stmt FROM "SELECT (AVG(i) = 1), AVG(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(AVG(i) = 1)	AVG(i)
+NULL	NULL
+SET @a = 1;
+EXECUTE stmt USING @a;
+(AVG(i) = 1)	AVG(i)
+1	1.0000
+SET @a = 0;
+EXECUTE stmt USING @a;
+(AVG(i) = 1)	AVG(i)
+NULL	NULL
+PREPARE stmt FROM "SELECT (VARIANCE(i) = 1), VARIANCE(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(VARIANCE(i) = 1)	VARIANCE(i)
+NULL	NULL
+SET @a = 1;
+EXECUTE stmt USING @a;
+(VARIANCE(i) = 1)	VARIANCE(i)
+0	0.0000
+SET @a = 0;
+EXECUTE stmt USING @a;
+(VARIANCE(i) = 1)	VARIANCE(i)
+NULL	NULL
+PREPARE stmt FROM "SELECT (STDDEV(i) = 1), STDDEV(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(STDDEV(i) = 1)	STDDEV(i)
+NULL	NULL
+SET @a = 1;
+EXECUTE stmt USING @a;
+(STDDEV(i) = 1)	STDDEV(i)
+0	0.0000
+SET @a = 0;
+EXECUTE stmt USING @a;
+(STDDEV(i) = 1)	STDDEV(i)
+NULL	NULL
+PREPARE stmt FROM "SELECT (BIT_OR(i) = 1), BIT_OR(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_OR(i) = 1)	BIT_OR(i)
+0	0
+SET @a = 1;
+EXECUTE stmt USING @a;
+(BIT_OR(i) = 1)	BIT_OR(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_OR(i) = 1)	BIT_OR(i)
+0	0
+PREPARE stmt FROM "SELECT (BIT_AND(i) = 1), BIT_AND(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_AND(i) = 1)	BIT_AND(i)
+0	18446744073709551615
+SET @a = 1;
+EXECUTE stmt USING @a;
+(BIT_AND(i) = 1)	BIT_AND(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_AND(i) = 1)	BIT_AND(i)
+0	18446744073709551615
+PREPARE stmt FROM "SELECT (BIT_XOR(i) = 1), BIT_XOR(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_XOR(i) = 1)	BIT_XOR(i)
+0	0
+SET @a = 1;
+EXECUTE stmt USING @a;
+(BIT_XOR(i) = 1)	BIT_XOR(i)
+1	1
+SET @a = 0;
+EXECUTE stmt USING @a;
+(BIT_XOR(i) = 1)	BIT_XOR(i)
+0	0
+DEALLOCATE PREPARE stmt;
+DROP TABLE t1;
+End of 4.1 tests.
 create table t1 (a varchar(20));
 insert into t1 values ('foo');
 prepare stmt FROM 'SELECT char_length (a) FROM t1';
@@ -1379,6 +1476,7 @@ i
 1
 DEALLOCATE PREPARE stmt;
 DROP TABLE t1, t2;
+DROP PROCEDURE IF EXISTS p1;
 End of 5.0 tests.
 create procedure proc_1() reset query cache;
 call proc_1();

mysql-test/r/sp-error.result

@@ -1226,6 +1226,30 @@ END;
 ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'IF NOT EXISTS bug14702()
 BEGIN
 END' at line 1
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (i INT);
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO @a;
+ERROR HY000: View's SELECT contains a 'INTO' clause
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO DUMPFILE "file";
+ERROR HY000: View's SELECT contains a 'INTO' clause
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO OUTFILE "file";
+ERROR HY000: View's SELECT contains a 'INTO' clause
+CREATE PROCEDURE bug20953()
+CREATE VIEW v AS SELECT i FROM t1 PROCEDURE ANALYSE();
+ERROR HY000: View's SELECT contains a 'PROCEDURE' clause
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 FROM (SELECT 1) AS d1;
+ERROR HY000: View's SELECT contains a subquery in the FROM clause
+CREATE PROCEDURE bug20953(i INT) CREATE VIEW v AS SELECT i;
+ERROR HY000: View's SELECT contains a variable or parameter
+CREATE PROCEDURE bug20953()
+BEGIN
+DECLARE i INT;
+CREATE VIEW v AS SELECT i;
+END |
+ERROR HY000: View's SELECT contains a variable or parameter
+PREPARE stmt FROM "CREATE VIEW v AS SELECT ?";
+ERROR HY000: View's SELECT contains a variable or parameter
+DROP TABLE t1;
 End of 5.0 tests
 drop function if exists bug16164;
 create function bug16164() returns int
@@ -1234,9 +1258,9 @@ show authors;
 return 42;
 end|
 ERROR 0A000: Not allowed to return a result set from a function
-drop function if exists bug20701|
+drop function if exists bug20701;
-create function bug20701() returns varchar(25) binary return "test"|
+create function bug20701() returns varchar(25) binary return "test";
 ERROR 42000: This version of MySQL doesn't yet support 'return value collation'
-create function bug20701() returns varchar(25) return "test"|
+create function bug20701() returns varchar(25) return "test";
-drop function bug20701|
+drop function bug20701;
 End of 5.1 tests

mysql-test/r/sp-vars.result

@@ -4,6 +4,7 @@ DROP FUNCTION IF EXISTS sp_vars_check_ret1;
 DROP FUNCTION IF EXISTS sp_vars_check_ret2;
 DROP FUNCTION IF EXISTS sp_vars_check_ret3;
 DROP FUNCTION IF EXISTS sp_vars_check_ret4;
+DROP FUNCTION IF EXISTS sp_vars_div_zero;
 SET @@sql_mode = 'ansi';
 CREATE PROCEDURE sp_vars_check_dflt()
 BEGIN
@@ -88,6 +89,12 @@ CREATE FUNCTION sp_vars_check_ret4() RETURNS DECIMAL(64, 2)
 BEGIN
 RETURN 12 * 10 + 34 + 0.1234;
 END|
+CREATE FUNCTION sp_vars_div_zero() RETURNS INTEGER
+BEGIN
+DECLARE div_zero INTEGER;
+SELECT 1/0 INTO div_zero;
+RETURN div_zero;
+END|
 
 ---------------------------------------------------------------
 Calling the routines, created in ANSI mode.
@@ -172,6 +179,9 @@ sp_vars_check_ret4()
 154.12
 Warnings:
 Note	1265	Data truncated for column 'sp_vars_check_ret4()' at row 1
+SELECT sp_vars_div_zero();
+sp_vars_div_zero()
+NULL
 SET @@sql_mode = 'traditional';
 
 ---------------------------------------------------------------
@@ -257,12 +267,16 @@ sp_vars_check_ret4()
 154.12
 Warnings:
 Note	1265	Data truncated for column 'sp_vars_check_ret4()' at row 1
+SELECT sp_vars_div_zero();
+sp_vars_div_zero()
+NULL
 DROP PROCEDURE sp_vars_check_dflt;
 DROP PROCEDURE sp_vars_check_assignment;
 DROP FUNCTION sp_vars_check_ret1;
 DROP FUNCTION sp_vars_check_ret2;
 DROP FUNCTION sp_vars_check_ret3;
 DROP FUNCTION sp_vars_check_ret4;
+DROP FUNCTION sp_vars_div_zero;
 CREATE PROCEDURE sp_vars_check_dflt()
 BEGIN
 DECLARE v1 TINYINT DEFAULT 1e200;
@@ -346,6 +360,12 @@ CREATE FUNCTION sp_vars_check_ret4() RETURNS DECIMAL(64, 2)
 BEGIN
 RETURN 12 * 10 + 34 + 0.1234;
 END|
+CREATE FUNCTION sp_vars_div_zero() RETURNS INTEGER
+BEGIN
+DECLARE div_zero INTEGER;
+SELECT 1/0 INTO div_zero;
+RETURN div_zero;
+END|
 
 ---------------------------------------------------------------
 Calling the routines, created in TRADITIONAL mode.
@@ -366,6 +386,8 @@ sp_vars_check_ret4()
 154.12
 Warnings:
 Note	1265	Data truncated for column 'sp_vars_check_ret4()' at row 1
+SELECT sp_vars_div_zero();
+ERROR 22012: Division by 0
 SET @@sql_mode = 'ansi';
 DROP PROCEDURE sp_vars_check_dflt;
 DROP PROCEDURE sp_vars_check_assignment;
@@ -373,6 +395,7 @@ DROP FUNCTION sp_vars_check_ret1;
 DROP FUNCTION sp_vars_check_ret2;
 DROP FUNCTION sp_vars_check_ret3;
 DROP FUNCTION sp_vars_check_ret4;
+DROP FUNCTION sp_vars_div_zero;
 
 ---------------------------------------------------------------
 BIT data type tests

mysql-test/r/sp.result

@@ -5470,5 +5470,161 @@ CAD
 CHF
 DROP FUNCTION bug21493|
 DROP TABLE t3,t4|
+drop function if exists func_20028_a|
+drop function if exists func_20028_b|
+drop function if exists func_20028_c|
+drop procedure if exists proc_20028_a|
+drop procedure if exists proc_20028_b|
+drop procedure if exists proc_20028_c|
+drop table if exists table_20028|
+create table table_20028 (i int)|
+SET @save_sql_mode=@@sql_mode|
+SET sql_mode=''|
+create function func_20028_a() returns integer
+begin
+declare temp integer;
+select i into temp from table_20028 limit 1;
+return ifnull(temp, 0);
+end|
+create function func_20028_b() returns integer
+begin
+return func_20028_a();
+end|
+create function func_20028_c() returns integer
+begin
+declare div_zero integer;
+set SQL_MODE='TRADITIONAL';
+select 1/0 into div_zero;
+return div_zero;
+end|
+create procedure proc_20028_a()
+begin
+declare temp integer;
+select i into temp from table_20028 limit 1;
+end|
+create procedure proc_20028_b()
+begin
+call proc_20028_a();
+end|
+create procedure proc_20028_c()
+begin
+declare div_zero integer;
+set SQL_MODE='TRADITIONAL';
+select 1/0 into div_zero;
+end|
+select func_20028_a()|
+func_20028_a()
+0
+Warnings:
+Warning	1329	No data - zero rows fetched, selected, or processed
+select func_20028_b()|
+func_20028_b()
+0
+Warnings:
+Warning	1329	No data - zero rows fetched, selected, or processed
+select func_20028_c()|
+ERROR 22012: Division by 0
+call proc_20028_a()|
+Warnings:
+Warning	1329	No data - zero rows fetched, selected, or processed
+call proc_20028_b()|
+Warnings:
+Warning	1329	No data - zero rows fetched, selected, or processed
+call proc_20028_c()|
+ERROR 22012: Division by 0
+SET sql_mode='TRADITIONAL'|
+drop function func_20028_a|
+drop function func_20028_b|
+drop function func_20028_c|
+drop procedure proc_20028_a|
+drop procedure proc_20028_b|
+drop procedure proc_20028_c|
+create function func_20028_a() returns integer
+begin
+declare temp integer;
+select i into temp from table_20028 limit 1;
+return ifnull(temp, 0);
+end|
+create function func_20028_b() returns integer
+begin
+return func_20028_a();
+end|
+create function func_20028_c() returns integer
+begin
+declare div_zero integer;
+set SQL_MODE='';
+select 1/0 into div_zero;
+return div_zero;
+end|
+create procedure proc_20028_a()
+begin
+declare temp integer;
+select i into temp from table_20028 limit 1;
+end|
+create procedure proc_20028_b()
+begin
+call proc_20028_a();
+end|
+create procedure proc_20028_c()
+begin
+declare div_zero integer;
+set SQL_MODE='';
+select 1/0 into div_zero;
+end|
+select func_20028_a()|
+func_20028_a()
+0
+Warnings:
+Warning	1329	No data - zero rows fetched, selected, or processed
+select func_20028_b()|
+func_20028_b()
+0
+Warnings:
+Warning	1329	No data - zero rows fetched, selected, or processed
+select func_20028_c()|
+func_20028_c()
+NULL
+call proc_20028_a()|
+Warnings:
+Warning	1329	No data - zero rows fetched, selected, or processed
+call proc_20028_b()|
+Warnings:
+Warning	1329	No data - zero rows fetched, selected, or processed
+call proc_20028_c()|
+SET @@sql_mode=@save_sql_mode|
+drop function func_20028_a|
+drop function func_20028_b|
+drop function func_20028_c|
+drop procedure proc_20028_a|
+drop procedure proc_20028_b|
+drop procedure proc_20028_c|
+drop table table_20028|
+drop procedure if exists proc_21462_a|
+drop procedure if exists proc_21462_b|
+create procedure proc_21462_a()
+begin
+select "Called A";
+end|
+create procedure proc_21462_b(x int)
+begin
+select "Called B";
+end|
+call proc_21462_a|
+Called A
+Called A
+call proc_21462_a()|
+Called A
+Called A
+call proc_21462_a(1)|
+ERROR 42000: Incorrect number of arguments for PROCEDURE test.proc_21462_a; expected 0, got 1
+call proc_21462_b|
+ERROR 42000: Incorrect number of arguments for PROCEDURE test.proc_21462_b; expected 1, got 0
+call proc_21462_b()|
+ERROR 42000: Incorrect number of arguments for PROCEDURE test.proc_21462_b; expected 1, got 0
+call proc_21462_b(1)|
+Called B
+Called B
+drop procedure proc_21462_a|
+drop procedure proc_21462_b|
 End of 5.0 tests
 drop table t1,t2;

mysql-test/r/trigger.result

@@ -1073,10 +1073,11 @@ SELECT @x;
 NULL
 SET @x=2;
 UPDATE t1 SET i1 = @x;
-ERROR 22012: Division by 0
+Warnings:
+Error	1365	Division by 0
 SELECT @x;
 @x
-2
+NULL
 SET SQL_MODE='';
 SET @x=3;
 INSERT INTO t1 VALUES (@x);
@@ -1085,10 +1086,12 @@ SELECT @x;
 NULL
 SET @x=4;
 UPDATE t1 SET i1 = @x;
-ERROR 22012: Division by 0
+Warnings:
+Error	1365	Division by 0
+Error	1365	Division by 0
 SELECT @x;
 @x
-4
+NULL
 SET @@sql_mode=@save_sql_mode;
 DROP TRIGGER t1_ai;
 DROP TRIGGER t1_au;
@@ -1174,6 +1177,59 @@ ERROR HY000: String '1234567890abcdefghij1234567890abcdefghij1234567890abcdefghi
 DROP TABLE t1;
 DROP TABLE t2;
 drop table if exists t1;
+drop table if exists t2;
+drop table if exists t3;
+drop table if exists t4;
+SET @save_sql_mode=@@sql_mode;
+SET sql_mode='TRADITIONAL'|
+create table t1 (id int(10) not null primary key, v int(10) )|
+create table t2 (id int(10) not null primary key, v int(10) )|
+create table t3 (id int(10) not null primary key, v int(10) )|
+create table t4 (c int)|
+create trigger t4_bi before insert on t4 for each row set @t4_bi_called:=1|
+create trigger t4_bu before update on t4 for each row set @t4_bu_called:=1|
+insert into t1 values(10, 10)|
+set @a:=1/0|
+Warnings:
+Error	1365	Division by 0
+select 1/0 from t1|
+1/0
+NULL
+Warnings:
+Error	1365	Division by 0
+create trigger t1_bi before insert on t1 for each row set @a:=1/0|
+insert into t1 values(20, 20)|
+Warnings:
+Error	1365	Division by 0
+drop trigger t1_bi|
+create trigger t1_bi before insert on t1 for each row
+begin
+insert into t2 values (new.id, new.v);
+update t2 set v=v+1 where id= new.id;
+replace t3 values (new.id, 0);
+update t2, t3 set t2.v=new.v, t3.v=new.v where t2.id=t3.id;
+create temporary table t5 select * from t1;
+delete from t5;
+insert into t5 select * from t1;
+insert into t4 values (0);
+set @check= (select count(*) from t5);
+update t4 set c= @check;
+drop temporary table t5;
+set @a:=1/0;
+end|
+set @check=0, @t4_bi_called=0, @t4_bu_called=0|
+insert into t1 values(30, 30)|
+Warnings:
+Error	1365	Division by 0
+select @check, @t4_bi_called, @t4_bu_called|
+@check	@t4_bi_called	@t4_bu_called
+2	1	1
+SET @@sql_mode=@save_sql_mode;
+drop table t1;
+drop table t2;
+drop table t3;
+drop table t4;
+drop table if exists t1;
 create table t1 (i int, j int key);
 insert into t1 values (1,1), (2,2), (3,3);
 create trigger t1_bu before update on t1 for each row

mysql-test/r/view.result

@@ -12,6 +12,9 @@ create table t1 (a int, b int);
 insert into t1 values (1,2), (1,3), (2,4), (2,5), (3,10);
 create view v1 (c,d) as select a,b+@@global.max_user_connections from t1;
 ERROR HY000: View's SELECT contains a variable or parameter
+create view v1 (c,d) as select a,b from t1
+where a = @@global.max_user_connections;
+ERROR HY000: View's SELECT contains a variable or parameter
 create view v1 (c) as select b+1 from t1;
 select c from v1;
 c
@@ -596,11 +599,6 @@ ERROR HY000: View 'test.v1' references invalid table(s) or column(s) or function
 drop view v1;
 create view v1 (a,a) as select 'a','a';
 ERROR 42S21: Duplicate column name 'a'
-drop procedure if exists p1;
-create procedure p1 () begin declare v int; create view v1 as select v; end;//
-call p1();
-ERROR HY000: View's SELECT contains a variable or parameter
-drop procedure p1;
 create table t1 (col1 int,col2 char(22));
 insert into t1 values(5,'Hello, world of views');
 create view v1 as select * from t1;
@@ -886,6 +884,8 @@ ERROR HY000: View's SELECT contains a 'INTO' clause
 create table t1 (a int);
 create view v1 as select a from t1 procedure analyse();
 ERROR HY000: View's SELECT contains a 'PROCEDURE' clause
+create view v1 as select 1 from (select 1) as d1;
+ERROR HY000: View's SELECT contains a subquery in the FROM clause
 drop table t1;
 create table t1 (s1 int, primary key (s1));
 create view v1 as select * from t1;
@@ -2956,6 +2956,20 @@ View	Create View
 v1	CREATE ALGORITHM=MERGE DEFINER=`root`@`localhost` SQL SECURITY DEFINER VIEW `v1` AS select `t1`.`pk` AS `pk` from (`t1` join `t2` on(((`t2`.`fk` = `t1`.`pk`) and (`t2`.`ver` = (select max(`t`.`ver`) AS `MAX(t.ver)` from `t2` `t` where (`t`.`org` = `t2`.`org`))))))
 DROP VIEW v1;
 DROP TABLE t1, t2;
+DROP FUNCTION IF EXISTS f1;
+DROP VIEW IF EXISTS v1;
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (i INT);
+INSERT INTO t1 VALUES (1);
+CREATE VIEW v1 AS SELECT MAX(i) FROM t1;
+CREATE TRIGGER t1_bi BEFORE INSERT ON t1 FOR EACH ROW
+SET NEW.i = (SELECT * FROM v1) + 1;
+INSERT INTO t1 VALUES (1);
+CREATE FUNCTION f1() RETURNS INT RETURN (SELECT * FROM v1);
+UPDATE t1 SET i= f1();
+DROP FUNCTION f1;
+DROP VIEW v1;
+DROP TABLE t1;
 CREATE TABLE t1(id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, val INT UNSIGNED NOT NULL);
 CREATE VIEW v1 AS SELECT id, val FROM t1 WHERE val >= 1 AND val <= 5 WITH CHECK OPTION;
 INSERT INTO v1 (val) VALUES (2);
@@ -2966,4 +2980,38 @@ UPDATE v1 SET val=6 WHERE id=2;
 ERROR HY000: CHECK OPTION failed 'test.v1'
 DROP VIEW v1;
 DROP TABLE t1;
+DROP VIEW IF EXISTS v1, v2;
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (i INT AUTO_INCREMENT PRIMARY KEY, j INT);
+CREATE VIEW v1 AS SELECT j FROM t1;
+CREATE VIEW v2 AS SELECT * FROM t1;
+INSERT INTO t1 (j) VALUES (1);
+SELECT LAST_INSERT_ID();
+LAST_INSERT_ID()
+1
+INSERT INTO v1 (j) VALUES (2);
+# LAST_INSERT_ID() should not change.
+SELECT LAST_INSERT_ID();
+LAST_INSERT_ID()
+1
+INSERT INTO v2 (j) VALUES (3);
+# LAST_INSERT_ID() should be updated.
+SELECT LAST_INSERT_ID();
+LAST_INSERT_ID()
+3
+INSERT INTO v1 (j) SELECT j FROM t1;
+# LAST_INSERT_ID() should not change.
+SELECT LAST_INSERT_ID();
+LAST_INSERT_ID()
+3
+SELECT * FROM t1;
+i	j
+1	1
+2	2
+3	3
+4	1
+5	2
+6	3
+DROP VIEW v1, v2;
+DROP TABLE t1;
 End of 5.0 tests.

mysql-test/t/disabled.def

@@ -14,8 +14,6 @@
 #events                   : BUG#17619 2006-02-21 andrey  Race conditions
 #events_scheduling        : BUG#19170 2006-04-26 andrey  Test case of 19170 fails on some platforms. Has to be checked.
 im_options                : Bug#20294 2006-07-24 stewart   Instance manager test im_options fails randomly
-#im_life_cycle             : Bug#20368 2006-06-10 alik    im_life_cycle test fails
-im_daemon_life_cycle     : BUG#22379 2006-09-15 ingo    im_daemon_life_cycle.test fails on merge of 5.1 -> 5.1-engines
 im_instance_conf         : BUG#20294 2006-09-16 ingo    Instance manager test im_instance_conf fails randomly
 concurrent_innodb        : BUG#21579 2006-08-11 mleich innodb_concurrent random failures with varying differences
 ndb_autodiscover         : BUG#18952 2006-02-16 jmiller Needs to be fixed w.r.t binlog

mysql-test/t/func_gconcat.test

@@ -98,7 +98,7 @@ select ifnull(group_concat(concat(t1.id, ':', t1.name)), 'shortname') as 'withou
 select distinct ifnull(group_concat(concat(t1.id, ':', t1.name)), 'shortname') as 'with distinct: cutoff at length of shortname' from t1;
 drop table t1;
 
-# check zero rows
+# check zero rows (bug#836)
 create table t1(id int);
 create table t2(id int);
 insert into t1 values(0),(1);

mysql-test/t/im_daemon_life_cycle.imtest

@@ -17,6 +17,12 @@
 
 ###########################################################################
 
+# Wait for IM to start accepting connections.
+
+--exec $MYSQL_TEST_DIR/t/wait_for_socket.sh $EXE_MYSQL $IM_PATH_SOCK $IM_USERNAME $IM_PASSWORD '' 30
+
+###########################################################################
+
 #
 # BUG#12751: Instance Manager: client hangs
 #

mysql-test/t/log_tables.test

@@ -314,6 +314,89 @@ use mysql;
 lock tables general_log read local, help_category read local;
 unlock tables;
 
+#
+# Bug #17544 Cannot do atomic log rotate and
+# Bug #21785 Server crashes after rename of the log table
+#
+
+use mysql;
+# Should result in error
+--error ER_CANT_RENAME_LOG_TABLE
+RENAME TABLE general_log TO renamed_general_log;
+--error ER_CANT_RENAME_LOG_TABLE
+RENAME TABLE slow_log TO renamed_slow_log;
+
+#check rotate logs
+truncate table general_log;
+--replace_column 1 TIMESTAMP 2 USER_HOST 3 THREAD_ID
+select * from general_log;
+
+truncate table slow_log;
+--replace_column 1 TIMESTAMP 2 USER_HOST
+select * from slow_log;
+
+create table general_log_new like general_log;
+rename table general_log TO renamed_general_log, general_log_new TO general_log;
+
+create table slow_log_new like slow_log;
+rename table slow_log TO renamed_slow_log, slow_log_new TO slow_log;
+
+# check that rename checks more then first table in the list
+--error ER_CANT_RENAME_LOG_TABLE
+rename table general_log TO general_log_new, renamed_general_log TO general_log, slow_log to renamed_slow_log;
+
+# now check the content of tables
+--replace_column 1 TIMESTAMP 2 USER_HOST 3 THREAD_ID
+select * from general_log;
+--replace_column 1 TIMESTAMP 2 USER_HOST 3 THREAD_ID
+select * from renamed_general_log;
+
+# the content of the slow log is empty, but we will try a select anyway
+--replace_column 1 TIMESTAMP 2 USER_HOST
+select * from slow_log;
+--replace_column 1 TIMESTAMP 2 USER_HOST
+select * from renamed_slow_log;
+
+# check that we can do whatever we want with disabled log
+set global general_log='OFF';
+RENAME TABLE general_log TO general_log2;
+
+set global slow_query_log='OFF';
+RENAME TABLE slow_log TO slow_log2;
+
+# this should fail
+--error ER_CANT_ACTIVATE_LOG
+set global general_log='ON';
+--error ER_CANT_ACTIVATE_LOG
+set global slow_query_log='ON';
+
+RENAME TABLE general_log2 TO general_log;
+RENAME TABLE slow_log2 TO slow_log;
+
+# this should work
+set global general_log='ON';
+set global slow_query_log='ON';
+# now check flush logs
+flush logs;
+flush logs;
+drop table renamed_general_log, renamed_slow_log;
+use test;
+
+#
+# Bug #21966 Strange warnings on repair of the log tables
+#
+
+use mysql;
+# check that no warning occurs on repair of the log tables
+repair table general_log;
+repair table slow_log;
+# check that no warning occurs on "create like" for the log tables
+create table general_log_new like general_log;
+create table slow_log_new like slow_log;
+show tables like "%log%";
+drop table slow_log_new, general_log_new;
+use test;
+
 # kill all connections
 disconnect con1;
 disconnect con2;

mysql-test/t/ps.test

@@ -988,6 +988,7 @@ execute stmt;
 drop temporary table t1;
 deallocate prepare stmt;
 
+
 #
 # BUG#22085: Crash on the execution of a prepared statement that
 #            uses an IN subquery with aggregate functions in HAVING 
@@ -1040,7 +1041,81 @@ EXECUTE STMT USING @id,@id;
 DEALLOCATE PREPARE STMT;
 DROP TABLE t1;
 
---echo End of 4.1 tests
+#
+# BUG#21354: (COUNT(*) = 1) not working in SELECT inside prepared
+# statement 
+#
+--disable_warnings
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+
+CREATE TABLE t1 (i INT, INDEX(i));
+INSERT INTO t1 VALUES (1);
+
+PREPARE stmt FROM "SELECT (COUNT(i) = 1), COUNT(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (AVG(i) = 1), AVG(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (VARIANCE(i) = 1), VARIANCE(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (STDDEV(i) = 1), STDDEV(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (BIT_OR(i) = 1), BIT_OR(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (BIT_AND(i) = 1), BIT_AND(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+PREPARE stmt FROM "SELECT (BIT_XOR(i) = 1), BIT_XOR(i) FROM t1 WHERE i = ?";
+SET @a = 0;
+EXECUTE stmt USING @a;
+SET @a = 1;
+EXECUTE stmt USING @a;
+SET @a = 0;
+EXECUTE stmt USING @a;
+
+DEALLOCATE PREPARE stmt;
+DROP TABLE t1;
+
+
+--echo End of 4.1 tests.
+
+
+
 ############################# 5.0 tests start ################################
 #
 #
@@ -1437,6 +1512,26 @@ DEALLOCATE PREPARE stmt;
 DROP TABLE t1, t2;
 
 
+#
+# BUG#21856: Prepared Statments: crash if bad create
+#
+--disable_warnings
+DROP PROCEDURE IF EXISTS p1;
+--enable_warnings
+
+let $iterations= 100;
+--disable_query_log
+--disable_result_log
+while ($iterations > 0)
+{
+  --error ER_PARSE_ERROR
+  PREPARE stmt FROM "CREATE PROCEDURE p1()";
+  dec $iterations;
+}
+--enable_query_log
+--enable_result_log
+
+
 --echo End of 5.0 tests.
 
 #

mysql-test/t/sp-error.test

@@ -1748,6 +1748,8 @@ drop function if exists bug16896;
 --error ER_SP_NO_AGGREGATE
 create aggregate function bug16896() returns int return 1;
 
+#
+#
 # BUG#14702: misleading error message when syntax error in CREATE
 # PROCEDURE
 #
@@ -1769,6 +1771,47 @@ BEGIN
 END;
 
 
+#
+# BUG#20953: create proc with a create view that uses local
+# vars/params should fail to create
+#
+# See test case for what syntax is forbidden in a view.
+#
+--disable_warnings
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+
+CREATE TABLE t1 (i INT);
+
+# We do not have to drop this procedure and view because they won't be
+# created.
+--error ER_VIEW_SELECT_CLAUSE
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO @a;
+--error ER_VIEW_SELECT_CLAUSE
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO DUMPFILE "file";
+--error ER_VIEW_SELECT_CLAUSE
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 INTO OUTFILE "file";
+--error ER_VIEW_SELECT_CLAUSE
+CREATE PROCEDURE bug20953()
+  CREATE VIEW v AS SELECT i FROM t1 PROCEDURE ANALYSE();
+--error ER_VIEW_SELECT_DERIVED
+CREATE PROCEDURE bug20953() CREATE VIEW v AS SELECT 1 FROM (SELECT 1) AS d1;
+--error ER_VIEW_SELECT_VARIABLE
+CREATE PROCEDURE bug20953(i INT) CREATE VIEW v AS SELECT i;
+delimiter |;
+--error ER_VIEW_SELECT_VARIABLE
+CREATE PROCEDURE bug20953()
+BEGIN
+  DECLARE i INT;
+  CREATE VIEW v AS SELECT i;
+END |
+delimiter ;|
+--error ER_VIEW_SELECT_VARIABLE
+PREPARE stmt FROM "CREATE VIEW v AS SELECT ?";
+
+DROP TABLE t1;
+
+
 #
 # End of 5.0 tests
 #
@@ -1788,12 +1831,14 @@ begin
   show authors;
   return 42;
 end|
+delimiter ;|
+
 
 #
 # BUG#20701: BINARY keyword should be forbidden in stored routines
 #
 --disable_warnings
-drop function if exists bug20701|
+drop function if exists bug20701;
 --enable_warnings
 #
 # This was disabled in 5.1.12. See bug #20701
@@ -1801,17 +1846,19 @@ drop function if exists bug20701|
 # be removed.
 #
 --error ER_NOT_SUPPORTED_YET
-create function bug20701() returns varchar(25) binary return "test"|
+create function bug20701() returns varchar(25) binary return "test";
-create function bug20701() returns varchar(25) return "test"|
+create function bug20701() returns varchar(25) return "test";
-drop function bug20701|
+drop function bug20701;
+
+
 --echo End of 5.1 tests
 
 #
 # BUG#NNNN: New bug synopsis
 #
 #--disable_warnings
-#drop procedure if exists bugNNNN|
+#drop procedure if exists bugNNNN;
-#drop function if exists bugNNNN|
+#drop function if exists bugNNNN;
 #--enable_warnings
 #create procedure bugNNNN...
 #create function bugNNNN...

mysql-test/t/sp-vars.test

@@ -15,6 +15,7 @@ DROP FUNCTION IF EXISTS sp_vars_check_ret1;
 DROP FUNCTION IF EXISTS sp_vars_check_ret2;
 DROP FUNCTION IF EXISTS sp_vars_check_ret3;
 DROP FUNCTION IF EXISTS sp_vars_check_ret4;
+DROP FUNCTION IF EXISTS sp_vars_div_zero;
 
 --enable_warnings
 
@@ -49,6 +50,8 @@ SELECT sp_vars_check_ret3();
 
 SELECT sp_vars_check_ret4();
 
+SELECT sp_vars_div_zero();
+
 # Check that changing sql_mode after creating a store procedure does not
 # matter.
 
@@ -72,6 +75,8 @@ SELECT sp_vars_check_ret3();
 
 SELECT sp_vars_check_ret4();
 
+SELECT sp_vars_div_zero();
+
 # Create the procedure in TRADITIONAL mode. Check that error will be thrown on
 # execution.
 
@@ -81,6 +86,7 @@ DROP FUNCTION sp_vars_check_ret1;
 DROP FUNCTION sp_vars_check_ret2;
 DROP FUNCTION sp_vars_check_ret3;
 DROP FUNCTION sp_vars_check_ret4;
+DROP FUNCTION sp_vars_div_zero;
 
 --source include/sp-vars.inc
 
@@ -110,6 +116,9 @@ SELECT sp_vars_check_ret3();
 
 SELECT sp_vars_check_ret4();
 
+--error ER_DIVISION_BY_ZERO
+SELECT sp_vars_div_zero();
+
 SET @@sql_mode = 'ansi';
 
 #
@@ -122,6 +131,7 @@ DROP FUNCTION sp_vars_check_ret1;
 DROP FUNCTION sp_vars_check_ret2;
 DROP FUNCTION sp_vars_check_ret3;
 DROP FUNCTION sp_vars_check_ret4;
+DROP FUNCTION sp_vars_div_zero;
 
 ###########################################################################
 #

mysql-test/t/sp.test

@@ -6419,6 +6419,170 @@ SELECT bug21493(Member_ID) FROM t3|
 DROP FUNCTION bug21493|
 DROP TABLE t3,t4|
 
+#
+# Bug#20028 Function with select return no data
+#
+
+--disable_warnings
+drop function if exists func_20028_a|
+drop function if exists func_20028_b|
+drop function if exists func_20028_c|
+drop procedure if exists proc_20028_a|
+drop procedure if exists proc_20028_b|
+drop procedure if exists proc_20028_c|
+drop table if exists table_20028|
+--enable_warnings
+
+create table table_20028 (i int)|
+
+SET @save_sql_mode=@@sql_mode|
+
+SET sql_mode=''|
+
+create function func_20028_a() returns integer
+begin
+  declare temp integer;
+  select i into temp from table_20028 limit 1;
+  return ifnull(temp, 0);
+end|
+
+create function func_20028_b() returns integer
+begin
+  return func_20028_a();
+end|
+
+create function func_20028_c() returns integer
+begin
+  declare div_zero integer;
+  set SQL_MODE='TRADITIONAL';
+  select 1/0 into div_zero;
+  return div_zero;
+end|
+
+create procedure proc_20028_a()
+begin
+  declare temp integer;
+  select i into temp from table_20028 limit 1;
+end|
+
+create procedure proc_20028_b()
+begin
+  call proc_20028_a();
+end|
+
+create procedure proc_20028_c()
+begin
+  declare div_zero integer;
+  set SQL_MODE='TRADITIONAL';
+  select 1/0 into div_zero;
+end|
+
+select func_20028_a()|
+select func_20028_b()|
+--error ER_DIVISION_BY_ZERO
+select func_20028_c()|
+call proc_20028_a()|
+call proc_20028_b()|
+--error ER_DIVISION_BY_ZERO
+call proc_20028_c()|
+
+SET sql_mode='TRADITIONAL'|
+
+drop function func_20028_a|
+drop function func_20028_b|
+drop function func_20028_c|
+drop procedure proc_20028_a|
+drop procedure proc_20028_b|
+drop procedure proc_20028_c|
+
+create function func_20028_a() returns integer
+begin
+  declare temp integer;
+  select i into temp from table_20028 limit 1;
+  return ifnull(temp, 0);
+end|
+
+create function func_20028_b() returns integer
+begin
+  return func_20028_a();
+end|
+
+create function func_20028_c() returns integer
+begin
+  declare div_zero integer;
+  set SQL_MODE='';
+  select 1/0 into div_zero;
+  return div_zero;
+end|
+
+create procedure proc_20028_a()
+begin
+  declare temp integer;
+  select i into temp from table_20028 limit 1;
+end|
+
+create procedure proc_20028_b()
+begin
+  call proc_20028_a();
+end|
+
+create procedure proc_20028_c()
+begin
+  declare div_zero integer;
+  set SQL_MODE='';
+  select 1/0 into div_zero;
+end|
+
+select func_20028_a()|
+select func_20028_b()|
+select func_20028_c()|
+call proc_20028_a()|
+call proc_20028_b()|
+call proc_20028_c()|
+
+SET @@sql_mode=@save_sql_mode|
+
+drop function func_20028_a|
+drop function func_20028_b|
+drop function func_20028_c|
+drop procedure proc_20028_a|
+drop procedure proc_20028_b|
+drop procedure proc_20028_c|
+drop table table_20028|
+
+#
+# Bug#21462 Stored procedures with no arguments require parenthesis
+#
+
+--disable_warnings
+drop procedure if exists proc_21462_a|
+drop procedure if exists proc_21462_b|
+--enable_warnings
+
+create procedure proc_21462_a()
+begin
+  select "Called A";
+end|
+
+create procedure proc_21462_b(x int)
+begin
+  select "Called B";
+end|
+
+call proc_21462_a|
+call proc_21462_a()|
+-- error ER_SP_WRONG_NO_OF_ARGS
+call proc_21462_a(1)|
+
+-- error ER_SP_WRONG_NO_OF_ARGS
+call proc_21462_b|
+-- error ER_SP_WRONG_NO_OF_ARGS
+call proc_21462_b()|
+call proc_21462_b(1)|
+
+drop procedure proc_21462_a|
+drop procedure proc_21462_b|
+
 --echo End of 5.0 tests
 
 

mysql-test/t/trigger.test

@@ -1274,7 +1274,6 @@ INSERT INTO t1 VALUES (@x);
 SELECT @x;
 
 SET @x=2;
---error ER_DIVISION_BY_ZERO
 UPDATE t1 SET i1 = @x;
 SELECT @x;
 
@@ -1285,7 +1284,6 @@ INSERT INTO t1 VALUES (@x);
 SELECT @x;
 
 SET @x=4;
---error ER_DIVISION_BY_ZERO
 UPDATE t1 SET i1 = @x;
 SELECT @x;
 
@@ -1420,6 +1418,67 @@ CREATE DEFINER=some_user_name@1234567890abcdefghij1234567890abcdefghij1234567890
 DROP TABLE t1;
 DROP TABLE t2;
 
+#
+# Bug#20028 Function with select return no data
+# 
+
+--disable_warnings
+drop table if exists t1;
+drop table if exists t2;
+drop table if exists t3;
+drop table if exists t4;
+--enable_warnings
+
+SET @save_sql_mode=@@sql_mode;
+
+delimiter |;
+SET sql_mode='TRADITIONAL'|
+create table t1 (id int(10) not null primary key, v int(10) )|
+create table t2 (id int(10) not null primary key, v int(10) )|
+create table t3 (id int(10) not null primary key, v int(10) )|
+create table t4 (c int)|
+
+create trigger t4_bi before insert on t4 for each row set @t4_bi_called:=1|
+create trigger t4_bu before update on t4 for each row set @t4_bu_called:=1|
+
+insert into t1 values(10, 10)|
+set @a:=1/0|
+select 1/0 from t1|
+
+create trigger t1_bi before insert on t1 for each row set @a:=1/0|
+
+insert into t1 values(20, 20)|
+
+drop trigger t1_bi|
+create trigger t1_bi before insert on t1 for each row
+begin
+  insert into t2 values (new.id, new.v);
+  update t2 set v=v+1 where id= new.id;
+  replace t3 values (new.id, 0);
+  update t2, t3 set t2.v=new.v, t3.v=new.v where t2.id=t3.id;
+  create temporary table t5 select * from t1;
+  delete from t5;
+  insert into t5 select * from t1;
+  insert into t4 values (0);
+  set @check= (select count(*) from t5);
+  update t4 set c= @check;
+  drop temporary table t5;
+
+  set @a:=1/0;
+end|
+
+set @check=0, @t4_bi_called=0, @t4_bu_called=0|
+insert into t1 values(30, 30)|
+select @check, @t4_bi_called, @t4_bu_called|
+
+delimiter ;|
+
+SET @@sql_mode=@save_sql_mode;
+
+drop table t1;
+drop table t2;
+drop table t3;
+drop table t4;
 
 #
 # Bug#20670 "UPDATE using key and invoking trigger that modifies

mysql-test/t/view.test

@@ -23,8 +23,11 @@ create table t1 (a int, b int);
 insert into t1 values (1,2), (1,3), (2,4), (2,5), (3,10);
 
 # view with variable
--- error 1351
+-- error ER_VIEW_SELECT_VARIABLE
 create view v1 (c,d) as select a,b+@@global.max_user_connections from t1;
+-- error ER_VIEW_SELECT_VARIABLE
+create view v1 (c,d) as select a,b from t1
+  where a = @@global.max_user_connections;
 
 # simple view
 create view v1 (c) as select b+1 from t1;
@@ -486,19 +489,6 @@ drop view v1;
 -- error 1060
 create view v1 (a,a) as select 'a','a';
 
-#
-# SP variables inside view test
-#
---disable_warnings
-drop procedure if exists p1;
---enable_warnings
-delimiter //;
-create procedure p1 () begin declare v int; create view v1 as select v; end;//
-delimiter ;//
--- error 1351
-call p1();
-drop procedure p1;
-
 #
 # updatablity should be transitive
 #
@@ -820,6 +810,8 @@ create view v1 as select 5 into outfile 'ttt';
 create table t1 (a int);
 -- error 1350
 create view v1 as select a from t1 procedure analyse();
+-- error ER_VIEW_SELECT_DERIVED
+create view v1 as select 1 from (select 1) as d1;
 drop table t1;
 
 #
@@ -2886,6 +2878,38 @@ DROP VIEW v1;
 DROP TABLE t1, t2;
 
 #
+# Bug#19111: TRIGGERs selecting from a VIEW on the firing base table
+# fail
+#
+# Allow to select from a view on a table being modified in a trigger
+# and stored function, since plain select is allowed there.
+#
+--disable_warnings
+DROP FUNCTION IF EXISTS f1;
+DROP VIEW IF EXISTS v1;
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+
+CREATE TABLE t1 (i INT);
+INSERT INTO t1 VALUES (1);
+
+CREATE VIEW v1 AS SELECT MAX(i) FROM t1;
+
+# Plain 'SET NEW.i = (SELECT MAX(i) FROM t1) + 1' works, so select
+# from a view should work too.
+CREATE TRIGGER t1_bi BEFORE INSERT ON t1 FOR EACH ROW
+  SET NEW.i = (SELECT * FROM v1) + 1;
+INSERT INTO t1 VALUES (1);
+
+# Plain 'RETURN (SELECT MAX(i) FROM t1)' works in INSERT, so select
+# from a view should work too.
+CREATE FUNCTION f1() RETURNS INT RETURN (SELECT * FROM v1);
+UPDATE t1 SET i= f1();
+
+DROP FUNCTION f1;
+DROP VIEW v1;
+DROP TABLE t1;
+
 # Bug #16813 (WITH CHECK OPTION doesn't work with UPDATE)
 #
 CREATE TABLE t1(id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, val INT UNSIGNED NOT NULL);
@@ -2899,4 +2923,43 @@ UPDATE v1 SET val=6 WHERE id=2;
 DROP VIEW v1;
 DROP TABLE t1;
 
+
+#
+# BUG#22584: last_insert_id not updated after inserting a record
+# through a updatable view
+#
+# We still do not update LAST_INSERT_ID if AUTO_INCREMENT column is
+# not accessible through a view.  However, we do not reset the value
+# of LAST_INSERT_ID, but keep it unchanged.
+#
+--disable_warnings
+DROP VIEW IF EXISTS v1, v2;
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+
+CREATE TABLE t1 (i INT AUTO_INCREMENT PRIMARY KEY, j INT);
+CREATE VIEW v1 AS SELECT j FROM t1;
+CREATE VIEW v2 AS SELECT * FROM t1;
+
+INSERT INTO t1 (j) VALUES (1);
+SELECT LAST_INSERT_ID();
+
+INSERT INTO v1 (j) VALUES (2);
+--echo # LAST_INSERT_ID() should not change.
+SELECT LAST_INSERT_ID();
+
+INSERT INTO v2 (j) VALUES (3);
+--echo # LAST_INSERT_ID() should be updated.
+SELECT LAST_INSERT_ID();
+
+INSERT INTO v1 (j) SELECT j FROM t1;
+--echo # LAST_INSERT_ID() should not change.
+SELECT LAST_INSERT_ID();
+
+SELECT * FROM t1;
+
+DROP VIEW v1, v2;
+DROP TABLE t1;
+
+
 --echo End of 5.0 tests.

mysql-test/t/wait_for_socket.sh

@@ -0,0 +1,62 @@
+#!/bin/sh
+
+###########################################################################
+
+if [ $# -ne 6 ]; then
+  echo "Usage: wait_for_socket.sh <executable path> <socket path> <username> <password> <db> <timeout>"
+  exit 0
+fi
+
+client_exe="$1"
+socket_path="$2"
+username="$3"
+password="$4"
+db="$5"
+total_timeout="$6"
+
+###########################################################################
+
+if [ -z "$client_exe" ]; then
+  echo "Error: invalid path to client executable ($client_exe)."
+  exit 0;
+fi
+
+if [ ! -x "$client_exe" ]; then
+  echo "Error: client by path '$client_exe' is not available."
+  exit 0;
+fi
+
+if [ -z "$socket_path" ]; then
+  echo "Error: invalid socket patch."
+  exit 0
+fi
+
+###########################################################################
+
+client_args="--silent --socket=$socket_path "
+
+[ -n "$username" ] && client_args="$client_args --user=$username "
+[ -n "$password" ] && client_args="$client_args --password=$password "
+[ -n "$db" ] && client_args="$client_args $db"
+
+###########################################################################
+
+cur_attempt=1
+
+while true; do
+
+  if ( echo 'quit' | "$client_exe" $client_args >/dev/null 2>&1 ); then
+    echo "Success: server is ready to accept connection on socket."
+    exit 0
+  fi
+
+  [ $cur_attempt -ge $total_timeout ] && break
+
+  sleep 1
+
+  cur_attempt=`expr $cur_attempt + 1`
+
+done
+
+echo "Error: server does not accept connections after $total_timeout seconds."
+exit 0

server-tools/instance-manager/guardian.cc

@@ -74,7 +74,7 @@ Guardian_thread::Guardian_thread(Thread_registry &thread_registry_arg,
                                  uint monitoring_interval_arg) :
   Guardian_thread_args(thread_registry_arg, instance_map_arg,
                        monitoring_interval_arg),
-  thread_info(pthread_self()), guarded_instances(0)
+  thread_info(pthread_self(), TRUE), guarded_instances(0)
 {
   pthread_mutex_init(&LOCK_guardian, 0);
   pthread_cond_init(&COND_guardian, 0);
@@ -95,11 +95,11 @@ Guardian_thread::~Guardian_thread()
 }
 
 
-void Guardian_thread::request_shutdown(bool stop_instances_arg)
+void Guardian_thread::request_shutdown()
 {
   pthread_mutex_lock(&LOCK_guardian);
   /* stop instances or just clean up Guardian repository */
-  stop_instances(stop_instances_arg);
+  stop_instances();
   shutdown_requested= TRUE;
   pthread_mutex_unlock(&LOCK_guardian);
 }
@@ -154,11 +154,11 @@ void Guardian_thread::process_instance(Instance *instance,
     {
       /* Pid file not created yet, don't go to STARTED state yet  */
     }
-    else
+    else if (current_node->state != STARTED)
     {
       /* clear status fields */
-      log_info("guardian: instance %s is running, set state to STARTED",
+      log_info("guardian: instance '%s' is running, set state to STARTED.",
-               instance->options.instance_name);
+               (const char *) instance->options.instance_name.str);
       current_node->restart_counter= 0;
       current_node->crash_moment= 0;
       current_node->state= STARTED;
@@ -168,8 +168,8 @@ void Guardian_thread::process_instance(Instance *instance,
   {
     switch (current_node->state) {
     case NOT_STARTED:
-      log_info("guardian: starting instance %s",
+      log_info("guardian: starting instance '%s'...",
-               instance->options.instance_name);
+               (const char *) instance->options.instance_name.str);
 
       /* NOTE, set state to STARTING _before_ start() is called */
       current_node->state= STARTING;
@@ -193,8 +193,8 @@ void Guardian_thread::process_instance(Instance *instance,
         if (instance->is_crashed())
         {
           instance->start();
-          log_info("guardian: starting instance %s",
+          log_info("guardian: starting instance '%s'...",
-                   instance->options.instance_name);
+                   (const char *) instance->options.instance_name.str);
         }
       }
       else
@@ -211,14 +211,14 @@ void Guardian_thread::process_instance(Instance *instance,
             instance->start();
             current_node->last_checked= current_time;
             current_node->restart_counter++;
-            log_info("guardian: restarting instance %s",
+            log_info("guardian: restarting instance '%s'...",
-                     instance->options.instance_name);
+                     (const char *) instance->options.instance_name.str);
           }
         }
         else
         {
           log_info("guardian: cannot start instance %s. Abandoning attempts "
-                   "to (re)start it", instance->options.instance_name);
+                   "to (re)start it", instance->options.instance_name.str);
           current_node->state= CRASHED_AND_ABANDONED;
         }
       }
@@ -250,6 +250,8 @@ void Guardian_thread::run()
   LIST *node;
   struct timespec timeout;
 
+  log_info("Guardian: started.");
+
   thread_registry.register_thread(&thread_info);
 
   my_thread_init();
@@ -277,12 +279,16 @@ void Guardian_thread::run()
                                      &LOCK_guardian, &timeout);
   }
 
+  log_info("Guardian: stopped.");
+
   stopped= TRUE;
   pthread_mutex_unlock(&LOCK_guardian);
   /* now, when the Guardian is stopped we can stop the IM */
   thread_registry.unregister_thread(&thread_info);
   thread_registry.request_shutdown();
   my_thread_end();
+
+  log_info("Guardian: finished.");
 }
 
 
@@ -414,12 +420,11 @@ int Guardian_thread::stop_guard(Instance *instance)
 
   SYNOPSYS
     stop_instances()
-    stop_instances_arg          whether we should stop instances at shutdown
 
   DESCRIPTION
     Loops through the guarded_instances list and prepares them for shutdown.
-    If stop_instances was requested, we need to issue a stop command and change
+    For each instance we issue a stop command and change the state
-    the state accordingly. Otherwise we simply delete an entry.
+    accordingly.
 
   NOTE
     Guardian object should be locked by the calling function.
@@ -429,42 +434,29 @@ int Guardian_thread::stop_guard(Instance *instance)
     1 - error occured
 */
 
-int Guardian_thread::stop_instances(bool stop_instances_arg)
+int Guardian_thread::stop_instances()
 {
   LIST *node;
   node= guarded_instances;
   while (node != NULL)
   {
-    if (!stop_instances_arg)
+    GUARD_NODE *current_node= (GUARD_NODE *) node->data;
+    /*
+      If instance is running or was running (and now probably hanging),
+      request stop.
+    */
+    if (current_node->instance->is_running() ||
+        (current_node->state == STARTED))
     {
-      /* just forget about an instance */
+      current_node->state= STOPPING;
-      guarded_instances= list_delete(guarded_instances, node);
+      current_node->last_checked= time(NULL);
-      /*
-        This should still work fine, as we have only removed the
-        node from the list. The pointer to the next one is still valid
-      */
-      node= node->next;
     }
     else
-    {
+      /* otherwise remove it from the list */
-      GUARD_NODE *current_node= (GUARD_NODE *) node->data;
+      guarded_instances= list_delete(guarded_instances, node);
-      /*
+    /* But try to kill it anyway. Just in case */
-        If instance is running or was running (and now probably hanging),
+    current_node->instance->kill_instance(SIGTERM);
-        request stop.
+    node= node->next;
-      */
-      if (current_node->instance->is_running() ||
-          (current_node->state == STARTED))
-      {
-        current_node->state= STOPPING;
-        current_node->last_checked= time(NULL);
-      }
-      else
-        /* otherwise remove it from the list */
-        guarded_instances= list_delete(guarded_instances, node);
-      /* But try to kill it anyway. Just in case */
-      current_node->instance->kill_instance(SIGTERM);
-      node= node->next;
-    }
   }
   return 0;
 }

server-tools/instance-manager/guardian.h

@@ -91,7 +91,7 @@ public:
   /* Initialize or refresh the list of guarded instances */
   int init();
   /* Request guardian shutdown. Stop instances if needed */
-  void request_shutdown(bool stop_instances);
+  void request_shutdown();
   /* Start instance protection */
   int guard(Instance *instance, bool nolock= FALSE);
   /* Stop instance protection */
@@ -123,7 +123,7 @@ public:
 
 private:
   /* Prepares Guardian shutdown. Stops instances is needed */
-  int stop_instances(bool stop_instances_arg);
+  int stop_instances();
   /* check instance state and act accordingly */
   void process_instance(Instance *instance, GUARD_NODE *current_node,
                         LIST **guarded_instances, LIST *elem);

server-tools/instance-manager/instance.cc

@@ -34,6 +34,7 @@
 #include "mysql_manager_error.h"
 #include "portability.h"
 #include "priv.h"
+#include "thread_registry.h"
 
 
 const LEX_STRING
@@ -44,7 +45,8 @@ static const int INSTANCE_NAME_PREFIX_LEN= Instance::DFLT_INSTANCE_NAME.length;
 
 
 static void start_and_monitor_instance(Instance_options *old_instance_options,
-                                       Instance_map *instance_map);
+                                       Instance_map *instance_map,
+                                       Thread_registry *thread_registry);
 
 #ifndef __WIN__
 typedef pid_t My_process_info;
@@ -63,7 +65,8 @@ pthread_handler_t proxy(void *arg)
 {
   Instance *instance= (Instance *) arg;
   start_and_monitor_instance(&instance->options,
-                             instance->get_map());
+                             instance->get_map(),
+                             &instance->thread_registry);
   return 0;
 }
 
@@ -99,6 +102,7 @@ static int wait_process(My_process_info *pi)
     thread, but we don't know this one). Or we could use waitpid(), but
     couldn't use wait(), because it could return in any wait() in the program.
   */
+
   if (linuxthreads)
     wait(NULL);                               /* LinuxThreads were detected */
   else
@@ -165,8 +169,8 @@ static int start_process(Instance_options *instance_options,
     /* exec never returns */
     exit(1);
   case -1:
-    log_info("cannot create a new process to start instance %s",
+    log_info("cannot create a new process to start instance '%s'.",
-             instance_options->instance_name);
+             (const char *) instance_options->instance_name.str);
     return 1;
   }
   return 0;
@@ -239,11 +243,28 @@ static int start_process(Instance_options *instance_options,
 */
 
 static void start_and_monitor_instance(Instance_options *old_instance_options,
-                                       Instance_map *instance_map)
+                                       Instance_map *instance_map,
+                                       Thread_registry *thread_registry)
 {
   Instance_name instance_name(&old_instance_options->instance_name);
   Instance *current_instance;
   My_process_info process_info;
+  Thread_info thread_info(pthread_self(), FALSE);
+
+  log_info("Monitoring thread (instance: '%s'): started.",
+           (const char *) instance_name.get_c_str());
+
+  if (!old_instance_options->nonguarded)
+  {
+    /*
+      Register thread in Thread_registry to wait for it to stop on shutdown
+      only if instance is nuarded. If instance is guarded, the thread will not
+      finish, because nonguarded instances are not stopped on shutdown.
+    */
+
+    thread_registry->register_thread(&thread_info);
+    my_thread_init();
+  }
 
   /*
     Lock instance map to guarantee that no instances are deleted during
@@ -256,7 +277,8 @@ static void start_and_monitor_instance(Instance_options *old_instance_options,
     are using is destroyed. (E.g. by "FLUSH INSTANCES")
   */
 
-  log_info("starting instance %s", (const char *) instance_name.get_c_str());
+  log_info("starting instance %s...",
+           (const char *) instance_name.get_c_str());
 
   if (start_process(old_instance_options, &process_info))
   {
@@ -279,7 +301,14 @@ static void start_and_monitor_instance(Instance_options *old_instance_options,
 
   instance_map->unlock();
 
-  return;
+  if (!old_instance_options->nonguarded)
+  {
+    thread_registry->unregister_thread(&thread_info);
+    my_thread_end();
+  }
+
+  log_info("Monitoring thread (instance: '%s'): finished.",
+           (const char *) instance_name.get_c_str());
 }
 
 
@@ -311,9 +340,9 @@ void Instance::remove_pid()
   int pid;
   if ((pid= options.get_pid()) != 0)          /* check the pidfile */
     if (options.unlink_pidfile())             /* remove stalled pidfile */
-      log_error("cannot remove pidfile for instance %i, this might be \
+      log_error("cannot remove pidfile for instance '%s', this might be "
-                since IM lacks permmissions or hasn't found the pidifle",
+                "since IM lacks permmissions or hasn't found the pidifle",
-                options.instance_name);
+                (const char *) options.instance_name.str);
 }
 
 
@@ -342,10 +371,6 @@ int Instance::start()
   {
     remove_pid();
 
-    /*
-      No need to monitor this thread in the Thread_registry, as all
-      instances are to be stopped during shutdown.
-    */
     pthread_t proxy_thd_id;
     pthread_attr_t proxy_thd_attr;
     int rc;
@@ -403,7 +428,8 @@ void Instance::set_crash_flag_n_wake_all()
 
 
 
-Instance::Instance(): crashed(FALSE), configured(FALSE)
+Instance::Instance(Thread_registry &thread_registry_arg):
+  crashed(FALSE), configured(FALSE), thread_registry(thread_registry_arg)
 {
   pthread_mutex_init(&LOCK_instance, 0);
   pthread_cond_init(&COND_instance_stopped, 0);
@@ -467,9 +493,9 @@ bool Instance::is_running()
       We have successfully connected to the server using fake
       username/password. Write a warning to the logfile.
     */
-    log_info("The Instance Manager was able to log into you server \
+    log_info("The Instance Manager was able to log into you server "
-             with faked compiled-in password while checking server status. \
+             "with faked compiled-in password while checking server status. "
-             Looks like something is wrong.");
+             "Looks like something is wrong.");
     pthread_mutex_unlock(&LOCK_instance);
     return_val= TRUE;                           /* server is alive */
   }
@@ -616,10 +642,10 @@ void Instance::kill_instance(int signum)
       /* Kill suceeded */
       if (signum == SIGKILL)      /* really killed instance with SIGKILL */
       {
-        log_error("The instance %s is being stopped forcibly. Normally" \
+        log_error("The instance '%s' is being stopped forcibly. Normally"
-                  "it should not happen. Probably the instance has been" \
+                  "it should not happen. Probably the instance has been"
                   "hanging. You should also check your IM setup",
-                  options.instance_name);
+                  (const char *) options.instance_name.str);
         /* After sucessful hard kill the pidfile need to be removed */
         options.unlink_pidfile();
       }

server-tools/instance-manager/instance.h

@@ -27,6 +27,7 @@
 #endif
 
 class Instance_map;
+class Thread_registry;
 
 
 /*
@@ -87,7 +88,7 @@ public:
   static bool is_mysqld_compatible_name(const LEX_STRING *name);
 
 public:
-  Instance();
+  Instance(Thread_registry &thread_registry_arg);
 
   ~Instance();
   int init(const LEX_STRING *name_arg);
@@ -120,6 +121,7 @@ public:
 public:
   enum { DEFAULT_SHUTDOWN_DELAY= 35 };
   Instance_options options;
+  Thread_registry &thread_registry;
 
 private:
   /* This attributes is a flag, specifies if the instance has been crashed. */

server-tools/instance-manager/instance_map.cc

@@ -169,7 +169,7 @@ int Instance_map::process_one_option(const LEX_STRING *group,
   if (!(instance= (Instance *) hash_search(&hash, (byte *) group->str,
                                            group->length)))
   {
-    if (!(instance= new Instance()))
+    if (!(instance= new Instance(thread_registry)))
       return 1;
 
     if (instance->init(group) || add_instance(instance))
@@ -213,8 +213,10 @@ int Instance_map::process_one_option(const LEX_STRING *group,
 }
 
 
-Instance_map::Instance_map(const char *default_mysqld_path_arg):
+Instance_map::Instance_map(const char *default_mysqld_path_arg,
-mysqld_path(default_mysqld_path_arg)
+                           Thread_registry &thread_registry_arg):
+  mysqld_path(default_mysqld_path_arg),
+  thread_registry(thread_registry_arg)
 {
   pthread_mutex_init(&LOCK_instance_map, 0);
 }
@@ -293,7 +295,9 @@ int Instance_map::flush_instances()
             get_instance_key, delete_instance, 0);
 
   rc= load();
-  guardian->init(); // TODO: check error status.
+  /* don't init guardian if we failed to load instances */
+  if (!rc)
+    guardian->init(); // TODO: check error status.
   return rc;
 }
 
@@ -331,7 +335,7 @@ int Instance_map::remove_instance(Instance *instance)
 int Instance_map::create_instance(const LEX_STRING *instance_name,
                                   const Named_value_arr *options)
 {
-  Instance *instance= new Instance();
+  Instance *instance= new Instance(thread_registry);
 
   if (!instance)
   {

server-tools/instance-manager/instance_map.h

@@ -28,6 +28,7 @@
 class Guardian_thread;
 class Instance;
 class Named_value_arr;
+class Thread_registry;
 
 extern int load_all_groups(char ***groups, const char *filename);
 extern void free_groups(char **groups);
@@ -104,7 +105,8 @@ public:
   int create_instance(const LEX_STRING *instance_name,
                       const Named_value_arr *options);
 
-  Instance_map(const char *default_mysqld_path_arg);
+  Instance_map(const char *default_mysqld_path_arg,
+               Thread_registry &thread_registry_arg);
   ~Instance_map();
 
   /*
@@ -130,6 +132,8 @@ private:
   enum { START_HASH_SIZE = 16 };
   pthread_mutex_t LOCK_instance_map;
   HASH hash;
+
+  Thread_registry &thread_registry;
 };
 
 #endif /* INCLUDES_MYSQL_INSTANCE_MANAGER_INSTANCE_MAP_H */

server-tools/instance-manager/listener.cc

@@ -87,7 +87,7 @@ private:
 Listener_thread::Listener_thread(const Listener_thread_args &args) :
   Listener_thread_args(args.thread_registry, args.user_map, args.instance_map)
   ,total_connection_count(0)
-  ,thread_info(pthread_self())
+  ,thread_info(pthread_self(), TRUE)
   ,num_sockets(0)
 {
 }
@@ -112,6 +112,8 @@ void Listener_thread::run()
 {
   int i, n= 0;
 
+  log_info("Listener_thread: started.");
+
 #ifndef __WIN__
   /* we use this var to check whether we are running on LinuxThreads */
   pid_t thread_pid;
@@ -164,7 +166,7 @@ void Listener_thread::run()
     if (rc == 0 || rc == -1)
     {
       if (rc == -1 && errno != EINTR)
-        log_error("Listener_thread::run(): select() failed, %s",
+        log_error("Listener_thread: select() failed, %s",
                   strerror(errno));
       continue;
     }
@@ -198,7 +200,7 @@ void Listener_thread::run()
 
   /* III. Release all resources and exit */
 
-  log_info("Listener_thread::run(): shutdown requested, exiting...");
+  log_info("Listener_thread: shutdown requested, exiting...");
 
   for (i= 0; i < num_sockets; i++)
     close(sockets[i]);
@@ -209,6 +211,8 @@ void Listener_thread::run()
 
   thread_registry.unregister_thread(&thread_info);
   my_thread_end();
+
+  log_info("Listener_thread: finished.");
   return;
 
 err:
@@ -230,7 +234,7 @@ int Listener_thread::create_tcp_socket()
   int ip_socket= socket(AF_INET, SOCK_STREAM, 0);
   if (ip_socket == INVALID_SOCKET)
   {
-    log_error("Listener_thead::run(): socket(AF_INET) failed, %s",
+    log_error("Listener_thead: socket(AF_INET) failed, %s",
               strerror(errno));
     return -1;
   }
@@ -261,7 +265,7 @@ int Listener_thread::create_tcp_socket()
   if (bind(ip_socket, (struct sockaddr *) &ip_socket_address,
            sizeof(ip_socket_address)))
   {
-    log_error("Listener_thread::run(): bind(ip socket) failed, '%s'",
+    log_error("Listener_thread: bind(ip socket) failed, '%s'",
               strerror(errno));
     close(ip_socket);
     return -1;
@@ -269,7 +273,7 @@ int Listener_thread::create_tcp_socket()
 
   if (listen(ip_socket, LISTEN_BACK_LOG_SIZE))
   {
-    log_error("Listener_thread::run(): listen(ip socket) failed, %s",
+    log_error("Listener_thread: listen(ip socket) failed, %s",
               strerror(errno));
     close(ip_socket);
     return -1;
@@ -283,7 +287,7 @@ int Listener_thread::create_tcp_socket()
 
   FD_SET(ip_socket, &read_fds);
   sockets[num_sockets++]= ip_socket;
-  log_info("accepting connections on ip socket");
+  log_info("accepting connections on ip socket (port: %d)", (int) im_port);
   return 0;
 }
 
@@ -294,7 +298,7 @@ create_unix_socket(struct sockaddr_un &unix_socket_address)
   int unix_socket= socket(AF_UNIX, SOCK_STREAM, 0);
   if (unix_socket == INVALID_SOCKET)
   {
-    log_error("Listener_thead::run(): socket(AF_UNIX) failed, %s",
+    log_error("Listener_thead: socket(AF_UNIX) failed, %s",
               strerror(errno));
     return -1;
   }
@@ -314,7 +318,7 @@ create_unix_socket(struct sockaddr_un &unix_socket_address)
   if (bind(unix_socket, (struct sockaddr *) &unix_socket_address,
            sizeof(unix_socket_address)))
   {
-    log_error("Listener_thread::run(): bind(unix socket) failed, "
+    log_error("Listener_thread: bind(unix socket) failed, "
               "socket file name is '%s', error '%s'",
               unix_socket_address.sun_path, strerror(errno));
     close(unix_socket);
@@ -325,7 +329,7 @@ create_unix_socket(struct sockaddr_un &unix_socket_address)
 
   if (listen(unix_socket, LISTEN_BACK_LOG_SIZE))
   {
-    log_error("Listener_thread::run(): listen(unix socket) failed, %s",
+    log_error("Listener_thread: listen(unix socket) failed, %s",
               strerror(errno));
     close(unix_socket);
     return -1;
@@ -337,7 +341,7 @@ create_unix_socket(struct sockaddr_un &unix_socket_address)
   /* make sure that instances won't be listening our sockets */
   set_no_inherit(unix_socket);
 
-  log_info("accepting connections on unix socket %s",
+  log_info("accepting connections on unix socket '%s'",
            unix_socket_address.sun_path);
   sockets[num_sockets++]= unix_socket;
   FD_SET(unix_socket, &read_fds);

server-tools/instance-manager/log.cc

@@ -52,14 +52,16 @@ static inline void log(FILE *file,  const char *format, va_list args)
   struct tm bd_time;                            // broken-down time
   localtime_r(&now, &bd_time);
 
-  char buff_date[32];
+  char buff_date[128];
-  sprintf(buff_date, "%02d%02d%02d %2d:%02d:%02d\t",
+  sprintf(buff_date, "[%d/%lu] [%02d/%02d/%02d %02d:%02d:%02d] ",
-                            bd_time.tm_year % 100,
+          (int) getpid(),
-                            bd_time.tm_mon + 1,
+          (unsigned long) pthread_self(),
-                            bd_time.tm_mday,
+          bd_time.tm_year % 100,
-                            bd_time.tm_hour,
+          bd_time.tm_mon + 1,
-                            bd_time.tm_min,
+          bd_time.tm_mday,
-                            bd_time.tm_sec);
+          bd_time.tm_hour,
+          bd_time.tm_min,
+          bd_time.tm_sec);
   /* Format the message */
   char buff_stack[256];
 

server-tools/instance-manager/manager.cc

@@ -120,6 +120,19 @@ int my_sigwait(const sigset_t *set, int *sig)
 #endif
 
 
+void stop_all(Guardian_thread *guardian, Thread_registry *registry)
+{
+  /*
+    Let guardian thread know that it should break it's processing cycle,
+    once it wakes up.
+  */
+  guardian->request_shutdown();
+  /* wake guardian */
+  pthread_cond_signal(&guardian->COND_guardian);
+  /* stop all threads */
+  registry->deliver_shutdown();
+}
+
 /*
   manager - entry point to the main instance manager process: start
   listener thread, write pid file and enter into signal handling.
@@ -143,7 +156,8 @@ void manager()
   */
 
   User_map user_map;
-  Instance_map instance_map(Options::Main::default_mysqld_path);
+  Instance_map instance_map(Options::Main::default_mysqld_path,
+                            thread_registry);
   Guardian_thread guardian_thread(thread_registry,
                                   &instance_map,
                                   Options::Main::monitoring_interval);
@@ -251,7 +265,6 @@ void manager()
 
   /* Load instances. */
 
-
   {
     instance_map.guardian->lock();
     instance_map.lock();
@@ -266,7 +279,8 @@ void manager()
       log_error("Cannot init instances repository. This might be caused by "
         "the wrong config file options. For instance, missing mysqld "
         "binary. Aborting.");
-      return;
+      stop_all(&guardian_thread, &thread_registry);
+      goto err;
     }
   }
 
@@ -284,6 +298,7 @@ void manager()
     if (rc)
     {
       log_error("manager(): set_stacksize_n_create_thread(listener) failed");
+      stop_all(&guardian_thread, &thread_registry);
       goto err;
     }
   }
@@ -294,6 +309,8 @@ void manager()
   */
   pthread_cond_signal(&guardian_thread.COND_guardian);
 
+  log_info("Main loop: started.");
+
   while (!shutdown_complete)
   {
     int signo;
@@ -302,9 +319,24 @@ void manager()
     if ((status= my_sigwait(&mask, &signo)) != 0)
     {
       log_error("sigwait() failed");
+      stop_all(&guardian_thread, &thread_registry);
       goto err;
     }
 
+    /*
+      The general idea in this loop is the following:
+        - we are waiting for SIGINT, SIGTERM -- signals that mean we should
+          shutdown;
+        - as shutdown signal is caught, we stop Guardian thread (by calling
+          Guardian_thread::request_shutdown());
+        - as Guardian_thread is stopped, it sends SIGTERM to this thread
+          (by calling Thread_registry::request_shutdown()), so that the
+          my_sigwait() above returns;
+        - as we catch the second SIGTERM, we send signals to all threads
+          registered in Thread_registry (by calling
+          Thread_registry::deliver_shutdown()) and waiting for threads to stop;
+    */
+
 #ifndef __WIN__
 /*
   On some Darwin kernels SIGHUP is delivered along with most
@@ -321,10 +353,11 @@ void manager()
     else
 #endif
     {
+      log_info("Main loop: got shutdown signal.");
+
       if (!guardian_thread.is_stopped())
       {
-        bool stop_instances= TRUE;
+        guardian_thread.request_shutdown();
-        guardian_thread.request_shutdown(stop_instances);
         pthread_cond_signal(&guardian_thread.COND_guardian);
       }
       else
@@ -335,6 +368,8 @@ void manager()
     }
   }
 
+  log_info("Main loop: finished.");
+
 err:
   /* delete the pid file */
   my_delete(Options::Main::pid_file_name, MYF(0));

server-tools/instance-manager/mysql_connection.cc

@@ -97,7 +97,7 @@ Mysql_connection_thread::Mysql_connection_thread(
                                args.user_map,
                                args.connection_id,
                                args.instance_map)
-  ,thread_info(pthread_self())
+  ,thread_info(pthread_self(), TRUE)
 {
   thread_registry.register_thread(&thread_info);
 }
@@ -165,7 +165,7 @@ Mysql_connection_thread::~Mysql_connection_thread()
 
 void Mysql_connection_thread::run()
 {
-  log_info("accepted mysql connection %d", connection_id);
+  log_info("accepted mysql connection %d", (int) connection_id);
 
   my_thread_init();
 
@@ -175,7 +175,7 @@ void Mysql_connection_thread::run()
     return;
   }
 
-  log_info("connection %d is checked successfully", connection_id);
+  log_info("connection %d is checked successfully", (int) connection_id);
 
   vio_keepalive(vio, TRUE);
 
@@ -315,7 +315,7 @@ int Mysql_connection_thread::do_command()
     enum enum_server_command command= (enum enum_server_command)
                                       (uchar) *packet;
     log_info("connection %d: packet_length=%d, command=%d",
-             connection_id, packet_length, command);
+             (int) connection_id, (int) packet_length, (int) command);
     return dispatch_command(command, packet + 1, packet_length - 1);
   }
 }
@@ -325,27 +325,33 @@ int Mysql_connection_thread::dispatch_command(enum enum_server_command command,
 {
   switch (command) {
   case COM_QUIT:                                // client exit
-    log_info("query for connection %d received quit command", connection_id);
+    log_info("query for connection %d received quit command",
+             (int) connection_id);
     return 1;
   case COM_PING:
-    log_info("query for connection %d received ping command", connection_id);
+    log_info("query for connection %d received ping command",
+             (int) connection_id);
     net_send_ok(&net, connection_id, NULL);
     break;
   case COM_QUERY:
   {
     log_info("query for connection %d : ----\n%s\n-------------------------",
-	     connection_id,packet);
+	     (int) connection_id,
+             (const char *) packet);
     if (Command *command= parse_command(&instance_map, packet))
     {
       int res= 0;
-      log_info("query for connection %d successfully parsed",connection_id);
+      log_info("query for connection %d successfully parsed",
+               (int) connection_id);
       res= command->execute(&net, connection_id);
       delete command;
       if (!res)
-        log_info("query for connection %d executed ok",connection_id);
+        log_info("query for connection %d executed ok",
+                 (int) connection_id);
       else
       {
-        log_info("query for connection %d executed err=%d",connection_id,res);
+        log_info("query for connection %d executed err=%d",
+                 (int) connection_id, (int) res);
         net_send_error(&net, res);
         return 0;
       }
@@ -358,7 +364,8 @@ int Mysql_connection_thread::dispatch_command(enum enum_server_command command,
     break;
   }
   default:
-    log_info("query for connection %d received unknown command",connection_id);
+    log_info("query for connection %d received unknown command",
+             (int) connection_id);
     net_send_error(&net, ER_UNKNOWN_COM_ERROR);
     break;
   }

server-tools/instance-manager/options.cc

@@ -41,7 +41,6 @@
 static char win_dflt_config_file_name[FN_REFLEN];
 static char win_dflt_password_file_name[FN_REFLEN];
 static char win_dflt_pid_file_name[FN_REFLEN];
-static char win_dflt_socket_file_name[FN_REFLEN];
 
 static char win_dflt_mysqld_path[FN_REFLEN];
 
@@ -54,7 +53,6 @@ my_bool Options::Service::stand_alone;
 const char *Options::Main::config_file= win_dflt_config_file_name;
 const char *Options::Main::password_file_name= win_dflt_password_file_name;
 const char *Options::Main::pid_file_name= win_dflt_pid_file_name;
-const char *Options::Main::socket_file_name= win_dflt_socket_file_name;
 
 const char *Options::Main::default_mysqld_path= win_dflt_mysqld_path;
 
@@ -262,10 +260,12 @@ static struct my_option my_long_options[] =
     0, 0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 0, 0 },
 #endif
 
+#ifndef __WIN__
   { "socket", OPT_SOCKET, "Socket file to use for connection.",
     (gptr *) &Options::Main::socket_file_name,
     (gptr *) &Options::Main::socket_file_name,
     0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
+#endif
 
 #ifdef __WIN__
   { "standalone", OPT_STAND_ALONE, "Run the application in stand alone mode.",
@@ -550,8 +550,6 @@ static int setup_windows_defaults()
   strxmov(win_dflt_password_file_name, dir_name, im_name, DFLT_PASSWD_FILE_EXT,
           NullS);
   strxmov(win_dflt_pid_file_name, dir_name, im_name, DFLT_PID_FILE_EXT, NullS);
-  strxmov(win_dflt_socket_file_name, dir_name, im_name, DFLT_SOCKET_FILE_EXT,
-          NullS);
 
   return 0;
 }

server-tools/instance-manager/options.h

@@ -50,7 +50,9 @@ struct Options
     static bool is_forced_default_file;
 
     static const char *pid_file_name;
+#ifndef __WIN__
     static const char *socket_file_name;
+#endif
     static const char *password_file_name;
     static const char *default_mysqld_path;
     static uint monitoring_interval;

server-tools/instance-manager/thread_registry.cc

@@ -43,8 +43,10 @@ static void handle_signal(int __attribute__((unused)) sig_no)
 */
 
 Thread_info::Thread_info() {}
-Thread_info::Thread_info(pthread_t thread_id_arg) :
+Thread_info::Thread_info(pthread_t thread_id_arg,
-  thread_id(thread_id_arg) {}
+                         bool send_signal_on_shutdown_arg) :
+  thread_id(thread_id_arg),
+  send_signal_on_shutdown(send_signal_on_shutdown_arg) {}
 
 /*
   TODO: think about moving signal information (now it's shutdown_in_progress)
@@ -86,6 +88,9 @@ Thread_registry::~Thread_registry()
 
 void Thread_registry::register_thread(Thread_info *info)
 {
+  log_info("Thread_registry: registering thread %d...",
+           (int) info->thread_id);
+
 #ifndef __WIN__
   struct sigaction sa;
   sa.sa_handler= handle_signal;
@@ -112,11 +117,19 @@ void Thread_registry::register_thread(Thread_info *info)
 
 void Thread_registry::unregister_thread(Thread_info *info)
 {
+  log_info("Thread_registry: unregistering thread %d...",
+           (int) info->thread_id);
+
   pthread_mutex_lock(&LOCK_thread_registry);
   info->prev->next= info->next;
   info->next->prev= info->prev;
+
   if (head.next == &head)
+  {
+    log_info("Thread_registry: thread registry is empty!");
     pthread_cond_signal(&COND_thread_registry_is_empty);
+  }
+
   pthread_mutex_unlock(&LOCK_thread_registry);
 }
 
@@ -181,11 +194,6 @@ int Thread_registry::cond_timedwait(Thread_info *info, pthread_cond_t *cond,
 
 void Thread_registry::deliver_shutdown()
 {
-  Thread_info *info;
-  struct timespec shutdown_time;
-  int error;
-  set_timespec(shutdown_time, 1);
-
   pthread_mutex_lock(&LOCK_thread_registry);
   shutdown_in_progress= TRUE;
 
@@ -199,29 +207,14 @@ void Thread_registry::deliver_shutdown()
   process_alarm(THR_SERVER_ALARM);
 #endif
 
-  for (info= head.next; info != &head; info= info->next)
-  {
-    pthread_kill(info->thread_id, THREAD_KICK_OFF_SIGNAL);
-    /*
-      sic: race condition here, the thread may not yet fall into
-      pthread_cond_wait.
-    */
-    if (info->current_cond)
-      pthread_cond_signal(info->current_cond);
-  }
   /*
-    The common practice is to test predicate before pthread_cond_wait.
+    sic: race condition here, the thread may not yet fall into
-    I don't do that here because the predicate is practically always false
+    pthread_cond_wait.
-    before wait - is_shutdown's been just set, and the lock's still not
-    released - the only case when the predicate is false is when no other
-    threads exist.
   */
-  while (((error= pthread_cond_timedwait(&COND_thread_registry_is_empty,
+
-                                          &LOCK_thread_registry,
+  interrupt_threads();
-                                          &shutdown_time)) != ETIMEDOUT &&
+
-          error != ETIME) &&
+  wait_for_threads_to_unregister();
-         head.next != &head)
-    ;
 
   /*
     If previous signals did not reach some threads, they must be sleeping
@@ -230,11 +223,28 @@ void Thread_registry::deliver_shutdown()
     so this time everybody should be informed (presumably each worker can
     get CPU during shutdown_time.)
   */
-  for (info= head.next; info != &head; info= info->next)
+
+  interrupt_threads();
+
+  /* Get the last chance to threads to stop. */
+
+  wait_for_threads_to_unregister();
+
+  /*
+    Print out threads, that didn't stopped. Thread_registry destructor will
+    probably abort the program if there is still any alive thread.
+  */
+
+  if (head.next != &head)
   {
-    pthread_kill(info->thread_id, THREAD_KICK_OFF_SIGNAL);
+    log_info("Thread_registry: non-stopped threads:");
-    if (info->current_cond)
+
-      pthread_cond_signal(info->current_cond);
+    for (Thread_info *info= head.next; info != &head; info= info->next)
+      log_info("  - %ld", (long int) info->thread_id);
+  }
+  else
+  {
+    log_info("Thread_registry: all threads stopped.");
   }
 
   pthread_mutex_unlock(&LOCK_thread_registry);
@@ -245,3 +255,46 @@ void Thread_registry::request_shutdown()
 {
   pthread_kill(sigwait_thread_pid, SIGTERM);
 }
+
+
+void Thread_registry::interrupt_threads()
+{
+  for (Thread_info *info= head.next; info != &head; info= info->next)
+  {
+    if (!info->send_signal_on_shutdown)
+      continue;
+
+    pthread_kill(info->thread_id, THREAD_KICK_OFF_SIGNAL);
+    if (info->current_cond)
+      pthread_cond_signal(info->current_cond);
+  }
+}
+
+
+void Thread_registry::wait_for_threads_to_unregister()
+{
+  struct timespec shutdown_time;
+
+  set_timespec(shutdown_time, 1);
+
+  log_info("Thread_registry: joining threads...");
+
+  while (true)
+  {
+    if (head.next == &head)
+    {
+      log_info("Thread_registry: emptied.");
+      return;
+    }
+
+    int error= pthread_cond_timedwait(&COND_thread_registry_is_empty,
+                                      &LOCK_thread_registry,
+                                      &shutdown_time);
+
+    if (error == ETIMEDOUT || error == ETIME)
+    {
+      log_info("Thread_registry: threads shutdown timed out.");
+      return;
+    }
+  }
+}

server-tools/instance-manager/thread_registry.h

@@ -67,13 +67,17 @@
 class Thread_info
 {
 public:
-  Thread_info();
+  Thread_info(pthread_t thread_id_arg, bool send_signal_on_shutdown_arg);
-  Thread_info(pthread_t thread_id_arg);
   friend class Thread_registry;
+
+private:
+  Thread_info();
+
 private:
   pthread_cond_t *current_cond;
   Thread_info *prev, *next;
   pthread_t thread_id;
+  bool send_signal_on_shutdown;
 };
 
 
@@ -97,6 +101,10 @@ public:
                  pthread_mutex_t *mutex);
   int cond_timedwait(Thread_info *info, pthread_cond_t *cond,
                      pthread_mutex_t *mutex, struct timespec *wait_time);
+private:
+  void interrupt_threads();
+  void wait_for_threads_to_unregister();
+
 private:
   Thread_info head;
   bool shutdown_in_progress;

sql/event_data_objects.cc

@@ -886,14 +886,29 @@ Event_queue_element::load_from_row(TABLE *table)
     goto error;
 
   /*
-    In DB the values start from 1 but enum interval_type starts
+    We load the interval type from disk as string and then map it to
-    from 0
+    an integer. This decouples the values of enum interval_type
+    and values actually stored on disk. Therefore the type can be
+    reordered without risking incompatibilities of data between versions.
   */
   if (!table->field[ET_FIELD_TRANSIENT_INTERVAL]->is_null())
-    interval= (interval_type) ((ulonglong)
+  {
-          table->field[ET_FIELD_TRANSIENT_INTERVAL]->val_int() - 1);
+    int i;
-  else
+    char buff[MAX_FIELD_WIDTH];
-    interval= (interval_type) 0;
+    String str(buff, sizeof(buff), &my_charset_bin);
+    LEX_STRING tmp;
+
+    table->field[ET_FIELD_TRANSIENT_INTERVAL]->val_str(&str);
+    if (!(tmp.length= str.length()))
+      goto error;
+
+    tmp.str= str.c_ptr_safe();
+
+    i= find_string_in_array(interval_type_to_name, &tmp, system_charset_info);
+    if (i < 0)
+      goto error;
+    interval= (interval_type) i;
+  }
 
   table->field[ET_FIELD_LAST_EXECUTED]->get_date(&last_executed,
                                                  TIME_NO_ZERO_DATE);

sql/event_db_repository.cc

@@ -188,11 +188,11 @@ mysql_event_fill_row(THD *thd, TABLE *table, Event_parse_data *et,
     fields[ET_FIELD_INTERVAL_EXPR]->store((longlong)et->expression, TRUE);
 
     fields[ET_FIELD_TRANSIENT_INTERVAL]->set_notnull();
-    /*
+
-      In the enum (C) intervals start from 0 but in mysql enum valid values
+    fields[ET_FIELD_TRANSIENT_INTERVAL]->
-      start from 1. Thus +1 offset is needed!
+                            store(interval_type_to_name[et->interval].str,
-    */
+                                  interval_type_to_name[et->interval].length,
-    fields[ET_FIELD_TRANSIENT_INTERVAL]->store((longlong)et->interval+1, TRUE);
+                                  scs);
 
     fields[ET_FIELD_EXECUTE_AT]->set_null();
 

sql/handler.cc

@@ -1483,8 +1483,9 @@ bool handler::check_if_log_table_locking_is_allowed(uint sql_command,
 {
   /*
     Deny locking of the log tables, which is incompatible with
-    concurrent insert. Unless called from a logger THD:
+    concurrent insert. The routine is not called if the table is
-    general_log_thd or slow_log_thd.
+    being locked from a logger THD (general_log_thd or slow_log_thd)
+    or from a privileged thread (see log.cc for details)
   */
   if (table->s->log_table &&
       sql_command != SQLCOM_TRUNCATE &&

sql/handler.h

@@ -975,6 +975,10 @@ public:
         thd     Handler of the thread, trying to lock the table
         table   Table handler to check
         count   Number of locks already granted to the table
+        called_by_privileged_thread TRUE if called from a logger THD
+                                    (general_log_thd or slow_log_thd)
+                                    or by a privileged thread, which
+                                    has the right to lock log tables.
 
     DESCRIPTION
       Check whether a handler allows to lock the table. For instance,
@@ -990,7 +994,7 @@ public:
   virtual bool check_if_locking_is_allowed(uint sql_command,
                                            ulong type, TABLE *table,
                                            uint count,
-                                           bool called_by_logger_thread)
+                                           bool called_by_privileged_thread)
   {
     return TRUE;
   }

sql/item_sum.cc

@@ -1065,6 +1065,7 @@ longlong Item_sum_count::val_int()
 void Item_sum_count::cleanup()
 {
   DBUG_ENTER("Item_sum_count::cleanup");
+  count= 0;
   Item_sum_int::cleanup();
   used_table_cache= ~(table_map) 0;
   DBUG_VOID_RETURN;

sql/item_sum.h

@@ -260,9 +260,30 @@ public:
   Item_sum(THD *thd, Item_sum *item);
   enum Type type() const { return SUM_FUNC_ITEM; }
   virtual enum Sumfunctype sum_func () const=0;
+
+  /*
+    This method is similar to add(), but it is called when the current
+    aggregation group changes. Thus it performs a combination of
+    clear() and add().
+  */
   inline bool reset() { clear(); return add(); };
+
+  /*
+    Prepare this item for evaluation of an aggregate value. This is
+    called by reset() when a group changes, or, for correlated
+    subqueries, between subquery executions.  E.g. for COUNT(), this
+    method should set count= 0;
+  */
   virtual void clear()= 0;
+
+  /*
+    This method is called for the next row in the same group. Its
+    purpose is to aggregate the new value to the previous values in
+    the group (i.e. since clear() was called last time). For example,
+    for COUNT(), do count++.
+  */
   virtual bool add()=0;
+
   /*
     Called when new group is started and results are being saved in
     a temporary table. Similar to reset(), but must also store value in
@@ -306,7 +327,17 @@ public:
   void make_field(Send_field *field);
   void print(String *str);
   void fix_num_length_and_dec();
-  void no_rows_in_result() { reset(); }
+
+  /*
+    This function is called by the execution engine to assign 'NO ROWS
+    FOUND' value to an aggregate item, when the underlying result set
+    has no rows. Such value, in a general case, may be different from
+    the default value of the item after 'clear()': e.g. a numeric item
+    may be initialized to 0 by clear() and to NULL by
+    no_rows_in_result().
+  */
+  void no_rows_in_result() { clear(); }
+
   virtual bool setup(THD *thd) {return 0;}
   virtual void make_unique() {}
   Item *get_tmp_table_item(THD *thd);
@@ -610,6 +641,11 @@ public:
   const char *func_name() const { return "avg("; }
   Item *copy_or_same(THD* thd);
   Field *create_tmp_field(bool group, TABLE *table, uint convert_blob_length);
+  void cleanup()
+  {
+    count= 0;
+    Item_sum_sum::cleanup();
+  }
 };
 
 class Item_sum_variance;
@@ -689,6 +725,12 @@ public:
   Item *copy_or_same(THD* thd);
   Field *create_tmp_field(bool group, TABLE *table, uint convert_blob_length);
   enum Item_result result_type () const { return REAL_RESULT; }
+  void cleanup()
+  {
+    cur_dec= 0;
+    count= 0;
+    Item_sum_num::cleanup();
+  }
 };
 
 class Item_sum_std;
@@ -819,6 +861,11 @@ public:
   void update_field();
   void fix_length_and_dec()
   { decimals= 0; max_length=21; unsigned_flag= 1; maybe_null= null_value= 0; }
+  void cleanup()
+  {
+    bits= reset_bits;
+    Item_sum_int::cleanup();
+  }
 };
 
 

sql/lock.cc

@@ -691,7 +691,8 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table_ptr, uint count,
           check_if_locking_is_allowed(thd->lex->sql_command, thd->lex->type,
                                       table_ptr[i], count,
                                       (thd == logger.get_general_log_thd()) ||
-                                           (thd == logger.get_slow_log_thd())))
+                                      (thd == logger.get_slow_log_thd()) ||
+                                      (thd == logger.get_privileged_thread())))
       DBUG_RETURN(0);
   }
 

sql/log.cc

@@ -173,6 +173,33 @@ public:
 
 handlerton *binlog_hton;
 
+
+/* Check if a given table is opened log table */
+int check_if_log_table(uint db_len, const char *db, uint table_name_len,
+                       const char *table_name, uint check_if_opened)
+{
+  if (db_len == 5 &&
+      !(lower_case_table_names ?
+        my_strcasecmp(system_charset_info, db, "mysql") :
+        strcmp(db, "mysql")))
+  {
+    if (table_name_len == 11 && !(lower_case_table_names ?
+                                  my_strcasecmp(system_charset_info,
+                                                table_name, "general_log") :
+                                  strcmp(table_name, "general_log")) &&
+        (!check_if_opened || logger.is_log_table_enabled(QUERY_LOG_GENERAL)))
+      return QUERY_LOG_GENERAL;
+    else
+      if (table_name_len == 8 && !(lower_case_table_names ?
+        my_strcasecmp(system_charset_info, table_name, "slow_log") :
+        strcmp(table_name, "slow_log")) &&
+          (!check_if_opened ||logger.is_log_table_enabled(QUERY_LOG_SLOW)))
+        return QUERY_LOG_SLOW;
+  }
+  return 0;
+}
+
+
 /*
   Open log table of a given type (general or slow log)
 
@@ -273,6 +300,12 @@ bool Log_to_csv_event_handler::open_log_table(uint log_table_type)
     my_pthread_setspecific_ptr(THR_MALLOC, 0);
   }
 
+  /*
+    After a log table was opened, we should clear privileged thread
+    flag (which allows locking of a log table by a special thread, usually
+    the one who closed log tables temporarily).
+  */
+  privileged_thread= 0;
   DBUG_RETURN(error);
 }
 
@@ -284,11 +317,15 @@ Log_to_csv_event_handler::Log_to_csv_event_handler()
   /* logger thread always works with mysql database */
   general_log_thd->db= my_strdup("mysql", MYF(0));
   general_log_thd->db_length= 5;
+  general_log.table= 0;
 
   slow_log_thd= new THD;
   /* logger thread always works with mysql database */
   slow_log_thd->db= my_strdup("mysql", MYF(0));;
   slow_log_thd->db_length= 5;
+  slow_log.table= 0;
+  /* no privileged thread exists at the moment */
+  privileged_thread= 0;
 }
 
 
@@ -341,6 +378,7 @@ bool Log_to_csv_event_handler::reopen_log_table(uint log_table_type)
   return open_log_table(log_table_type);
 }
 
+
 void Log_to_csv_event_handler::cleanup()
 {
   if (opt_log)
@@ -395,9 +433,6 @@ bool Log_to_csv_event_handler::
     filled by the Logger (=> no need to load default ones).
   */
 
-  /* log table entries are not replicated at the moment */
-  tmp_disable_binlog(current_thd);
-
   /* Set current time. Required for CURRENT_TIMESTAMP to work */
   general_log_thd->start_time= event_time;
 
@@ -406,21 +441,36 @@ bool Log_to_csv_event_handler::
     default value (which is CURRENT_TIMESTAMP).
   */
 
-  table->field[1]->store(user_host, user_host_len, client_cs);
+  /* check that all columns exist */
+  if (!table->field[1] || !table->field[2] || !table->field[3] ||
+      !table->field[4] || !table->field[5])
+    goto err;
+
+  /* do a write */
+  if (table->field[1]->store(user_host, user_host_len, client_cs) ||
+      table->field[2]->store((longlong) thread_id, TRUE) ||
+      table->field[3]->store((longlong) server_id, TRUE) ||
+      table->field[4]->store(command_type, command_type_len, client_cs) ||
+      table->field[5]->store(sql_text, sql_text_len, client_cs))
+    goto err;
+
+  /* mark tables as not null */
   table->field[1]->set_notnull();
-  table->field[2]->store((longlong) thread_id, TRUE);
   table->field[2]->set_notnull();
-  table->field[3]->store((longlong) server_id, TRUE);
   table->field[3]->set_notnull();
-  table->field[4]->store(command_type, command_type_len, client_cs);
   table->field[4]->set_notnull();
-  table->field[5]->store(sql_text, sql_text_len, client_cs);
   table->field[5]->set_notnull();
+
+  /* log table entries are not replicated at the moment */
+  tmp_disable_binlog(current_thd);
+
   table->file->ha_write_row(table->record[0]);
 
   reenable_binlog(current_thd);
 
   return FALSE;
+err:
+  return TRUE;
 }
 
 
@@ -469,9 +519,6 @@ bool Log_to_csv_event_handler::
   if (unlikely(!logger.is_log_tables_initialized))
     return FALSE;
 
-  /* log table entries are not replicated at the moment */
-  tmp_disable_binlog(current_thd);
-
   /*
      Set start time for CURRENT_TIMESTAMP to the start of the query.
      This will be default value for the field[0]
@@ -484,19 +531,30 @@ bool Log_to_csv_event_handler::
     default value.
   */
 
+  if (!table->field[1] || !table->field[2] || !table->field[3] ||
+      !table->field[4] || !table->field[5] || !table->field[6] ||
+      !table->field[7] || !table->field[8] || !table->field[9] ||
+      !table->field[10])
+    goto err;
+
   /* store the value */
-  table->field[1]->store(user_host, user_host_len, client_cs);
+  if (table->field[1]->store(user_host, user_host_len, client_cs))
+    goto err;
 
   if (query_start_arg)
   {
     /* fill in query_time field */
-    table->field[2]->store(query_time, TRUE);
+    if (table->field[2]->store(query_time, TRUE))
+      goto err;
     /* lock_time */
-    table->field[3]->store(lock_time, TRUE);
+    if (table->field[3]->store(lock_time, TRUE))
+      goto err;
     /* rows_sent */
-    table->field[4]->store((longlong) thd->sent_row_count, TRUE);
+    if (table->field[4]->store((longlong) thd->sent_row_count, TRUE))
+      goto err;
     /* rows_examined */
-    table->field[5]->store((longlong) thd->examined_row_count, TRUE);
+    if (table->field[5]->store((longlong) thd->examined_row_count, TRUE))
+      goto err;
   }
   else
   {
@@ -509,14 +567,18 @@ bool Log_to_csv_event_handler::
   /* fill database field */
   if (thd->db)
   {
-    table->field[6]->store(thd->db, thd->db_length, client_cs);
+    if (table->field[6]->store(thd->db, thd->db_length, client_cs))
+      goto err;
     table->field[6]->set_notnull();
   }
 
   if (thd->stmt_depends_on_first_successful_insert_id_in_prev_stmt)
   {
-    table->field[7]->store((longlong)
+    if (table->
-                           thd->first_successful_insert_id_in_prev_stmt_for_binlog, TRUE);
+        field[7]->store((longlong)
+                        thd->first_successful_insert_id_in_prev_stmt_for_binlog,
+                        TRUE))
+      goto err;
     table->field[7]->set_notnull();
   }
 
@@ -528,16 +590,23 @@ bool Log_to_csv_event_handler::
   */
   if (thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements() > 0)
   {
-    table->field[8]->store((longlong)
+    if (table->
-                           thd->auto_inc_intervals_in_cur_stmt_for_binlog.minimum(), TRUE);
+        field[8]->store((longlong)
+          thd->auto_inc_intervals_in_cur_stmt_for_binlog.minimum(), TRUE))
+      goto err;
     table->field[8]->set_notnull();
   }
 
-  table->field[9]->store((longlong) server_id, TRUE);
+  if (table->field[9]->store((longlong) server_id, TRUE))
+    goto err;
   table->field[9]->set_notnull();
 
   /* sql_text */
-  table->field[10]->store(sql_text,sql_text_len, client_cs);
+  if (table->field[10]->store(sql_text,sql_text_len, client_cs))
+    goto err;
+
+  /* log table entries are not replicated at the moment */
+  tmp_disable_binlog(current_thd);
 
   /* write the row */
   table->file->ha_write_row(table->record[0]);
@@ -545,6 +614,8 @@ bool Log_to_csv_event_handler::
   reenable_binlog(current_thd);
 
   DBUG_RETURN(0);
+err:
+  DBUG_RETURN(1);
 }
 
 bool Log_to_csv_event_handler::
@@ -733,61 +804,48 @@ bool LOGGER::reopen_log_table(uint log_table_type)
   return table_log_handler->reopen_log_table(log_table_type);
 }
 
+bool LOGGER::reopen_log_tables()
+{
+    /*
+      we use | and not || here, to ensure that both reopen_log_table
+      are called, even if the first one fails
+    */
+    if ((opt_slow_log && logger.reopen_log_table(QUERY_LOG_SLOW)) |
+        (opt_log && logger.reopen_log_table(QUERY_LOG_GENERAL)))
+      return TRUE;
+    return FALSE;
+}
+
+
+void LOGGER::tmp_close_log_tables(THD *thd)
+{
+  table_log_handler->tmp_close_log_tables(thd);
+}
 
 bool LOGGER::flush_logs(THD *thd)
 {
-  TABLE_LIST close_slow_log, close_general_log;
+  int rc= 0;
-
-  /* reopen log tables */
-  bzero((char*) &close_slow_log, sizeof(TABLE_LIST));
-  close_slow_log.alias= close_slow_log.table_name=(char*) "slow_log";
-  close_slow_log.table_name_length= 8;
-  close_slow_log.db= (char*) "mysql";
-  close_slow_log.db_length= 5;
-
-  bzero((char*) &close_general_log, sizeof(TABLE_LIST));
-  close_general_log.alias= close_general_log.table_name=(char*) "general_log";
-  close_general_log.table_name_length= 11;
-  close_general_log.db= (char*) "mysql";
-  close_general_log.db_length= 5;
-
-  /* lock tables, in the case they are enabled */
-  if (logger.is_log_tables_initialized)
-  {
-    /*
-      This will lock and wait for all but the logger thread to release the
-      tables. Then we could reopen log tables. Then release the name locks.
-
-      NOTE: in fact, the first parameter used in lock_and_wait_for_table_name()
-      and table_log_handler->flush() could be any non-NULL THD, as the
-      underlying code makes certain assumptions about this.
-      Here we use one of the logger handler THD's. Simply because it
-      seems appropriate.
-    */
-    if (opt_slow_log)
-      lock_and_wait_for_table_name(table_log_handler->general_log_thd,
-				   &close_slow_log);
-    if (opt_log)
-      lock_and_wait_for_table_name(table_log_handler->general_log_thd,
-				   &close_general_log);
-  }
 
   /*
-    Deny others from logging to general and slow log,
+    Now we lock logger, as nobody should be able to use logging routines while
-    while reopening tables.
+    log tables are closed
   */
   logger.lock();
+  if (logger.is_log_tables_initialized)
+    table_log_handler->tmp_close_log_tables(thd); // the locking happens here
 
   /* reopen log files */
   file_log_handler->flush();
 
-  /* flush tables, in the case they are enabled */
+  /* reopen tables in the case they were enabled */
   if (logger.is_log_tables_initialized)
-    table_log_handler->flush(table_log_handler->general_log_thd,
+  {
-                             &close_slow_log, &close_general_log);
+    if (reopen_log_tables())
+      rc= TRUE;
+  }
   /* end of log flush */
   logger.unlock();
-  return FALSE;
+  return rc;
 }
 
 
@@ -1095,31 +1153,50 @@ void LOGGER::deactivate_log_handler(THD *thd, uint log_type)
 }
 
 
-bool Log_to_csv_event_handler::flush(THD *thd, TABLE_LIST *close_slow_log,
+/*
-                                     TABLE_LIST *close_general_log)
+  Close log tables temporarily. The thread which closed
+  them this way can lock them in any mode it needs.
+  NOTE: one should call logger.lock() before entering this
+  function.
+*/
+void Log_to_csv_event_handler::tmp_close_log_tables(THD *thd)
 {
+  TABLE_LIST close_slow_log, close_general_log;
+
+  /* fill lists, we will need to perform operations on tables */
+  bzero((char*) &close_slow_log, sizeof(TABLE_LIST));
+  close_slow_log.alias= close_slow_log.table_name=(char*) "slow_log";
+  close_slow_log.table_name_length= 8;
+  close_slow_log.db= (char*) "mysql";
+  close_slow_log.db_length= 5;
+
+  bzero((char*) &close_general_log, sizeof(TABLE_LIST));
+  close_general_log.alias= close_general_log.table_name=(char*) "general_log";
+  close_general_log.table_name_length= 11;
+  close_general_log.db= (char*) "mysql";
+  close_general_log.db_length= 5;
+
+  privileged_thread= thd;
+
   VOID(pthread_mutex_lock(&LOCK_open));
+  /*
+    NOTE: in fact, the first parameter used in query_cache_invalidate3()
+    could be any non-NULL THD, as the underlying code makes certain
+    assumptions about this.
+    Here we use one of the logger handler THD's. Simply because it
+    seems appropriate.
+  */
   if (opt_log)
   {
     close_log_table(QUERY_LOG_GENERAL, TRUE);
-    query_cache_invalidate3(thd, close_general_log, 0);
+    query_cache_invalidate3(general_log_thd, &close_general_log, 0);
-    unlock_table_name(thd, close_general_log);
   }
   if (opt_slow_log)
   {
     close_log_table(QUERY_LOG_SLOW, TRUE);
-    query_cache_invalidate3(thd, close_slow_log, 0);
+    query_cache_invalidate3(general_log_thd, &close_slow_log, 0);
-    unlock_table_name(thd, close_slow_log);
   }
   VOID(pthread_mutex_unlock(&LOCK_open));
-  /*
-    we use | and not || here, to ensure that both reopen_log_table
-    are called, even if the first one fails
-  */
-  if ((opt_slow_log && reopen_log_table(QUERY_LOG_SLOW)) |
-      (opt_log && reopen_log_table(QUERY_LOG_GENERAL)))
-    return 1;
-  return 0;
 }
 
 /* the parameters are unused for the log tables */
@@ -1187,16 +1264,15 @@ void Log_to_csv_event_handler::
   THD *log_thd, *curr= current_thd;
   TABLE_LIST *table;
 
+  if (!logger.is_log_table_enabled(log_table_type))
+    return;                                     /* do nothing */
+
   switch (log_table_type) {
   case QUERY_LOG_GENERAL:
-    if (!logger.is_general_log_table_enabled())
-      return;                                     /* do nothing */
     log_thd= general_log_thd;
     table= &general_log;
     break;
   case QUERY_LOG_SLOW:
-    if (!logger.is_slow_log_table_enabled())
-      return;                                     /* do nothing */
     log_thd= slow_log_thd;
     table= &slow_log;
     break;

sql/log.h

@@ -404,6 +404,9 @@ public:
 };
 
 
+int check_if_log_table(uint db_len, const char *db, uint table_name_len,
+                       const char *table_name, uint check_if_opened);
+
 class Log_to_csv_event_handler: public Log_event_handler
 {
   /*
@@ -412,6 +415,16 @@ class Log_to_csv_event_handler: public Log_event_handler
     THD's of the query. The reason is the locking order and duration.
   */
   THD *general_log_thd, *slow_log_thd;
+  /*
+    This is for the thread, which called tmp_close_log_tables. The thread
+    will be allowed to write-lock the log tables (as it explicitly disabled
+    logging). This is used for such operations as REPAIR, which require
+    exclusive lock on the log tables.
+    NOTE: there can be only one priviliged thread, as one should
+    lock logger with logger.lock() before calling tmp_close_log_tables().
+    So no other thread could get privileged status at the same time.
+  */
+  THD *privileged_thread;
   friend class LOGGER;
   TABLE_LIST general_log, slow_log;
 
@@ -436,13 +449,20 @@ public:
                            const char *command_type, uint command_type_len,
                            const char *sql_text, uint sql_text_len,
                             CHARSET_INFO *client_cs);
-  bool flush(THD *thd, TABLE_LIST *close_slow_Log,
+  void tmp_close_log_tables(THD *thd);
-             TABLE_LIST* close_general_log);
   void close_log_table(uint log_type, bool lock_in_use);
   bool reopen_log_table(uint log_type);
+  THD* get_privileged_thread()
+  {
+    return privileged_thread;
+  }
 };
 
 
+/* type of the log table */
+#define QUERY_LOG_SLOW 1
+#define QUERY_LOG_GENERAL 2
+
 class Log_to_file_event_handler: public Log_event_handler
 {
   MYSQL_QUERY_LOG mysql_log;
@@ -498,13 +518,18 @@ public:
   {}
   void lock() { (void) pthread_mutex_lock(&LOCK_logger); }
   void unlock() { (void) pthread_mutex_unlock(&LOCK_logger); }
-  bool is_general_log_table_enabled()
+  void tmp_close_log_tables(THD *thd);
+  bool is_log_table_enabled(uint log_table_type)
   {
-    return table_log_handler && table_log_handler->general_log.table != 0;
+    switch (log_table_type) {
-  }
+    case QUERY_LOG_SLOW:
-  bool is_slow_log_table_enabled()
+      return table_log_handler && table_log_handler->slow_log.table != 0;
-  {
+    case QUERY_LOG_GENERAL:
-    return table_log_handler && table_log_handler->slow_log.table != 0;
+      return table_log_handler && table_log_handler->general_log.table != 0;
+    default:
+      DBUG_ASSERT(0);
+      return FALSE;                             /* make compiler happy */
+    }
   }
   /*
     We want to initialize all log mutexes as soon as possible,
@@ -542,6 +567,7 @@ public:
 
   void close_log_table(uint log_type, bool lock_in_use);
   bool reopen_log_table(uint log_type);
+  bool reopen_log_tables();
 
   /* we use this function to setup all enabled log event handlers */
   int set_handlers(uint error_log_printer,
@@ -564,6 +590,13 @@ public:
       return file_log_handler->get_mysql_log();
     return NULL;
   }
+  THD* get_privileged_thread()
+  {
+    if (table_log_handler)
+      return table_log_handler->get_privileged_thread();
+    else
+      return NULL;
+  }
 };
 
 enum enum_binlog_format {

sql/mysql_priv.h

@@ -140,6 +140,8 @@ MY_LOCALE *my_locale_by_name(const char *name);
 #define MAX_ACCEPT_RETRY	10	// Test accept this many times
 #define MAX_FIELDS_BEFORE_HASH	32
 #define USER_VARS_HASH_SIZE     16
+#define TABLE_OPEN_CACHE_MIN    64
+#define TABLE_OPEN_CACHE_DEFAULT 64
 
 /* 
  Value of 9236 discovered through binary search 2006-09-26 on Ubuntu Dapper
@@ -1451,10 +1453,6 @@ typedef void (*sql_print_message_func)(const char *format, ...)
   ATTRIBUTE_FORMAT(printf, 1, 2);
 extern sql_print_message_func sql_print_message_handlers[];
 
-/* type of the log table */
-#define QUERY_LOG_SLOW 1
-#define QUERY_LOG_GENERAL 2
-
 int error_log_print(enum loglevel level, const char *format,
                     va_list args);
 
@@ -1485,6 +1483,8 @@ uint find_type2(TYPELIB *lib, const char *find, uint length, CHARSET_INFO *cs);
 void unhex_type2(TYPELIB *lib);
 uint check_word(TYPELIB *lib, const char *val, const char *end,
 		const char **end_of_word);
+int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
+                         CHARSET_INFO * const cs);
 
 
 bool is_keyword(const char *name, uint len);

sql/mysqld.cc

@@ -2663,19 +2663,43 @@ static int init_common_variables(const char *conf_file_name, int argc,
 
   /* connections and databases needs lots of files */
   {
-    uint files, wanted_files;
+    uint files, wanted_files, max_open_files;
 
-    wanted_files= 10+(uint) max(max_connections*5,
+    /* MyISAM requires two file handles per table. */
-				 max_connections+table_cache_size*2);
+    wanted_files= 10+max_connections+table_cache_size*2;
-    set_if_bigger(wanted_files, open_files_limit);
+    /*
-    files= my_set_max_open_files(wanted_files);
+      We are trying to allocate no less than max_connections*5 file
+      handles (i.e. we are trying to set the limit so that they will
+      be available).  In addition, we allocate no less than how much
+      was already allocated.  However below we report a warning and
+      recompute values only if we got less file handles than were
+      explicitly requested.  No warning and re-computation occur if we
+      can't get max_connections*5 but still got no less than was
+      requested (value of wanted_files).
+    */
+    max_open_files= max(max(wanted_files, max_connections*5),
+                        open_files_limit);
+    files= my_set_max_open_files(max_open_files);
 
     if (files < wanted_files)
     {
       if (!open_files_limit)
       {
-	max_connections=	(ulong) min((files-10),max_connections);
+        /*
-	table_cache_size= (ulong) max((files-10-max_connections)/2,64);
+          If we have requested too much file handles than we bring
+          max_connections in supported bounds.
+        */
+        max_connections= (ulong) min(files-10-TABLE_OPEN_CACHE_MIN*2,
+                                     max_connections);
+        /*
+          Decrease table_cache_size according to max_connections, but
+          not below TABLE_OPEN_CACHE_MIN.  Outer min() ensures that we
+          never increase table_cache_size automatically (that could
+          happen if max_connections is decreased above).
+        */
+        table_cache_size= (ulong) min(max((files-10-max_connections)/2,
+                                          TABLE_OPEN_CACHE_MIN),
+                                      table_cache_size);    
 	DBUG_PRINT("warning",
 		   ("Changed limits: max_open_files: %u  max_connections: %ld  table_cache: %ld",
 		    files, max_connections, table_cache_size));
@@ -6185,15 +6209,15 @@ The minimum value for this variable is 4096.",
   {"table_cache", OPT_TABLE_OPEN_CACHE,
    "Deprecated; use --table_open_cache instead.",
    (gptr*) &table_cache_size, (gptr*) &table_cache_size, 0, GET_ULONG,
-   REQUIRED_ARG, 64, 1, 512*1024L, 0, 1, 0},
+   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
   {"table_definition_cache", OPT_TABLE_DEF_CACHE,
    "The number of cached table definitions.",
    (gptr*) &table_def_size, (gptr*) &table_def_size,
    0, GET_ULONG, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
   {"table_open_cache", OPT_TABLE_OPEN_CACHE,
    "The number of cached open tables.",
-   (gptr*) &table_cache_size, (gptr*) &table_cache_size,
+   (gptr*) &table_cache_size, (gptr*) &table_cache_size, 0, GET_ULONG,
-   0, GET_ULONG, REQUIRED_ARG, 64, 1, 512*1024L, 0, 1, 0},
+   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
   {"table_lock_wait_timeout", OPT_TABLE_LOCK_WAIT_TIMEOUT,
    "Timeout in seconds to wait for a table level lock before returning an "
    "error. Used only if the connection has active cursors.",

sql/parse_file.h

@@ -107,4 +107,20 @@ public:
 					bool bad_format_errors);
 };
 
+
+/*
+  Custom version of standard offsetof() macro which can be used to get
+  offsets of members in class for non-POD types (according to the current
+  version of C++ standard offsetof() macro can't be used in such cases and
+  attempt to do so causes warnings to be emitted, OTOH in many cases it is
+  still OK to assume that all instances of the class has the same offsets
+  for the same members).
+
+  This is temporary solution which should be removed once File_parser class
+  and related routines are refactored.
+*/
+
+#define my_offsetof(TYPE, MEMBER) \
+        ((size_t)((char *)&(((TYPE *)0x10)->MEMBER) - (char*)0x10))
+
 #endif /* _PARSE_FILE_H_ */

sql/share/errmsg.txt

@@ -6004,4 +6004,6 @@ ER_BAD_LOG_STATEMENT
         ger "Sie können eine Logtabelle nicht '%s', wenn Loggen angeschaltet ist"
 ER_NON_INSERTABLE_TABLE  
         eng "The target table %-.100s of the %s is not insertable-into"
+ER_CANT_RENAME_LOG_TABLE
+        eng "Cannot rename '%s'. When logging enabled, rename to/from log table must rename two tables: the log table to an archive table and another table back to '%s'"
 

sql/sp.cc

@@ -1371,6 +1371,10 @@ static bool add_used_routine(LEX *lex, Query_arena *arena,
                              const LEX_STRING *key,
                              TABLE_LIST *belong_to_view)
 {
+  hash_init_opt(&lex->sroutines, system_charset_info,
+                Query_tables_list::START_SROUTINES_HASH_SIZE,
+                0, 0, sp_sroutine_key, 0, 0);
+
   if (!hash_search(&lex->sroutines, (byte *)key->str, key->length))
   {
     Sroutine_hash_entry *rn=

sql/sp_head.cc

@@ -1029,8 +1029,7 @@ sp_head::execute(THD *thd)
   save_sql_mode= thd->variables.sql_mode;
   thd->variables.sql_mode= m_sql_mode;
   save_abort_on_warning= thd->abort_on_warning;
-  thd->abort_on_warning=
+  thd->abort_on_warning= 0;
-    (m_sql_mode & (MODE_STRICT_TRANS_TABLES | MODE_STRICT_ALL_TABLES));
 
   /*
     It is also more efficient to save/restore current thd->lex once when

sql/sql_base.cc

@@ -1365,6 +1365,10 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table,
     Also SELECT::exclude_from_table_unique_test used to exclude from check
     tables of main SELECT of multi-delete and multi-update
 
+    We also skip tables with TABLE_LIST::prelocking_placeholder set,
+    because we want to allow SELECTs from them, and their modification
+    will rise the error anyway.
+
     TODO: when we will have table/view change detection we can do this check
           only once for PS/SP
 
@@ -1411,12 +1415,13 @@ TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
     if (((! (res= find_table_in_global_list(table_list, d_name, t_name))) &&
          (! (res= mysql_lock_have_duplicate(thd, table, table_list)))) ||
         ((!res->table || res->table != table->table) &&
-         res->select_lex && !res->select_lex->exclude_from_table_unique_test))
+         res->select_lex && !res->select_lex->exclude_from_table_unique_test &&
+         !res->prelocking_placeholder))
       break;
     /*
-      If we found entry of this table or or table of SELECT which already
+      If we found entry of this table or table of SELECT which already
       processed in derived table or top select of multi-update/multi-delete
-      (exclude_from_table_unique_test).
+      (exclude_from_table_unique_test) or prelocking placeholder.
     */
     table_list= res->next_global;
     DBUG_PRINT("info",

sql/sql_delete.cc

@@ -350,7 +350,7 @@ cleanup:
     mysql_unlock_tables(thd, thd->lock);
     thd->lock=0;
   }
-  if (error < 0)
+  if (error < 0 || (thd->lex->ignore && !thd->is_fatal_error))
   {
     thd->row_count_func= deleted;
     send_ok(thd,deleted);
@@ -862,6 +862,7 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok)
   bool error;
   uint closed_log_tables= 0, lock_logger= 0;
   uint path_length;
+  uint log_type;
   DBUG_ENTER("mysql_truncate");
 
   bzero((char*) &create_info,sizeof(create_info));
@@ -913,28 +914,16 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok)
       DBUG_RETURN(TRUE);
   }
 
+  log_type= check_if_log_table(table_list->db_length, table_list->db,
+                               table_list->table_name_length,
+                               table_list->table_name, 1);
   /* close log tables in use */
-  if (!my_strcasecmp(system_charset_info, table_list->db, "mysql"))
+  if (log_type)
   {
-    if (opt_log &&
+    lock_logger= 1;
-        !my_strcasecmp(system_charset_info, table_list->table_name,
+    logger.lock();
-                       "general_log"))
+    logger.close_log_table(log_type, FALSE);
-    {
+    closed_log_tables= closed_log_tables | log_type;
-      lock_logger= 1;
-      logger.lock();
-      logger.close_log_table(QUERY_LOG_GENERAL, FALSE);
-      closed_log_tables= closed_log_tables | QUERY_LOG_GENERAL;
-    }
-    else
-      if (opt_slow_log &&
-          !my_strcasecmp(system_charset_info, table_list->table_name,
-                         "slow_log"))
-      {
-        lock_logger= 1;
-        logger.lock();
-        logger.close_log_table(QUERY_LOG_SLOW, FALSE);
-        closed_log_tables= closed_log_tables | QUERY_LOG_SLOW;
-      }
   }
 
   // Remove the .frm extension AIX 5.2 64-bit compiler bug (BUG#16155): this

sql/sql_lex.cc

@@ -151,7 +151,6 @@ void lex_start(THD *thd, const uchar *buf, uint length)
   lex->safe_to_cache_query= 1;
   lex->time_zone_tables_used= 0;
   lex->leaf_tables_insert= 0;
-  lex->variables_used= 0;
   lex->empty_field_list_on_rset= 0;
   lex->select_lex.select_number= 1;
   lex->next_state=MY_LEX_START;
@@ -1644,9 +1643,18 @@ void Query_tables_list::reset_query_tables_list(bool init)
   query_tables_last= &query_tables;
   query_tables_own_last= 0;
   if (init)
-    hash_init(&sroutines, system_charset_info, 0, 0, 0, sp_sroutine_key, 0, 0);
+  {
+    /*
+      We delay real initialization of hash (and therefore related
+      memory allocation) until first insertion into this hash.
+    */
+    hash_clear(&sroutines);
+  }
   else if (sroutines.records)
+  {
+    /* Non-zero sroutines.records means that hash was initialized. */
     my_hash_reset(&sroutines);
+  }
   sroutines_list.empty();
   sroutines_list_own_last= sroutines_list.next;
   sroutines_list_own_elements= 0;

sql/sql_lex.h

@@ -792,7 +792,11 @@ public:
     0 - indicates that this query does not need prelocking.
   */
   TABLE_LIST **query_tables_own_last;
-  /* Set of stored routines called by statement. */
+  /*
+    Set of stored routines called by statement.
+    (Note that we use lazy-initialization for this hash).
+  */
+  enum { START_SROUTINES_HASH_SIZE= 16 };
   HASH sroutines;
   /*
     List linking elements of 'sroutines' set. Allows you to add new elements
@@ -867,6 +871,25 @@ public:
 };
 
 
+/*
+  st_parsing_options contains the flags for constructions that are
+  allowed in the current statement.
+*/
+
+struct st_parsing_options
+{
+  bool allows_variable;
+  bool allows_select_into;
+  bool allows_select_procedure;
+  bool allows_derived;
+
+  st_parsing_options()
+    : allows_variable(TRUE), allows_select_into(TRUE),
+      allows_select_procedure(TRUE), allows_derived(TRUE)
+  {}
+};
+
+
 /* The state of the lex parsing. This is saved in the THD struct */
 
 typedef struct st_lex : public Query_tables_list
@@ -1023,7 +1046,7 @@ typedef struct st_lex : public Query_tables_list
   bool stmt_prepare_mode;
   bool safe_to_cache_query;
   bool subqueries, ignore;
-  bool variables_used;
+  st_parsing_options parsing_options;
   ALTER_INFO alter_info;
   /* Prepared statements SQL syntax:*/
   LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */

sql/sql_parse.cc

@@ -3394,9 +3394,17 @@ end_with_restore_list:
     res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
 		      lex->update_list, lex->value_list,
                       lex->duplicates, lex->ignore);
-    /* do not show last insert ID if VIEW does not have auto_inc */
+
+    /*
+      If we have inserted into a VIEW, and the base table has
+      AUTO_INCREMENT column, but this column is not accessible through
+      a view, then we should restore LAST_INSERT_ID to the value it
+      had before the statement.
+    */
     if (first_table->view && !first_table->contain_auto_increment)
-      thd->first_successful_insert_id_in_cur_stmt= 0;
+      thd->first_successful_insert_id_in_cur_stmt=
+        thd->first_successful_insert_id_in_prev_stmt;
+
     break;
   }
   case SQLCOM_REPLACE_SELECT:
@@ -3456,9 +3464,17 @@ end_with_restore_list:
       /* revert changes for SP */
       select_lex->table_list.first= (byte*) first_table;
     }
-    /* do not show last insert ID if VIEW does not have auto_inc */
+
+    /*
+      If we have inserted into a VIEW, and the base table has
+      AUTO_INCREMENT column, but this column is not accessible through
+      a view, then we should restore LAST_INSERT_ID to the value it
+      had before the statement.
+    */
     if (first_table->view && !first_table->contain_auto_increment)
-      thd->first_successful_insert_id_in_cur_stmt= 0;
+      thd->first_successful_insert_id_in_cur_stmt=
+        thd->first_successful_insert_id_in_prev_stmt;
+
     break;
   }
   case SQLCOM_TRUNCATE:
@@ -6088,14 +6104,19 @@ void mysql_parse(THD *thd, char *inBuf, uint length)
       DBUG_ASSERT(thd->net.report_error);
       DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
 			 thd->is_fatal_error));
-      query_cache_abort(&thd->net);
+
-      lex->unit.cleanup();
+      /*
+        The first thing we do after parse error is freeing sp_head to
+        ensure that we have restored original memroot.
+      */
       if (lex->sphead)
       {
 	/* Clean up after failed stored procedure/function */
 	delete lex->sphead;
 	lex->sphead= NULL;
       }
+      query_cache_abort(&thd->net);
+      lex->unit.cleanup();
     }
     thd->proc_info="freeing items";
     thd->end_statement();

sql/sql_prepare.cc

@@ -2811,7 +2811,19 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
 
   error= MYSQLparse((void *)thd) || thd->is_fatal_error ||
       thd->net.report_error || init_param_array(this);
+
+  /*
+    The first thing we do after parse error is freeing sp_head to
+    ensure that we have restored original memroot.
+  */
+  if (error && lex->sphead)
+  {
+    delete lex->sphead;
+    lex->sphead= NULL;
+  }
+
   lex->safe_to_cache_query= FALSE;
+
   /*
     While doing context analysis of the query (in check_prepared_statement)
     we allocate a lot of additional memory: for open tables, JOINs, derived
@@ -2837,6 +2849,7 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
   if (error == 0)
     error= check_prepared_statement(this, name.str != 0);
 
+  /* Free sp_head if check_prepared_statement() failed. */
   if (error && lex->sphead)
   {
     delete lex->sphead;

sql/sql_rename.cc

@@ -35,7 +35,10 @@ static TABLE_LIST *reverse_table_list(TABLE_LIST *table_list);
 bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list, bool silent)
 {
   bool error= 1;
-  TABLE_LIST *ren_table= 0;
+  TABLE_LIST *ren_table= 0, *new_table;
+  int to_table;
+  char *rename_log_table[2]= {NULL, NULL};
+  int disable_logs= 0;
   DBUG_ENTER("mysql_rename_tables");
 
   /*
@@ -52,6 +55,96 @@ bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list, bool silent)
 
   if (wait_if_global_read_lock(thd,0,1))
     DBUG_RETURN(1);
+
+  if (logger.is_log_table_enabled(QUERY_LOG_GENERAL) ||
+      logger.is_log_table_enabled(QUERY_LOG_SLOW))
+  {
+
+    /*
+      Rules for rename of a log table:
+
+      IF   1. Log tables are enabled
+      AND  2. Rename operates on the log table and nothing is being
+              renamed to the log table.
+      DO   3. Throw an error message.
+      ELSE 4. Perform rename.
+    */
+
+    for (to_table= 0, ren_table= table_list; ren_table;
+         to_table= 1 - to_table, ren_table= ren_table->next_local)
+    {
+      int log_table_rename= 0;
+
+      if ((log_table_rename=
+           check_if_log_table(ren_table->db_length, ren_table->db,
+                              ren_table->table_name_length,
+                              ren_table->table_name, 1)))
+      {
+        /*
+          Log table encoutered we will need to disable and lock logs
+          for duration of rename.
+        */
+        disable_logs= TRUE;
+
+        /*
+          as we use log_table_rename as an array index, we need it to start
+          with 0, while QUERY_LOG_SLOW == 1 and QUERY_LOG_GENERAL == 2.
+          So, we shift the value to start with 0;
+        */
+        log_table_rename--;
+        if (rename_log_table[log_table_rename])
+        {
+          if (to_table)
+            rename_log_table[log_table_rename]= NULL;
+          else
+          {
+            /*
+              Two renames of "log_table TO" w/o rename "TO log_table" in
+              between.
+            */
+            my_error(ER_CANT_RENAME_LOG_TABLE, MYF(0), ren_table->table_name,
+                     ren_table->table_name);
+            DBUG_RETURN(1);
+          }
+        }
+        else
+        {
+          if (to_table)
+          {
+            /*
+              Attempt to rename a table TO log_table w/o renaming
+              log_table TO some table.
+            */
+            my_error(ER_CANT_RENAME_LOG_TABLE, MYF(0), ren_table->table_name,
+                     ren_table->table_name);
+            DBUG_RETURN(1);
+          }
+          else
+          {
+            /* save the name of the log table to report an error */
+            rename_log_table[log_table_rename]= ren_table->table_name;
+          }
+        }
+      }
+    }
+    if (rename_log_table[0] || rename_log_table[1])
+    {
+      if (rename_log_table[0])
+        my_error(ER_CANT_RENAME_LOG_TABLE, MYF(0), rename_log_table[0],
+                 rename_log_table[0]);
+      else
+        my_error(ER_CANT_RENAME_LOG_TABLE, MYF(0), rename_log_table[1],
+                 rename_log_table[1]);
+      DBUG_RETURN(1);
+    }
+
+    if (disable_logs)
+    {
+      logger.lock();
+      logger.tmp_close_log_tables(thd);
+    }
+  }
+
   VOID(pthread_mutex_lock(&LOCK_open));
   if (lock_table_names(thd, table_list))
     goto err;
@@ -95,6 +188,13 @@ bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list, bool silent)
 
 err:
   pthread_mutex_unlock(&LOCK_open);
+  /* enable logging back if needed */
+  if (disable_logs)
+  {
+    if (logger.reopen_log_tables())
+      error= TRUE;
+    logger.unlock();
+  }
   start_waiting_global_read_lock(thd);
   DBUG_RETURN(error);
 }

sql/sql_table.cc

@@ -1639,11 +1639,8 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
 
     /* Disable drop of enabled log tables */
     if (share && share->log_table &&
-        ((!my_strcasecmp(system_charset_info, table->table_name,
+        check_if_log_table(table->db_length, table->db,
-                         "general_log") && opt_log &&
+                           table->table_name_length, table->table_name, 1))
-          logger.is_general_log_table_enabled()) ||
-         (!my_strcasecmp(system_charset_info, table->table_name, "slow_log")
-          && opt_slow_log && logger.is_slow_log_table_enabled())))
     {
       my_error(ER_BAD_LOG_STATEMENT, MYF(0), "DROP");
       DBUG_RETURN(1);
@@ -4043,7 +4040,7 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
   Item *item;
   Protocol *protocol= thd->protocol;
   LEX *lex= thd->lex;
-  int result_code;
+  int result_code, disable_logs= 0;
   DBUG_ENTER("mysql_admin_table");
 
   if (end_active_trans(thd))
@@ -4088,6 +4085,23 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
     thd->no_warnings_for_error= no_warnings_for_error;
     if (view_operator_func == NULL)
       table->required_type=FRMTYPE_TABLE;
+
+    /*
+      If we want to perform an admin operation on the log table
+      (E.g. rename) and lock_type >= TL_READ_NO_INSERT disable
+      log tables
+    */
+
+    if (check_if_log_table(table->db_length, table->db,
+                                  table->table_name_length,
+                                  table->table_name, 1) &&
+        lock_type >= TL_READ_NO_INSERT)
+    {
+      disable_logs= 1;
+      logger.lock();
+      logger.tmp_close_log_tables(thd);
+    }
+
     open_and_lock_tables(thd, table);
     thd->no_warnings_for_error= 0;
     table->next_global= save_next_global;
@@ -4404,11 +4418,24 @@ send_result_message:
   }
 
   send_eof(thd);
+  if (disable_logs)
+  {
+    if (logger.reopen_log_tables())
+      my_error(ER_CANT_ACTIVATE_LOG, MYF(0));
+    logger.unlock();
+  }
   DBUG_RETURN(FALSE);
 
  err:
   ha_autocommit_or_rollback(thd, 1);
   close_thread_tables(thd);			// Shouldn't be needed
+  /* enable logging back if needed */
+  if (disable_logs)
+  {
+    if (logger.reopen_log_tables())
+      my_error(ER_CANT_ACTIVATE_LOG, MYF(0));
+    logger.unlock();
+  }
   if (table)
     table->table=0;
   DBUG_RETURN(TRUE);
@@ -4573,17 +4600,18 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
 {
   TABLE *tmp_table;
   char src_path[FN_REFLEN], dst_path[FN_REFLEN], tmp_path[FN_REFLEN];
+  char src_table_name_buff[FN_REFLEN], src_db_name_buff[FN_REFLEN];
   uint dst_path_length;
   char *db= table->db;
   char *table_name= table->table_name;
   char *src_db;
   char *src_table= table_ident->table.str;
   int  err;
-  bool res= TRUE;
+  bool res= TRUE, unlock_dst_table= FALSE;
   enum legacy_db_type not_used;
   HA_CREATE_INFO *create_info;
 
-  TABLE_LIST src_tables_list;
+  TABLE_LIST src_tables_list, dst_tables_list;
   DBUG_ENTER("mysql_create_like_table");
 
   if (!(create_info= copy_create_info(lex_create_info)))
@@ -4609,13 +4637,6 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
     DBUG_RETURN(-1);
   }
 
-  bzero((gptr)&src_tables_list, sizeof(src_tables_list));
-  src_tables_list.db= src_db;
-  src_tables_list.table_name= src_table;
-
-  if (lock_and_wait_for_table_name(thd, &src_tables_list))
-    goto err;
-
   if ((tmp_table= find_temporary_table(thd, src_db, src_table)))
     strxmov(src_path, tmp_table->s->path.str, reg_ext, NullS);
   else
@@ -4642,6 +4663,34 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
     goto err;
   }
 
+  if (lower_case_table_names)
+  {
+    if (src_db)
+    {
+      strmake(src_db_name_buff, src_db,
+              min(sizeof(src_db_name_buff) - 1, table_ident->db.length));
+      my_casedn_str(files_charset_info, src_db_name_buff);
+      src_db= src_db_name_buff;
+    }
+    if (src_table)
+    {
+      strmake(src_table_name_buff, src_table,
+              min(sizeof(src_table_name_buff) - 1, table_ident->table.length));
+      my_casedn_str(files_charset_info, src_table_name_buff);
+      src_table= src_table_name_buff;
+    }
+  }
+
+  bzero((gptr)&src_tables_list, sizeof(src_tables_list));
+  src_tables_list.db= src_db;
+  src_tables_list.db_length= table_ident->db.length;
+  src_tables_list.lock_type= TL_READ;
+  src_tables_list.table_name= src_table;
+  src_tables_list.alias= src_table;
+
+  if (simple_open_n_lock_tables(thd, &src_tables_list))
+    DBUG_RETURN(TRUE);
+
   /*
     Validate the destination table
 
@@ -4745,17 +4794,29 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
         char buf[2048];
         String query(buf, sizeof(buf), system_charset_info);
         query.length(0);  // Have to zero it since constructor doesn't
-        TABLE *table_ptr;
+        uint counter;
-        int error;
 
         /*
-          Let's open and lock the table: it will be closed (and
+          Here we open the destination table. This is needed for
-          unlocked) by close_thread_tables() at the end of the
+          store_create_info() to work. The table will be closed
-          statement anyway.
+          by close_thread_tables() at the end of the statement.
-         */
+        */
-        if (!(table_ptr= open_ltable(thd, table, TL_READ_NO_INSERT)))
+        if (open_tables(thd, &table, &counter, 0))
           goto err;
 
+        bzero((gptr)&dst_tables_list, sizeof(dst_tables_list));
+        dst_tables_list.db= table->db;
+        dst_tables_list.table_name= table->table_name;
+
+        /*
+          lock destination table name, to make sure that nobody
+          can drop/alter the table while we execute store_create_info()
+        */
+        if (lock_and_wait_for_table_name(thd, &dst_tables_list))
+          goto err;
+        else
+          unlock_dst_table= TRUE;
+
         int result= store_create_info(thd, table, &query, create_info);
 
         DBUG_ASSERT(result == 0); // store_create_info() always return 0
@@ -4788,9 +4849,12 @@ table_exists:
     my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
 
 err:
-  pthread_mutex_lock(&LOCK_open);
+  if (unlock_dst_table)
-  unlock_table_name(thd, &src_tables_list);
+  {
-  pthread_mutex_unlock(&LOCK_open);
+    pthread_mutex_lock(&LOCK_open);
+    unlock_table_name(thd, &dst_tables_list);
+    pthread_mutex_unlock(&LOCK_open);
+  }
   DBUG_RETURN(res);
 }
 
@@ -5179,33 +5243,23 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
   LINT_INIT(index_add_buffer);
   LINT_INIT(index_drop_buffer);
 
-  if (table_list && table_list->db &&
+  if (table_list && table_list->db && table_list->table_name)
-      !my_strcasecmp(system_charset_info, table_list->db, "mysql") &&
-      table_list->table_name)
   {
-    enum enum_table_kind { NOT_LOG_TABLE= 1, GENERAL_LOG, SLOW_LOG }
+    int table_kind= 0;
-         table_kind= NOT_LOG_TABLE;
 
-    if (!my_strcasecmp(system_charset_info, table_list->table_name,
+    table_kind= check_if_log_table(table_list->db_length, table_list->db,
-                       "general_log"))
+                                   table_list->table_name_length,
-      table_kind= GENERAL_LOG;
+                                   table_list->table_name, 0);
-    else
-      if (!my_strcasecmp(system_charset_info, table_list->table_name,
-                         "slow_log"))
-        table_kind= SLOW_LOG;
 
     /* Disable alter of enabled log tables */
-    if ((table_kind == GENERAL_LOG && opt_log &&
+    if (table_kind && logger.is_log_table_enabled(table_kind))
-        logger.is_general_log_table_enabled()) ||
-       (table_kind == SLOW_LOG && opt_slow_log &&
-         logger.is_slow_log_table_enabled()))
     {
       my_error(ER_BAD_LOG_STATEMENT, MYF(0), "ALTER");
       DBUG_RETURN(TRUE);
     }
 
     /* Disable alter of log tables to unsupported engine */
-    if ((table_kind == GENERAL_LOG || table_kind == SLOW_LOG) &&
+    if (table_kind &&
         (lex_create_info->used_fields & HA_CREATE_USED_ENGINE) &&
         (!lex_create_info->db_type || /* unknown engine */
         !(lex_create_info->db_type->flags & HTON_SUPPORT_LOG_TABLES)))

sql/sql_trigger.cc

@@ -36,17 +36,17 @@ static File_option triggers_file_parameters[]=
 {
   {
     { C_STRING_WITH_LEN("triggers") },
-    offsetof(class Table_triggers_list, definitions_list),
+    my_offsetof(class Table_triggers_list, definitions_list),
     FILE_OPTIONS_STRLIST
   },
   {
     { C_STRING_WITH_LEN("sql_modes") },
-    offsetof(class Table_triggers_list, definition_modes_list),
+    my_offsetof(class Table_triggers_list, definition_modes_list),
     FILE_OPTIONS_ULLLIST
   },
   {
     { C_STRING_WITH_LEN("definers") },
-    offsetof(class Table_triggers_list, definers_list),
+    my_offsetof(class Table_triggers_list, definers_list),
     FILE_OPTIONS_STRLIST
   },
   { { 0, 0 }, 0, FILE_OPTIONS_STRING }
@@ -55,7 +55,7 @@ static File_option triggers_file_parameters[]=
 File_option sql_modes_parameters=
 {
   { C_STRING_WITH_LEN("sql_modes") },
-  offsetof(class Table_triggers_list, definition_modes_list),
+  my_offsetof(class Table_triggers_list, definition_modes_list),
   FILE_OPTIONS_ULLLIST
 };
 

sql/sql_view.cc

@@ -236,25 +236,9 @@ bool mysql_create_view(THD *thd,
   bool res= FALSE;
   DBUG_ENTER("mysql_create_view");
 
-  if (lex->proc_list.first ||
+  /* This is ensured in the parser. */
-      lex->result)
+  DBUG_ASSERT(!lex->proc_list.first && !lex->result &&
-  {
+              !lex->param_list.elements && !lex->derived_tables);
-    my_error(ER_VIEW_SELECT_CLAUSE, MYF(0), (lex->result ?
-                                             "INTO" :
-                                             "PROCEDURE"));
-    res= TRUE;
-    goto err;
-  }
-  if (lex->derived_tables ||
-      lex->variables_used || lex->param_list.elements)
-  {
-    int err= (lex->derived_tables ?
-              ER_VIEW_SELECT_DERIVED :
-              ER_VIEW_SELECT_VARIABLE);
-    my_message(err, ER(err), MYF(0));
-    res= TRUE;
-    goto err;
-  }
 
   if (mode != VIEW_CREATE_NEW)
   {
@@ -582,40 +566,40 @@ static const int num_view_backups= 3;
 */
 static File_option view_parameters[]=
 {{{ C_STRING_WITH_LEN("query")},
-  offsetof(TABLE_LIST, query),
+  my_offsetof(TABLE_LIST, query),
   FILE_OPTIONS_ESTRING},
  {{ C_STRING_WITH_LEN("md5")},
-  offsetof(TABLE_LIST, md5),
+  my_offsetof(TABLE_LIST, md5),
   FILE_OPTIONS_STRING},
  {{ C_STRING_WITH_LEN("updatable")},
-  offsetof(TABLE_LIST, updatable_view),
+  my_offsetof(TABLE_LIST, updatable_view),
   FILE_OPTIONS_ULONGLONG},
  {{ C_STRING_WITH_LEN("algorithm")},
-  offsetof(TABLE_LIST, algorithm),
+  my_offsetof(TABLE_LIST, algorithm),
   FILE_OPTIONS_ULONGLONG},
  {{ C_STRING_WITH_LEN("definer_user")},
-  offsetof(TABLE_LIST, definer.user),
+  my_offsetof(TABLE_LIST, definer.user),
   FILE_OPTIONS_STRING},
  {{ C_STRING_WITH_LEN("definer_host")},
-  offsetof(TABLE_LIST, definer.host),
+  my_offsetof(TABLE_LIST, definer.host),
   FILE_OPTIONS_STRING},
  {{ C_STRING_WITH_LEN("suid")},
-  offsetof(TABLE_LIST, view_suid),
+  my_offsetof(TABLE_LIST, view_suid),
   FILE_OPTIONS_ULONGLONG},
  {{ C_STRING_WITH_LEN("with_check_option")},
-  offsetof(TABLE_LIST, with_check),
+  my_offsetof(TABLE_LIST, with_check),
   FILE_OPTIONS_ULONGLONG},
  {{ C_STRING_WITH_LEN("revision")},
-  offsetof(TABLE_LIST, revision),
+  my_offsetof(TABLE_LIST, revision),
   FILE_OPTIONS_REV},
  {{ C_STRING_WITH_LEN("timestamp")},
-  offsetof(TABLE_LIST, timestamp),
+  my_offsetof(TABLE_LIST, timestamp),
   FILE_OPTIONS_TIMESTAMP},
  {{ C_STRING_WITH_LEN("create-version")},
-  offsetof(TABLE_LIST, file_version),
+  my_offsetof(TABLE_LIST, file_version),
   FILE_OPTIONS_ULONGLONG},
  {{ C_STRING_WITH_LEN("source")},
-  offsetof(TABLE_LIST, source),
+  my_offsetof(TABLE_LIST, source),
   FILE_OPTIONS_ESTRING},
  {{NullS, 0},			0,
   FILE_OPTIONS_STRING}

sql/sql_yacc.yy

@@ -793,7 +793,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %type <item>
 	literal text_literal insert_ident order_ident
 	simple_ident select_item2 expr opt_expr opt_else sum_expr in_sum_expr
-	bool_term bool_factor bool_test bool_pri 
+	variable variable_aux bool_term bool_factor bool_test bool_pri 
 	predicate bit_expr bit_term bit_factor value_expr term factor
 	table_wild simple_expr udf_expr
 	expr_or_default set_expr_or_default interval_expr
@@ -1725,15 +1725,20 @@ call:
 	    lex->value_list.empty();
 	    sp_add_used_routine(lex, YYTHD, $2, TYPE_ENUM_PROCEDURE);
 	  }
-          '(' sp_cparam_list ')' {}
+          opt_sp_cparam_list {}
 	;
 
 /* CALL parameters */
-sp_cparam_list:
+opt_sp_cparam_list:
 	  /* Empty */
-	| sp_cparams
+	| '(' opt_sp_cparams ')'
 	;
 
+opt_sp_cparams:
+          /* Empty */
+        | sp_cparams
+        ;
+
 sp_cparams:
 	  sp_cparams ',' expr
 	  {
@@ -5954,32 +5959,7 @@ simple_expr:
 	  }
 	| literal
 	| param_marker
-	| '@' ident_or_text SET_VAR expr
+	| variable
-	  {
-	    $$= new Item_func_set_user_var($2,$4);
-	    LEX *lex= Lex;
-	    lex->uncacheable(UNCACHEABLE_RAND);
-	    lex->variables_used= 1;
-	  }
-	| '@' ident_or_text
-	  {
-	    $$= new Item_func_get_user_var($2);
-	    LEX *lex= Lex;
-	    lex->uncacheable(UNCACHEABLE_RAND);
-	    lex->variables_used= 1;
-	  }
-	| '@' '@' opt_var_ident_type ident_or_text opt_component
-	  {
-
-            if ($4.str && $5.str && check_reserved_words(&$4))
-            {
-              yyerror(ER(ER_SYNTAX_ERROR));
-              YYABORT;
-            }
-	    if (!($$= get_system_var(YYTHD, $3, $4, $5)))
-	      YYABORT;
-	    Lex->variables_used= 1;
-	  }
 	| sum_expr
 	| simple_expr OR_OR_SYM simple_expr
 	  { $$= new Item_func_concat($1, $3); }
@@ -6702,6 +6682,46 @@ sum_expr:
 	    $5->empty();
 	  };
 
+variable:
+          '@'
+          {
+            if (! Lex->parsing_options.allows_variable)
+            {
+              my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+              YYABORT;
+            }
+          }
+          variable_aux
+          {
+            $$= $3;
+          }
+          ;
+
+variable_aux:
+          ident_or_text SET_VAR expr
+          {
+            $$= new Item_func_set_user_var($1, $3);
+            LEX *lex= Lex;
+            lex->uncacheable(UNCACHEABLE_RAND);
+          }
+        | ident_or_text
+          {
+            $$= new Item_func_get_user_var($1);
+            LEX *lex= Lex;
+            lex->uncacheable(UNCACHEABLE_RAND);
+          }
+        | '@' opt_var_ident_type ident_or_text opt_component
+          {
+            if ($3.str && $4.str && check_reserved_words(&$3))
+            {
+              yyerror(ER(ER_SYNTAX_ERROR));
+              YYABORT;
+            }
+            if (!($$= get_system_var(YYTHD, $2, $3, $4)))
+              YYABORT;
+          }
+        ;
+
 opt_distinct:
     /* empty */ { $$ = 0; }
     |DISTINCT   { $$ = 1; };
@@ -6808,7 +6828,7 @@ when_list2:
 /* Warning - may return NULL in case of incomplete SELECT */
 table_ref:
         table_factor            { $$=$1; }
-        | join_table            { $$=$1; }
+        | join_table
           {
 	    LEX *lex= Lex;
             if (!($$= lex->current_select->nest_last_join(lex->thd)))
@@ -6850,7 +6870,7 @@ join_table:
 	| table_ref normal_join table_ref
           ON
           {
-            YYERROR_UNLESS($1 && ($$=$3));
+            YYERROR_UNLESS($1 && $3);
             /* Change the current name resolution context to a local context. */
             if (push_new_name_resolution_context(YYTHD, $1, $3))
               YYABORT;
@@ -6865,7 +6885,7 @@ join_table:
         | table_ref STRAIGHT_JOIN table_factor
           ON
           {
-            YYERROR_UNLESS($1 && ($$=$3));
+            YYERROR_UNLESS($1 && $3);
             /* Change the current name resolution context to a local context. */
             if (push_new_name_resolution_context(YYTHD, $1, $3))
               YYABORT;
@@ -7131,6 +7151,13 @@ select_derived_init:
           SELECT_SYM
           {
             LEX *lex= Lex;
+
+            if (! lex->parsing_options.allows_derived)
+            {
+              my_error(ER_VIEW_SELECT_DERIVED, MYF(0));
+              YYABORT;
+            }
+
             SELECT_LEX *sel= lex->current_select;
             TABLE_LIST *embedding;
             if (!sel->embedding || sel->end_nested_join(lex->thd))
@@ -7515,6 +7542,13 @@ procedure_clause:
 	| PROCEDURE ident			/* Procedure name */
 	  {
 	    LEX *lex=Lex;
+
+            if (! lex->parsing_options.allows_select_procedure)
+            {
+              my_error(ER_VIEW_SELECT_CLAUSE, MYF(0), "PROCEDURE");
+              YYABORT;
+            }
+
 	    if (&lex->select_lex != lex->current_select)
 	    {
 	      my_error(ER_WRONG_USAGE, MYF(0), "PROCEDURE", "subquery");
@@ -7614,28 +7648,40 @@ select_var_ident:
            ;
 
 into:
-        INTO OUTFILE TEXT_STRING_filesystem
+        INTO
+	{
+          if (! Lex->parsing_options.allows_select_into)
+          {
+            my_error(ER_VIEW_SELECT_CLAUSE, MYF(0), "INTO");
+            YYABORT;
+          }
+	}
+        into_destination
+        ;
+
+into_destination:
+        OUTFILE TEXT_STRING_filesystem
 	{
           LEX *lex= Lex;
           lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-          if (!(lex->exchange= new sql_exchange($3.str, 0)) ||
+          if (!(lex->exchange= new sql_exchange($2.str, 0)) ||
               !(lex->result= new select_export(lex->exchange)))
             YYABORT;
 	}
 	opt_field_term opt_line_term
-	| INTO DUMPFILE TEXT_STRING_filesystem
+	| DUMPFILE TEXT_STRING_filesystem
 	{
 	  LEX *lex=Lex;
 	  if (!lex->describe)
 	  {
 	    lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-	    if (!(lex->exchange= new sql_exchange($3.str,1)))
+	    if (!(lex->exchange= new sql_exchange($2.str,1)))
 	      YYABORT;
 	    if (!(lex->result= new select_dump(lex->exchange)))
 	      YYABORT;
 	  }
 	}
-        | INTO select_var_list_init
+        | select_var_list_init
 	{
 	  Lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
 	}
@@ -8844,8 +8890,13 @@ param_marker:
         {
           THD *thd=YYTHD;
 	  LEX *lex= thd->lex;
-          Item_param *item= new Item_param((uint) (lex->tok_start -
+          Item_param *item;
-                                                   (uchar *) thd->query));
+          if (! lex->parsing_options.allows_variable)
+          {
+            my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+            YYABORT;
+          }
+          item= new Item_param((uint) (lex->tok_start - (uchar *) thd->query));
           if (!($$= item) || lex->param_list.push_back(item))
           {
             my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
@@ -8965,6 +9016,12 @@ simple_ident:
 	  if (spc && (spv = spc->find_variable(&$1)))
 	  {
             /* We're compiling a stored procedure and found a variable */
+            if (! lex->parsing_options.allows_variable)
+            {
+              my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+              YYABORT;
+            }
+
             Item_splocal *splocal;
             splocal= new Item_splocal($1, spv->offset, spv->type,
                                       lex->tok_start_prev - 
@@ -8974,7 +9031,6 @@ simple_ident:
               splocal->m_sp= lex->sphead;
 #endif
 	    $$ = (Item*) splocal;
-            lex->variables_used= 1;
 	    lex->safe_to_cache_query=0;
 	  }
 	  else
@@ -10873,6 +10929,24 @@ view_list:
 	;
 
 view_select:
+        {
+          LEX *lex= Lex;
+          lex->parsing_options.allows_variable= FALSE;
+          lex->parsing_options.allows_select_into= FALSE;
+          lex->parsing_options.allows_select_procedure= FALSE;
+          lex->parsing_options.allows_derived= FALSE;
+        }        
+        view_select_aux
+        {
+          LEX *lex= Lex;
+          lex->parsing_options.allows_variable= TRUE;
+          lex->parsing_options.allows_select_into= TRUE;
+          lex->parsing_options.allows_select_procedure= TRUE;
+          lex->parsing_options.allows_derived= TRUE;
+        }
+        ;
+
+view_select_aux:
 	SELECT_SYM remember_name select_init2
 	{
           THD *thd=YYTHD;

sql/strfunc.cc

@@ -312,3 +312,33 @@ outp:
   return (uint32) (to - to_start);
 
 }
+
+
+/*
+  Searches for a LEX_STRING in an LEX_STRING array.
+
+  SYNOPSIS
+    find_string_in_array()
+      heap    The array
+      needle  The string to search for
+
+  NOTE
+    The last LEX_STRING in the array should have str member set to NULL
+
+  RETURN VALUES
+    -1   Not found
+    >=0  Ordinal position
+*/
+
+int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
+                         CHARSET_INFO * const cs)
+{
+  const LEX_STRING *pos;
+  for (pos= haystack; pos->str; pos++)
+    if (!cs->coll->strnncollsp(cs, (uchar *) pos->str, pos->length,
+                               (uchar *) needle->str, needle->length, 0))
+    {
+      return (pos - haystack);
+    }
+  return -1;
+}

sql/table.cc

@@ -363,25 +363,24 @@ int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags)
     error= open_binary_frm(thd, share, head, file);
     *root_ptr= old_root;
 
-    if (share->db.length == 5 &&
+    if (share->db.length == 5 && !(lower_case_table_names ?
-        !my_strcasecmp(system_charset_info, share->db.str, "mysql"))
+        my_strcasecmp(system_charset_info, share->db.str, "mysql") :
+        strcmp(share->db.str, "mysql")))
     {
       /*
         We can't mark all tables in 'mysql' database as system since we don't
         allow to lock such tables for writing with any other tables (even with
         other system tables) and some privilege tables need this.
       */
-      if (!my_strcasecmp(system_charset_info, share->table_name.str, "proc"))
+      if (!(lower_case_table_names ?
+            my_strcasecmp(system_charset_info, share->table_name.str, "proc") :
+            strcmp(share->table_name.str, "proc")))
         share->system_table= 1;
       else
       {
-        if (!my_strcasecmp(system_charset_info, share->table_name.str,
+        share->log_table= check_if_log_table(share->db.length, share->db.str,
-                           "general_log"))
+                                             share->table_name.length,
-          share->log_table= QUERY_LOG_GENERAL;
+                                             share->table_name.str, 0);
-        else
-          if (!my_strcasecmp(system_charset_info, share->table_name.str,
-                             "slow_log"))
-            share->log_table= QUERY_LOG_SLOW;
       }
     }
     error_given= 1;

storage/csv/ha_tina.cc

@@ -826,9 +826,9 @@ void ha_tina::update_status()
 bool ha_tina::check_if_locking_is_allowed(uint sql_command,
                                           ulong type, TABLE *table,
                                           uint count,
-                                          bool called_by_logger_thread)
+                                          bool called_by_privileged_thread)
 {
-  if (!called_by_logger_thread)
+  if (!called_by_privileged_thread)
     return check_if_log_table_locking_is_allowed(sql_command, type, table);
 
   return TRUE;

storage/myisam/ha_myisam.cc

@@ -265,7 +265,7 @@ err:
 bool ha_myisam::check_if_locking_is_allowed(uint sql_command,
                                             ulong type, TABLE *table,
                                             uint count,
-                                            bool called_by_logger_thread)
+                                            bool called_by_privileged_thread)
 {
   /*
     To be able to open and lock for reading system tables like 'mysql.proc',
@@ -283,10 +283,10 @@ bool ha_myisam::check_if_locking_is_allowed(uint sql_command,
 
   /*
     Deny locking of the log tables, which is incompatible with
-    concurrent insert. Unless called from a logger THD:
+    concurrent insert. Unless called from a logger THD (general_log_thd
-    general_log_thd or slow_log_thd.
+    or slow_log_thd) or by a privileged thread.
   */
-  if (!called_by_logger_thread)
+  if (!called_by_privileged_thread)
     return check_if_log_table_locking_is_allowed(sql_command, type, table);
 
   return TRUE;