~drizzle-trunk/drizzle/development

# 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");

create table t1(f1 int);

# 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;

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

--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;