#At file:///home/ja155679/devel/mysql/mysql-6.0-runtime/
2768 Jorgen Austvik 2009-04-30
wl#4343: Add more stress testing variants
added:
mysql-test/suite/ddl_lock/include/exec_with_error.inc
mysql-test/suite/ddl_lock/r/stress_ddl1.result
mysql-test/suite/ddl_lock/r/stress_ddl2.result
mysql-test/suite/ddl_lock/r/stress_ddl3.result
mysql-test/suite/ddl_lock/r/stress_ddl4.result
mysql-test/suite/ddl_lock/r/stress_ddl5.result
mysql-test/suite/ddl_lock/r/stress_ddl6.result
mysql-test/suite/ddl_lock/r/stress_ddl7.result
mysql-test/suite/ddl_lock/r/stress_ddl8.result
mysql-test/suite/ddl_lock/r/stress_ddl9.result
mysql-test/suite/ddl_lock/r/stress_dml1.result
mysql-test/suite/ddl_lock/r/stress_dml2.result
mysql-test/suite/ddl_lock/r/stress_dml3.result
mysql-test/suite/ddl_lock/r/stress_dml4.result
mysql-test/suite/ddl_lock/r/stress_single_user.result
mysql-test/suite/ddl_lock/t/stress_ddl1.test
mysql-test/suite/ddl_lock/t/stress_ddl2.test
mysql-test/suite/ddl_lock/t/stress_ddl3.test
mysql-test/suite/ddl_lock/t/stress_ddl4.test
mysql-test/suite/ddl_lock/t/stress_ddl5.test
mysql-test/suite/ddl_lock/t/stress_ddl6.test
mysql-test/suite/ddl_lock/t/stress_ddl7.test
mysql-test/suite/ddl_lock/t/stress_ddl8.test
mysql-test/suite/ddl_lock/t/stress_ddl9.test
mysql-test/suite/ddl_lock/t/stress_dml1.test
mysql-test/suite/ddl_lock/t/stress_dml2.test
mysql-test/suite/ddl_lock/t/stress_dml3.test
mysql-test/suite/ddl_lock/t/stress_dml4.test
mysql-test/suite/ddl_lock/t/stress_single_user.test
renamed:
mysql-test/suite/ddl_lock/r/create_stress_tables.result => mysql-test/suite/ddl_lock/r/generate_prerequisites.result
mysql-test/suite/ddl_lock/t/create_stress_tables.test => mysql-test/suite/ddl_lock/t/generate_prerequisites.test
modified:
mysql-test/suite/ddl_lock/README
mysql-test/suite/ddl_lock/include/stress_settings.inc
mysql-test/suite/ddl_lock/include/sync_lock.inc
mysql-test/suite/ddl_lock/r/concurrent_ddl.result
mysql-test/suite/ddl_lock/r/stress_ddl.result
mysql-test/suite/ddl_lock/r/stress_dml.result
mysql-test/suite/ddl_lock/stress_init.txt
mysql-test/suite/ddl_lock/stress_tests.txt
mysql-test/suite/ddl_lock/t/concurrent_ddl.test
mysql-test/suite/ddl_lock/t/stress_ddl.test
mysql-test/suite/ddl_lock/t/stress_dml.test
mysql-test/suite/ddl_lock/r/generate_prerequisites.result
mysql-test/suite/ddl_lock/t/generate_prerequisites.test
=== modified file 'mysql-test/suite/ddl_lock/README'
--- a/mysql-test/suite/ddl_lock/README 2008-12-17 10:11:14 +0000
+++ b/mysql-test/suite/ddl_lock/README 2009-04-30 13:36:12 +0000
@@ -1,6 +1,6 @@
*DDL LOCKING TEST SUITE*
-This is the test suite for WL#4343
+This is the test suite for WL#4343 Testing DDL locking for all metadata objects
Tests:
- concurrent_ddl.test - WL#4343 Part 1. (Functional testing of
@@ -18,5 +18,29 @@ Typical example of running the stress te
This stress test used the tests specified in stress_init.txt and
stress_tests.txt.
+*STORAGE ENGINES*
+
+These tests will be run on MyISAM storage engine as default.
+
+If you want to run with another storage engine, please set
+$engine_type:
+
+ let $engine_type= Falcon;
+ --source suite/ddl_lock/t/concurrent_ddl.test
+
+You can also change the defaults for the stress tests in
+include/stress_settings.inc
+
+*MTR INTERNAL TEST FAIL*
+
+The stress tests in this suite source generate_prerequisites.test,
+which has side effects. This is fine for stress testing, but will make
+mtr fail when you run the tests as a suite. Running the tests as a
+suite is nice for detecting errors in the tests.
+
+If you want to run all these tests as a suite, I recommend you run it
+with --force --no-check-testcases, like:
+
+ ./mtr --suite=ddl_lock --force --no-check-testcases
Jorgen.Austvik@stripped
=== added file 'mysql-test/suite/ddl_lock/include/exec_with_error.inc'
--- a/mysql-test/suite/ddl_lock/include/exec_with_error.inc 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/include/exec_with_error.inc 2009-04-30 13:36:12 +0000
@@ -0,0 +1,59 @@
+#
+# SUMMARY
+#
+# Execute some SQL, and allow some errors.
+#
+# USAGE
+#
+# $sql - The SQL to execute, must be set
+#
+# OPTIONAL
+# $errors - The accepted errors, default = 0.
+# $replace_from - What to search for in the result string
+# $replace_to - What to replace it with
+#
+# If you want to do result replace on the SQL string, use the
+# $replace_from and $replace_to, like you would do in
+# --replace_result $replace_from $replace_to.
+#
+# EXAMPLE
+#
+# let $sql=SELECT * FROM foo;
+# let $errors=0, $ER_TABLE_EXISTS_ERROR;
+# --source suite/ddl_lock/include/exec_with_error.inc
+#
+
+# Default value
+if (`SELECT LENGTH('$errors') = 0`) {
+ let $errors= 0;
+}
+
+# Default value, $sql can contain single quotes.
+if (`SELECT LENGTH("$sql") = 0`) {
+ die Missing SQL expression;
+}
+
+--disable_abort_on_error
+--disable_result_log
+if (`SELECT LENGTH('$replace_from$replace_to') > 0`)
+{
+--replace_result $replace_from $replace_to
+}
+eval $sql;
+--enable_result_log
+--enable_abort_on_error
+let $my_errno= $mysql_errno;
+if (`SELECT $my_errno NOT IN ($errors)`)
+{
+ --echo # Got unexpected error: $my_errno, allowed error codes: $errors
+ --echo # When executing: $sql
+ if (`SELECT LENGTH('$replace_from$replace_to') > 0`)
+ {
+ --echo # Replacing '$replace_from' with '$replace_to'
+ }
+ --echo # Dumping debug information:
+ SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='test';
+ SELECT * FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA='test';
+ SELECT * FROM INFORMATION_SCHEMA.EVENTS WHERE EVENT_SCHEMA='test';
+ exit;
+}
=== modified file 'mysql-test/suite/ddl_lock/include/stress_settings.inc'
--- a/mysql-test/suite/ddl_lock/include/stress_settings.inc 2008-12-17 10:11:14 +0000
+++ b/mysql-test/suite/ddl_lock/include/stress_settings.inc 2009-04-30 13:36:12 +0000
@@ -2,3 +2,35 @@
## Standard settings (global variables) for the stress testing.
##
let $num_stress_rows= 5000;
+let $default_engine_type= myisam;
+
+if (`SELECT LENGTH('$engine_type') = 0`) {
+ let $engine_type= $default_engine_type;
+}
+if (`SELECT '$engine_type' = 'InnoDB'`) {
+ --source include/have_innodb.inc
+}
+if (`SELECT '$engine_type' = 'Falcon'`) {
+ --source include/have_falcon.inc
+}
+
+#
+# How many times to loop in each transaction
+#
+let $num_dml_ops_per_trans= 1000;
+let $num_ddl_ops_per_trans= 100;
+let $num_long_ddl_ops_per_trans= 10;
+
+#
+# Error codes used in test. Have to create them as variables,
+# as mysql-test does not support assigning the error codes directly
+# to variables.
+#
+let $ER_OK= 0;
+let $ER_FILE_NOT_FOUND= 1017;
+let $ER_TABLE_EXISTS_ERROR= 1050;
+let $ER_BAD_TABLE_ERROR= 1051;
+let $ER_DUP_FIELDNAME= 1060;
+let $ER_NO_SUCH_TABLE= 1146;
+let $ER_SP_ALREADY_EXISTS= 1304;
+let $ER_SP_DOES_NOT_EXIST= 1305;
=== modified file 'mysql-test/suite/ddl_lock/include/sync_lock.inc'
--- a/mysql-test/suite/ddl_lock/include/sync_lock.inc 2008-12-17 10:11:14 +0000
+++ b/mysql-test/suite/ddl_lock/include/sync_lock.inc 2009-04-30 13:36:12 +0000
@@ -25,13 +25,13 @@ SET DEBUG_SYNC= 'RESET';
--enable_warnings
# Default value
-if (`SELECT LENGTH("$sync") = 0`) {
+if (`SELECT LENGTH('$sync') = 0`) {
let $sync= mdl_enter_cond;
}
--echo # Connection waiter will run setup (if any)
connection waiter;
-if (`SELECT LENGTH("$setup")`) {
+if (`SELECT LENGTH('$setup')`) {
eval $setup;
}
@@ -63,7 +63,7 @@ UNLOCK TABLES;
--echo # lock is unlocked, and run teardown if we have any
connection waiter;
reap;
-if (`SELECT LENGTH("$teardown")`) {
+if (`SELECT LENGTH('$teardown')`) {
eval $teardown;
}
=== modified file 'mysql-test/suite/ddl_lock/r/concurrent_ddl.result'
--- a/mysql-test/suite/ddl_lock/r/concurrent_ddl.result 2009-02-04 09:11:18 +0000
+++ b/mysql-test/suite/ddl_lock/r/concurrent_ddl.result 2009-04-30 13:36:12 +0000
@@ -103,19 +103,19 @@ SET DEBUG_SYNC= 'RESET';
##
## 1.2 Two connections trying to perform alter on same table/view
##
-CREATE TABLE t1(a INT, b CHAR(100) DEFAULT "test 1.2")
+CREATE TABLE t1(a INT, b CHAR(100) DEFAULT 'test 1.2')
ENGINE=<engine_type>;
INSERT INTO t1 (a) VALUES (1), (2), (3), (4), (5);
# Switch to connection locker
SET DEBUG_SYNC= 'alter_table_before_main_binlog
SIGNAL locked WAIT_FOR do_unlock';
# "send" next statement
-ALTER TABLE t1 ADD COLUMN (c CHAR(100) DEFAULT "test 1.2 locker");
+ALTER TABLE t1 ADD COLUMN (c CHAR(100) DEFAULT 'test 1.2 locker');
# Switch to connection waiter
SET DEBUG_SYNC= 'now WAIT_FOR locked';
SET DEBUG_SYNC= 'mdl_enter_cond SIGNAL do_unlock';
# "send" next statement
-ALTER TABLE t1 ADD COLUMN (d CHAR(100) DEFAULT "test 1.2 waiter");
+ALTER TABLE t1 ADD COLUMN (d CHAR(100) DEFAULT 'test 1.2 waiter');
# Switch to connection locker
# "reap" outcome of last statement
# Switch to connection waiter
@@ -125,7 +125,7 @@ SET DEBUG_SYNC= 'RESET';
SELECT SUM(a) FROM t1;
SUM(a)
15
-SELECT COUNT(*) FROM t1 WHERE NOT c LIKE "test 1.2 %";
+SELECT COUNT(*) FROM t1 WHERE NOT c LIKE 'test 1.2 %';
COUNT(*)
0
DROP TABLE t1;
@@ -233,7 +233,7 @@ INSERT INTO t1 (a) VALUES (1);
SET DEBUG_SYNC= 'alter_table_before_main_binlog
SIGNAL locked WAIT_FOR do_unlock';
# "send" next statement
-ALTER TABLE t1 ADD COLUMN (c CHAR(100) DEFAULT "test 1.5");
+ALTER TABLE t1 ADD COLUMN (c CHAR(100) DEFAULT 'test 1.5');
# Switch to connection waiter
SET DEBUG_SYNC= 'now WAIT_FOR locked';
SET DEBUG_SYNC= 'mdl_enter_cond SIGNAL do_unlock';
@@ -251,13 +251,13 @@ HANDLER t1 CLOSE;
SELECT SUM(a) FROM t1;
SUM(a)
55
-SELECT COUNT(*) FROM t1 WHERE NOT c LIKE "test 1.5";
+SELECT COUNT(*) FROM t1 WHERE NOT c LIKE 'test 1.5';
COUNT(*)
0
SET DEBUG_SYNC= 'RESET';
DROP TABLE t1;
##
-## 1.6 Tow connections are long create/select, while another is
+## 1.6 Two connections are long create/select, while another is
## altering the table
##
# Connections locker1..locker3 will run different SQL queries, which
@@ -382,7 +382,7 @@ SET DEBUG_SYNC= 'RESET';
## and function
##
# Switch to connection default
-CREATE TABLE t1 (id INT PRIMARY KEY, b CHAR(100) DEFAULT "initial value")
+CREATE TABLE t1 (id INT PRIMARY KEY, b CHAR(100) DEFAULT 'initial value')
ENGINE=<engine_type>;
CREATE PROCEDURE t_proc ()
BEGIN
@@ -429,7 +429,7 @@ DROP TABLE t1;
## 1.10 One Connection altering a stored procedure/function, while
## the other is dropping it.
##
-CREATE TABLE t1 (id INT PRIMARY KEY, b CHAR(100) DEFAULT "initial value")
+CREATE TABLE t1 (id INT PRIMARY KEY, b CHAR(100) DEFAULT 'initial value')
ENGINE=<engine_type>;
CREATE PROCEDURE t_proc ()
BEGIN
@@ -472,9 +472,9 @@ ERROR 42000: FUNCTION test.t_func does n
SET DEBUG_SYNC= 'RESET';
DROP table t1;
##
-## 1.11, 1.12 and 1.13 - ALTER TABLE and TRUNCATE TABLE simoultaniously
+## 1.11, 1.12 and 1.13 - ALTER TABLE and TRUNCATE TABLE simultaniously
##
-CREATE TABLE t1(a INT, b CHAR(20) DEFAULT "test 1.11")
+CREATE TABLE t1(a INT, b CHAR(20) DEFAULT 'test 1.11')
ENGINE=<engine_type>;
INSERT INTO t1 (a) VALUES (1);
# Switch to connection locker
=== renamed file 'mysql-test/suite/ddl_lock/r/create_stress_tables.result' => 'mysql-test/suite/ddl_lock/r/generate_prerequisites.result'
--- a/mysql-test/suite/ddl_lock/r/create_stress_tables.result 2008-12-17 10:11:14 +0000
+++ b/mysql-test/suite/ddl_lock/r/generate_prerequisites.result 2009-04-30 13:36:12 +0000
@@ -1,4 +1,4 @@
-CREATE TABLE t1 (id INT PRIMARY KEY, b CHAR(100) DEFAULT "initial value")
+CREATE TABLE t1 (id INT PRIMARY KEY, b CHAR(100) DEFAULT 'initial value')
ENGINE=<engine_type>;
INSERT INTO t1(id) VALUES (1), (2), (3), (4), (5), (6), (7), (8);
SELECT MAX(id) FROM t1 INTO @max;
@@ -31,9 +31,51 @@ WHERE id + @max <= <num_stress_rows>;
SELECT MAX(id) FROM t1 INTO @max;
INSERT INTO t1(id) SELECT id + @max FROM t1
WHERE id + @max <= <num_stress_rows>;
+CREATE TABLE t2 (id INT PRIMARY KEY)
+ENGINE=<engine_type>;
+INSERT INTO t2(id) VALUES (1), (2), (3), (4), (5), (6), (7), (8);
+CREATE TABLE t3 (id INT PRIMARY KEY)
+ENGINE=<engine_type>;
+CREATE TABLE t4 (id INT PRIMARY KEY)
+ENGINE=<engine_type>;
+INSERT INTO t4(id) VALUES (1), (2), (3), (4), (5), (6), (7), (8);
+SELECT MAX(id) FROM t4 INTO @max;
+INSERT INTO t4(id) SELECT id + @max FROM t4
+WHERE id + @max <= <num_stress_rows>;
+SELECT MAX(id) FROM t4 INTO @max;
+INSERT INTO t4(id) SELECT id + @max FROM t4
+WHERE id + @max <= <num_stress_rows>;
+SELECT MAX(id) FROM t4 INTO @max;
+INSERT INTO t4(id) SELECT id + @max FROM t4
+WHERE id + @max <= <num_stress_rows>;
+SELECT MAX(id) FROM t4 INTO @max;
+INSERT INTO t4(id) SELECT id + @max FROM t4
+WHERE id + @max <= <num_stress_rows>;
+SELECT MAX(id) FROM t4 INTO @max;
+INSERT INTO t4(id) SELECT id + @max FROM t4
+WHERE id + @max <= <num_stress_rows>;
+SELECT MAX(id) FROM t4 INTO @max;
+INSERT INTO t4(id) SELECT id + @max FROM t4
+WHERE id + @max <= <num_stress_rows>;
+SELECT MAX(id) FROM t4 INTO @max;
+INSERT INTO t4(id) SELECT id + @max FROM t4
+WHERE id + @max <= <num_stress_rows>;
+SELECT MAX(id) FROM t4 INTO @max;
+INSERT INTO t4(id) SELECT id + @max FROM t4
+WHERE id + @max <= <num_stress_rows>;
+SELECT MAX(id) FROM t4 INTO @max;
+INSERT INTO t4(id) SELECT id + @max FROM t4
+WHERE id + @max <= <num_stress_rows>;
+SELECT MAX(id) FROM t4 INTO @max;
+INSERT INTO t4(id) SELECT id + @max FROM t4
+WHERE id + @max <= <num_stress_rows>;
+CREATE VIEW v1 AS SELECT * FROM t1;
+CREATE VIEW v2 AS SELECT * FROM t2;
CREATE PROCEDURE t_proc (OUT b_p CHAR(100))
BEGIN
SELECT b INTO @b_p FROM t1 WHERE Id = 1;
END|
CREATE FUNCTION t_func (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC
RETURN CONCAT('Hello, ', s, '!');
+CREATE EVENT ev1 ON SCHEDULE AT CURRENT_TIMESTAMP + INTERVAL 1 HOUR DO
+SELECT MOD(29,9);
=== modified file 'mysql-test/suite/ddl_lock/r/stress_ddl.result'
--- a/mysql-test/suite/ddl_lock/r/stress_ddl.result 2008-12-17 10:11:14 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_ddl.result 2009-04-30 13:36:12 +0000
@@ -1,4 +1,5 @@
-ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT "New column";
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
CREATE INDEX <index_name> ON t1 (<column_name>);
SELECT DISTINCT(<column_name>) FROM t1;
<column_name>
@@ -7,9 +8,37 @@ DROP INDEX <index_name> ON t1;
ALTER TABLE t1 DROP COLUMN <column_name>;
CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
-SELECT id FROM <all_view_name> WHERE id = <random_id>;
-id
-<random_id>
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
DROP VIEW <view_name>, <all_view_name>;
ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_id>';
ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_id>';
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
=== added file 'mysql-test/suite/ddl_lock/r/stress_ddl1.result'
--- a/mysql-test/suite/ddl_lock/r/stress_ddl1.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_ddl1.result 2009-04-30 13:36:12 +0000
@@ -0,0 +1,140 @@
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
+CREATE INDEX <index_name> ON t1 (<column_name>);
+SELECT DISTINCT(<column_name>) FROM t1;
+<column_name>
+New column
+DROP INDEX <index_name> ON t1;
+ALTER TABLE t1 DROP COLUMN <column_name>;
+CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
+CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
+DROP VIEW <view_name>, <all_view_name>;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
+CREATE INDEX <index_name> ON t1 (<column_name>);
+SELECT DISTINCT(<column_name>) FROM t1;
+<column_name>
+New column
+DROP INDEX <index_name> ON t1;
+ALTER TABLE t1 DROP COLUMN <column_name>;
+CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
+CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
+DROP VIEW <view_name>, <all_view_name>;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
+CREATE INDEX <index_name> ON t1 (<column_name>);
+SELECT DISTINCT(<column_name>) FROM t1;
+<column_name>
+New column
+DROP INDEX <index_name> ON t1;
+ALTER TABLE t1 DROP COLUMN <column_name>;
+CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
+CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
+DROP VIEW <view_name>, <all_view_name>;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
+CREATE INDEX <index_name> ON t1 (<column_name>);
+SELECT DISTINCT(<column_name>) FROM t1;
+<column_name>
+New column
+DROP INDEX <index_name> ON t1;
+ALTER TABLE t1 DROP COLUMN <column_name>;
+CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
+CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
+DROP VIEW <view_name>, <all_view_name>;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
+CREATE INDEX <index_name> ON t1 (<column_name>);
+SELECT DISTINCT(<column_name>) FROM t1;
+<column_name>
+New column
+DROP INDEX <index_name> ON t1;
+ALTER TABLE t1 DROP COLUMN <column_name>;
+CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
+CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
+DROP VIEW <view_name>, <all_view_name>;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
+CREATE INDEX <index_name> ON t1 (<column_name>);
+SELECT DISTINCT(<column_name>) FROM t1;
+<column_name>
+New column
+DROP INDEX <index_name> ON t1;
+ALTER TABLE t1 DROP COLUMN <column_name>;
+CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
+CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
+DROP VIEW <view_name>, <all_view_name>;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
+CREATE INDEX <index_name> ON t1 (<column_name>);
+SELECT DISTINCT(<column_name>) FROM t1;
+<column_name>
+New column
+DROP INDEX <index_name> ON t1;
+ALTER TABLE t1 DROP COLUMN <column_name>;
+CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
+CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
+DROP VIEW <view_name>, <all_view_name>;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
+CREATE INDEX <index_name> ON t1 (<column_name>);
+SELECT DISTINCT(<column_name>) FROM t1;
+<column_name>
+New column
+DROP INDEX <index_name> ON t1;
+ALTER TABLE t1 DROP COLUMN <column_name>;
+CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
+CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
+DROP VIEW <view_name>, <all_view_name>;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
+CREATE INDEX <index_name> ON t1 (<column_name>);
+SELECT DISTINCT(<column_name>) FROM t1;
+<column_name>
+New column
+DROP INDEX <index_name> ON t1;
+ALTER TABLE t1 DROP COLUMN <column_name>;
+CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
+CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
+DROP VIEW <view_name>, <all_view_name>;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+ALTER TABLE t1 ADD COLUMN <column_name> CHAR(200) DEFAULT 'New column';
+CREATE INDEX <index_name> ON t1 (<column_name>);
+SELECT DISTINCT(<column_name>) FROM t1;
+<column_name>
+New column
+DROP INDEX <index_name> ON t1;
+ALTER TABLE t1 DROP COLUMN <column_name>;
+CREATE VIEW <view_name> AS SELECT DISTINCT b FROM t1;
+CREATE VIEW <all_view_name> AS SELECT id, b FROM t1;
+SELECT 'Yes' AS "found" FROM <all_view_name> WHERE id = @rowid;
+found
+Yes
+DROP VIEW <view_name>, <all_view_name>;
=== added file 'mysql-test/suite/ddl_lock/r/stress_ddl2.result'
--- a/mysql-test/suite/ddl_lock/r/stress_ddl2.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_ddl2.result 2009-04-30 13:36:12 +0000
@@ -0,0 +1,200 @@
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 100';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 100';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 99';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 99';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 98';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 98';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 97';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 97';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 96';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 96';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 95';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 95';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 94';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 94';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 93';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 93';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 92';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 92';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 91';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 91';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 90';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 90';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 89';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 89';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 88';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 88';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 87';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 87';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 86';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 86';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 85';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 85';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 84';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 84';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 83';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 83';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 82';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 82';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 81';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 81';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 80';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 80';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 79';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 79';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 78';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 78';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 77';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 77';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 76';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 76';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 75';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 75';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 74';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 74';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 73';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 73';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 72';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 72';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 71';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 71';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 70';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 70';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 69';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 69';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 68';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 68';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 67';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 67';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 66';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 66';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 65';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 65';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 64';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 64';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 63';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 63';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 62';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 62';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 61';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 61';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 60';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 60';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 59';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 59';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 58';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 58';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 57';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 57';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 56';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 56';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 55';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 55';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 54';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 54';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 53';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 53';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 52';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 52';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 51';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 51';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 50';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 50';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 49';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 49';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 48';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 48';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 47';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 47';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 46';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 46';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 45';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 45';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 44';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 44';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 43';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 43';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 42';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 42';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 41';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 41';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 40';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 40';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 39';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 39';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 38';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 38';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 37';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 37';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 36';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 36';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 35';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 35';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 34';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 34';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 33';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 33';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 32';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 32';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 31';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 31';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 30';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 30';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 29';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 29';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 28';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 28';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 27';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 27';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 26';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 26';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 25';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 25';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 24';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 24';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 23';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 23';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 22';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 22';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 21';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 21';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 20';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 20';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 19';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 19';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 18';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 18';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 17';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 17';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 16';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 16';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 15';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 15';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 14';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 14';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 13';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 13';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 12';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 12';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 11';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 11';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 10';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 10';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 9';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 9';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 8';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 8';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 7';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 7';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 6';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 6';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 5';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 5';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 4';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 4';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 3';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 3';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 2';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 2';
+ALTER PROCEDURE t_proc COMMENT 'Now with a comment from conn <conn_nr>: 1';
+ALTER FUNCTION t_func COMMENT 'Now with a comment from conn <conn_nr>: 1';
=== added file 'mysql-test/suite/ddl_lock/r/stress_ddl3.result'
--- a/mysql-test/suite/ddl_lock/r/stress_ddl3.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_ddl3.result 2009-04-30 13:36:12 +0000
@@ -0,0 +1,800 @@
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
+LOCK TABLES t2 READ;
+UNLOCK TABLES;
+ALTER TABLE t2 ADD COLUMN (b_<conn_nr> INT);
+ALTER TABLE t2 DROP COLUMN b_<conn_nr>;
+TRUNCATE TABLE t3;
+HANDLER t2 OPEN;
+HANDLER t2 READ FIRST;
+HANDLER t2 CLOSE;
=== added file 'mysql-test/suite/ddl_lock/r/stress_ddl4.result'
--- a/mysql-test/suite/ddl_lock/r/stress_ddl4.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_ddl4.result 2009-04-30 13:36:12 +0000
@@ -0,0 +1,40 @@
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
+CREATE TABLE t5 (id INT PRIMARY KEY) ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+ALTER TABLE t5 ADD COLUMN (b CHAR(100));
+DROP TABLE t5;
=== added file 'mysql-test/suite/ddl_lock/r/stress_ddl5.result'
--- a/mysql-test/suite/ddl_lock/r/stress_ddl5.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_ddl5.result 2009-04-30 13:36:12 +0000
@@ -0,0 +1,30 @@
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
+CREATE TABLE t2_<conn_nr> ENGINE=<engine_type> AS
+SELECT *, SLEEP(1) FROM t2;
+DROP TABLE t2_<conn_nr>;
=== added file 'mysql-test/suite/ddl_lock/r/stress_ddl6.result'
--- a/mysql-test/suite/ddl_lock/r/stress_ddl6.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_ddl6.result 2009-04-30 13:36:12 +0000
@@ -0,0 +1,200 @@
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
+RENAME TABLE t4 TO t4_new;
+RENAME TABLE t4_new TO t4;
=== added file 'mysql-test/suite/ddl_lock/r/stress_ddl7.result'
--- a/mysql-test/suite/ddl_lock/r/stress_ddl7.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_ddl7.result 2009-04-30 13:36:12 +0000
@@ -0,0 +1,400 @@
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
+CREATE TABLE t6 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t7 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+CREATE TABLE t8 (id INT PRIMARY KEY) ENGINE=<engine_type>;
+DROP TABLE IF EXISTS t6, t7, t8;
=== added file 'mysql-test/suite/ddl_lock/r/stress_ddl8.result'
--- a/mysql-test/suite/ddl_lock/r/stress_ddl8.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_ddl8.result 2009-04-30 13:36:12 +0000
@@ -0,0 +1,300 @@
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
+CREATE FUNCTION t_func2 (s CHAR(20)) RETURNS CHAR(30) DETERMINISTIC RETURN CONCAT('Hello, ', s, '!');
+ALTER FUNCTION t_func2 COMMENT 'Now with a comment from <conn_nr>';
+DROP FUNCTION t_func2;
=== added file 'mysql-test/suite/ddl_lock/r/stress_ddl9.result'
--- a/mysql-test/suite/ddl_lock/r/stress_ddl9.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_ddl9.result 2009-04-30 13:36:12 +0000
@@ -0,0 +1,400 @@
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 12 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
+ALTER EVENT ev1 ON SCHEDULE EVERY 11 HOUR
+STARTS CURRENT_TIMESTAMP + INTERVAL 1 HOUR;
=== modified file 'mysql-test/suite/ddl_lock/r/stress_dml.result'
--- a/mysql-test/suite/ddl_lock/r/stress_dml.result 2008-12-17 10:11:14 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_dml.result 2009-04-30 13:36:12 +0000
@@ -1,12 +1,13 @@
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
START TRANSACTION;
-UPDATE t1 SET b = "changed" WHERE id=<random>;
-SELECT id,b FROM t1 WHERE id=<random>;
-id b
-<random> changed
+UPDATE t1 SET b = 'changed' WHERE id=@rowid;
+SELECT b FROM t1 WHERE id=@rowid;
+b
+changed
COMMIT;
START TRANSACTION;
-DELETE FROM t1 WHERE id=<random>;
-INSERT INTO t1 (id, b) VALUES (<random>, "newly_inserted");
+DELETE FROM t1 WHERE id=@rowid;
+INSERT INTO t1 (id, b) VALUES (@rowid, 'newly_inserted');
COMMIT;
CALL t_proc(@b);
SELECT @b;
=== added file 'mysql-test/suite/ddl_lock/r/stress_dml1.result'
--- a/mysql-test/suite/ddl_lock/r/stress_dml1.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/ddl_lock/r/stress_dml1.result 2009-04-30 13:36:12 +0000
@@ -0,0 +1,6000 @@
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHERE id=@row_id;
+SELECT id, b FROM t1 WHERE id=@row_id;
+id b
+COMMIT;
+SET @rowid = ROUND(RAND() * <num_stress_rows>);
+START TRANSACTION;
+UPDATE t1 SET b = 'changed' WHER 