# This test doesn't work with the embedded version as this code
# assumes that one query is running while we are doing queries on
# a second connection.
# This would work if mysqltest run would be threaded and handle each
# connection in a separate thread.
#
-- source include/not_embedded.inc

# Disable concurrent inserts to avoid test failures when reading the
# connection id which was inserted into a table by another thread.
set @old_concurrent_insert= @@global.concurrent_insert;
set @@global.concurrent_insert= 0;

connect (con1, localhost, root,,);
connect (con2, localhost, root,,);

#remember id of con1
connection con1;
--disable_warnings
drop table if exists t1, t2, t3;
--enable_warnings

--disable_reconnect
create table t1 (kill_id int);
insert into t1 values(connection_id());

#kill con1
connection con2;
select ((@id := kill_id) - kill_id) from t1; 
kill @id;

connection con1;
--sleep 2

--disable_query_log
--disable_result_log
# One of the following statements should fail
--error 0,2006,2013
select 1;
--error 0,2006,2013
select 1;
--enable_query_log
--enable_result_log

--enable_reconnect
# this should work, and we should have a new connection_id()
select ((@id := kill_id) - kill_id) from t1;
select @id != connection_id();

#make sure the server is still alive
connection con2;
select 4;
drop table t1;
connection default;

--error ER_NOT_SUPPORTED_YET
kill (select count(*) from mysql.user);

#
# BUG#14851: killing long running subquery processed via a temporary table.
#
create table t1 (id int primary key);
create table t2 (id int unsigned not null);

connect (conn1, localhost, root,,);
connection conn1;

-- disable_result_log
-- disable_query_log
let $1 = 4096;
while ($1)
{
  eval insert into t1 values ($1);
  dec $1;
}
-- enable_query_log
-- enable_result_log

insert into t2 select id from t1;

create table t3 (kill_id int);
insert into t3 values(connection_id());

connect (conn2, localhost, root,,);
connection conn2;

connection conn1;
-- disable_result_log
# This is a very long running query. If this test start failing, it may
# be necessary to change to an even longer query.
send select id from t1 where id in (select distinct a.id from t2 a, t2 b, t2 c, t2 d group by a.id, b.id, c.id, d.id having a.id between 10 and 20);
-- enable_result_log

connection conn2;
select ((@id := kill_id) - kill_id) from t3;
-- sleep 1
kill @id;

connection conn1;
-- error 1053,2013
reap;

connection default;

drop table t1, t2, t3;

# End of 4.1 tests

#
# test of blocking of sending ERROR after OK or EOF
#
connection con1;
select get_lock("a", 10);
connection con2;
let $ID= `select connection_id()`;
send select get_lock("a", 10);
real_sleep 2;
connection con1;
disable_query_log;
eval kill query $ID;
enable_query_log;
connection con2;
reap;
select 1;
connection con1;
select RELEASE_LOCK("a");

#
# Bug#27563: Stored functions and triggers wasn't throwing an error when killed.
#
create table t1(f1 int);
delimiter |;
create function bug27563() returns int(11)
deterministic
begin
  declare continue handler for sqlstate '70100' set @a:= 'killed';
  declare continue handler for sqlexception set @a:= 'exception';
  set @a= get_lock("lock27563", 10);
  return 1;
end|
delimiter ;|
# Test stored functions
# Test INSERT
connection con1;
select get_lock("lock27563",10);
connection con2;
let $ID= `select connection_id()`;
send insert into t1 values (bug27563());
real_sleep 2;
connection con1;
disable_query_log;
eval kill query $ID;
enable_query_log;
connection con2;
--error 1317
reap;
select @a;
connection con1;
select * from t1;

# Test UPDATE
insert into t1 values(0);
connection con2;
send update t1 set f1= bug27563();
real_sleep 2;
connection con1;
disable_query_log;
eval kill query $ID;
enable_query_log;
connection con2;
--error 1317
reap;
select @a;
connection con1;
select * from t1;

# Test DELETE
insert into t1 values(1);
connection con2;
send delete from t1 where bug27563() is null;
real_sleep 2;
connection con1;
disable_query_log;
eval kill query $ID;
enable_query_log;
connection con2;
--error 1317
reap;
select @a;
connection con1;
select * from t1;

# Test SELECT
connection con2;
send select * from t1 where f1= bug27563();
real_sleep 2;
connection con1;
disable_query_log;
eval kill query $ID;
enable_query_log;
connection con2;
--error 1317
reap;
select @a;

# Test PROCEDURE
connection con2;
delimiter |;
create procedure proc27563()
begin
  declare continue handler for sqlstate '70100' set @a:= 'killed';
  declare continue handler for sqlexception set @a:= 'exception';
  select get_lock("lock27563",10);
  select "shouldn't be selected";
end|
delimiter ;|
send call proc27563();
real_sleep 2;
connection con1;
disable_query_log;
eval kill query $ID;
enable_query_log;
connection con2;
--error 1317
reap;
select @a;

# Test TRIGGERS
connection con2;
create table t2 (f2 int);
delimiter |;
create trigger trg27563 before insert on t1 for each row 
begin 
  declare continue handler for sqlstate '70100' set @a:= 'killed';
  declare continue handler for sqlexception set @a:= 'exception';
  set @a:= get_lock("lock27563",10);
  insert into t2 values(1);
end|
delimiter ;|
send insert into t1 values(2),(3);
real_sleep 2;
connection con1;
disable_query_log;
eval kill query $ID;
enable_query_log;
connection con2;
--error 1317
reap;
select @a;
connection con1;
select * from t1;
select * from t2;

# Cleanup
select release_lock("lock27563");
drop table t1, t2;
drop function bug27563;
drop procedure proc27563;

#
# Bug#28598: mysqld crash when killing a long-running explain query.
#
--disable_query_log
connection con1;
let $ID= `select connection_id()`;
let $tab_count= 40;

let $i= $tab_count;
while ($i)
{
  eval CREATE TABLE t$i (a$i int, KEY(a$i));
  eval INSERT INTO t$i VALUES (1),(2),(3),(4),(5),(6),(7);
  dec $i ;
}
set session optimizer_search_depth=0;

let $i=$tab_count;
while ($i)
{
 let $a= a$i;
 let $t= t$i;
 dec $i;
 if ($i)
 {
   let $comma=,;
   let $from=$comma$t$from;
   let $where=a$i=$a $and $where;
 }
 if (!$i) 
 {
   let $from=FROM $t$from;
   let $where=WHERE $where;
 }
 let $and=AND;
}

--enable_query_log
eval PREPARE stmt FROM 'EXPLAIN SELECT * $from $where';
send EXECUTE stmt;
--disable_query_log

connection con2;
real_sleep 2;
eval kill query $ID;
let $i= $tab_count;
while ($i)
{
  eval DROP TABLE t$i;
  dec $i ;
}
--enable_query_log

###########################################################################

--echo #
--echo # Bug#19723: kill of active connection yields different error code
--echo # depending on platform.
--echo #

--echo
--echo # Connection: con2.
--connection con2

KILL CONNECTION_ID();

--echo # CR_SERVER_LOST, CR_SERVER_GONE_ERROR, depending on the timing 
--echo # of close of the connection socket
--error 2013, 2006 
SELECT 1;
--connection default

###########################################################################

# Restore global concurrent_insert value. Keep in the end of the test file.
set @@global.concurrent_insert= @old_concurrent_insert;
