List:Commits« Previous MessageNext Message »
From:Andrei Elkin Date:February 19 2011 4:26pm
Subject:bzr commit into mysql-next-mr-wl5569 branch (andrei.elkin:3271) WL#5754
View as plain text  
#At file:///home/andrei/MySQL/BZR/2a-23May/WL/mysql-next-mr-wl5569/ based on revid:andrei.elkin@stripped

 3271 Andrei Elkin	2011-02-19
      wl#5754 Query parallel replication.
      
      A base of the DDL patch that captures most of the ddl cases and provides tests.
      
      Todo:
      1. to complete with the remained create/drop o ftablespace, view,  logfile-group, server.
      2. to cover every case with a test
      3. to check with a test how out-of-max db limit or no db:s in the status var 
         are sequentially handled.                   
     @ mysql-test/suite/rpl/r/rpl_parallel_ddl.result
        the new test results are added.
     @ mysql-test/suite/rpl/t/rpl_parallel_ddl.test
        DDL specifics for parallelization tests are added.
     @ sql/binlog.cc
        separating out multiple db gathering into a THD method to be invoked as for DML so
        for few cases of DDL.
     @ sql/events.cc
        gathering updated dbs for create/drop events.
     @ sql/sp.cc
        covering db gathering for create/drop SP.
     @ sql/sql_class.h
        adding two base methods of db gathering: one for a queries that can update only one db,
        and the other for multiple db:s.
     @ sql/sql_db.cc
        create/drop database case of db gathering.
     @ sql/sql_rename.cc
        rename table(s) case of db gathering.
     @ sql/sql_table.cc
        create, drop, alter cases of db gathering.
     @ sql/sql_trigger.cc
        create/drop trigger case of db gathering.

    added:
      mysql-test/suite/rpl/r/rpl_parallel_ddl.result
      mysql-test/suite/rpl/t/rpl_parallel_ddl.test
    modified:
      sql/binlog.cc
      sql/events.cc
      sql/sp.cc
      sql/sql_class.h
      sql/sql_db.cc
      sql/sql_rename.cc
      sql/sql_table.cc
      sql/sql_trigger.cc
=== added file 'mysql-test/suite/rpl/r/rpl_parallel_ddl.result'
--- a/mysql-test/suite/rpl/r/rpl_parallel_ddl.result	1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/rpl/r/rpl_parallel_ddl.result	2011-02-19 16:26:33 +0000
@@ -0,0 +1,1065 @@
+include/master-slave.inc
+[connection master]
+include/stop_slave.inc
+set @save.mts_slave_parallel_workers= @@global.mts_slave_parallel_workers;
+set @@global.mts_slave_parallel_workers= 4;
+create database d32;
+create table d32.t8 (a int);
+select round(rand()*8) into @var;
+insert into d32.t8 values (@var);
+create table d32.t7 (a int);
+select round(rand()*8) into @var;
+insert into d32.t7 values (@var);
+create table d32.t6 (a int);
+select round(rand()*8) into @var;
+insert into d32.t6 values (@var);
+create table d32.t5 (a int);
+select round(rand()*8) into @var;
+insert into d32.t5 values (@var);
+create table d32.t4 (a int);
+select round(rand()*8) into @var;
+insert into d32.t4 values (@var);
+create table d32.t3 (a int);
+select round(rand()*8) into @var;
+insert into d32.t3 values (@var);
+create table d32.t2 (a int);
+select round(rand()*8) into @var;
+insert into d32.t2 values (@var);
+create table d32.t1 (a int);
+select round(rand()*8) into @var;
+insert into d32.t1 values (@var);
+create database d31;
+create table d31.t8 (a int);
+select round(rand()*8) into @var;
+insert into d31.t8 values (@var);
+create table d31.t7 (a int);
+select round(rand()*8) into @var;
+insert into d31.t7 values (@var);
+create table d31.t6 (a int);
+select round(rand()*8) into @var;
+insert into d31.t6 values (@var);
+create table d31.t5 (a int);
+select round(rand()*8) into @var;
+insert into d31.t5 values (@var);
+create table d31.t4 (a int);
+select round(rand()*8) into @var;
+insert into d31.t4 values (@var);
+create table d31.t3 (a int);
+select round(rand()*8) into @var;
+insert into d31.t3 values (@var);
+create table d31.t2 (a int);
+select round(rand()*8) into @var;
+insert into d31.t2 values (@var);
+create table d31.t1 (a int);
+select round(rand()*8) into @var;
+insert into d31.t1 values (@var);
+create database d30;
+create table d30.t8 (a int);
+select round(rand()*8) into @var;
+insert into d30.t8 values (@var);
+create table d30.t7 (a int);
+select round(rand()*8) into @var;
+insert into d30.t7 values (@var);
+create table d30.t6 (a int);
+select round(rand()*8) into @var;
+insert into d30.t6 values (@var);
+create table d30.t5 (a int);
+select round(rand()*8) into @var;
+insert into d30.t5 values (@var);
+create table d30.t4 (a int);
+select round(rand()*8) into @var;
+insert into d30.t4 values (@var);
+create table d30.t3 (a int);
+select round(rand()*8) into @var;
+insert into d30.t3 values (@var);
+create table d30.t2 (a int);
+select round(rand()*8) into @var;
+insert into d30.t2 values (@var);
+create table d30.t1 (a int);
+select round(rand()*8) into @var;
+insert into d30.t1 values (@var);
+create database d29;
+create table d29.t8 (a int);
+select round(rand()*8) into @var;
+insert into d29.t8 values (@var);
+create table d29.t7 (a int);
+select round(rand()*8) into @var;
+insert into d29.t7 values (@var);
+create table d29.t6 (a int);
+select round(rand()*8) into @var;
+insert into d29.t6 values (@var);
+create table d29.t5 (a int);
+select round(rand()*8) into @var;
+insert into d29.t5 values (@var);
+create table d29.t4 (a int);
+select round(rand()*8) into @var;
+insert into d29.t4 values (@var);
+create table d29.t3 (a int);
+select round(rand()*8) into @var;
+insert into d29.t3 values (@var);
+create table d29.t2 (a int);
+select round(rand()*8) into @var;
+insert into d29.t2 values (@var);
+create table d29.t1 (a int);
+select round(rand()*8) into @var;
+insert into d29.t1 values (@var);
+create database d28;
+create table d28.t8 (a int);
+select round(rand()*8) into @var;
+insert into d28.t8 values (@var);
+create table d28.t7 (a int);
+select round(rand()*8) into @var;
+insert into d28.t7 values (@var);
+create table d28.t6 (a int);
+select round(rand()*8) into @var;
+insert into d28.t6 values (@var);
+create table d28.t5 (a int);
+select round(rand()*8) into @var;
+insert into d28.t5 values (@var);
+create table d28.t4 (a int);
+select round(rand()*8) into @var;
+insert into d28.t4 values (@var);
+create table d28.t3 (a int);
+select round(rand()*8) into @var;
+insert into d28.t3 values (@var);
+create table d28.t2 (a int);
+select round(rand()*8) into @var;
+insert into d28.t2 values (@var);
+create table d28.t1 (a int);
+select round(rand()*8) into @var;
+insert into d28.t1 values (@var);
+create database d27;
+create table d27.t8 (a int);
+select round(rand()*8) into @var;
+insert into d27.t8 values (@var);
+create table d27.t7 (a int);
+select round(rand()*8) into @var;
+insert into d27.t7 values (@var);
+create table d27.t6 (a int);
+select round(rand()*8) into @var;
+insert into d27.t6 values (@var);
+create table d27.t5 (a int);
+select round(rand()*8) into @var;
+insert into d27.t5 values (@var);
+create table d27.t4 (a int);
+select round(rand()*8) into @var;
+insert into d27.t4 values (@var);
+create table d27.t3 (a int);
+select round(rand()*8) into @var;
+insert into d27.t3 values (@var);
+create table d27.t2 (a int);
+select round(rand()*8) into @var;
+insert into d27.t2 values (@var);
+create table d27.t1 (a int);
+select round(rand()*8) into @var;
+insert into d27.t1 values (@var);
+create database d26;
+create table d26.t8 (a int);
+select round(rand()*8) into @var;
+insert into d26.t8 values (@var);
+create table d26.t7 (a int);
+select round(rand()*8) into @var;
+insert into d26.t7 values (@var);
+create table d26.t6 (a int);
+select round(rand()*8) into @var;
+insert into d26.t6 values (@var);
+create table d26.t5 (a int);
+select round(rand()*8) into @var;
+insert into d26.t5 values (@var);
+create table d26.t4 (a int);
+select round(rand()*8) into @var;
+insert into d26.t4 values (@var);
+create table d26.t3 (a int);
+select round(rand()*8) into @var;
+insert into d26.t3 values (@var);
+create table d26.t2 (a int);
+select round(rand()*8) into @var;
+insert into d26.t2 values (@var);
+create table d26.t1 (a int);
+select round(rand()*8) into @var;
+insert into d26.t1 values (@var);
+create database d25;
+create table d25.t8 (a int);
+select round(rand()*8) into @var;
+insert into d25.t8 values (@var);
+create table d25.t7 (a int);
+select round(rand()*8) into @var;
+insert into d25.t7 values (@var);
+create table d25.t6 (a int);
+select round(rand()*8) into @var;
+insert into d25.t6 values (@var);
+create table d25.t5 (a int);
+select round(rand()*8) into @var;
+insert into d25.t5 values (@var);
+create table d25.t4 (a int);
+select round(rand()*8) into @var;
+insert into d25.t4 values (@var);
+create table d25.t3 (a int);
+select round(rand()*8) into @var;
+insert into d25.t3 values (@var);
+create table d25.t2 (a int);
+select round(rand()*8) into @var;
+insert into d25.t2 values (@var);
+create table d25.t1 (a int);
+select round(rand()*8) into @var;
+insert into d25.t1 values (@var);
+create database d24;
+create table d24.t8 (a int);
+select round(rand()*8) into @var;
+insert into d24.t8 values (@var);
+create table d24.t7 (a int);
+select round(rand()*8) into @var;
+insert into d24.t7 values (@var);
+create table d24.t6 (a int);
+select round(rand()*8) into @var;
+insert into d24.t6 values (@var);
+create table d24.t5 (a int);
+select round(rand()*8) into @var;
+insert into d24.t5 values (@var);
+create table d24.t4 (a int);
+select round(rand()*8) into @var;
+insert into d24.t4 values (@var);
+create table d24.t3 (a int);
+select round(rand()*8) into @var;
+insert into d24.t3 values (@var);
+create table d24.t2 (a int);
+select round(rand()*8) into @var;
+insert into d24.t2 values (@var);
+create table d24.t1 (a int);
+select round(rand()*8) into @var;
+insert into d24.t1 values (@var);
+create database d23;
+create table d23.t8 (a int);
+select round(rand()*8) into @var;
+insert into d23.t8 values (@var);
+create table d23.t7 (a int);
+select round(rand()*8) into @var;
+insert into d23.t7 values (@var);
+create table d23.t6 (a int);
+select round(rand()*8) into @var;
+insert into d23.t6 values (@var);
+create table d23.t5 (a int);
+select round(rand()*8) into @var;
+insert into d23.t5 values (@var);
+create table d23.t4 (a int);
+select round(rand()*8) into @var;
+insert into d23.t4 values (@var);
+create table d23.t3 (a int);
+select round(rand()*8) into @var;
+insert into d23.t3 values (@var);
+create table d23.t2 (a int);
+select round(rand()*8) into @var;
+insert into d23.t2 values (@var);
+create table d23.t1 (a int);
+select round(rand()*8) into @var;
+insert into d23.t1 values (@var);
+create database d22;
+create table d22.t8 (a int);
+select round(rand()*8) into @var;
+insert into d22.t8 values (@var);
+create table d22.t7 (a int);
+select round(rand()*8) into @var;
+insert into d22.t7 values (@var);
+create table d22.t6 (a int);
+select round(rand()*8) into @var;
+insert into d22.t6 values (@var);
+create table d22.t5 (a int);
+select round(rand()*8) into @var;
+insert into d22.t5 values (@var);
+create table d22.t4 (a int);
+select round(rand()*8) into @var;
+insert into d22.t4 values (@var);
+create table d22.t3 (a int);
+select round(rand()*8) into @var;
+insert into d22.t3 values (@var);
+create table d22.t2 (a int);
+select round(rand()*8) into @var;
+insert into d22.t2 values (@var);
+create table d22.t1 (a int);
+select round(rand()*8) into @var;
+insert into d22.t1 values (@var);
+create database d21;
+create table d21.t8 (a int);
+select round(rand()*8) into @var;
+insert into d21.t8 values (@var);
+create table d21.t7 (a int);
+select round(rand()*8) into @var;
+insert into d21.t7 values (@var);
+create table d21.t6 (a int);
+select round(rand()*8) into @var;
+insert into d21.t6 values (@var);
+create table d21.t5 (a int);
+select round(rand()*8) into @var;
+insert into d21.t5 values (@var);
+create table d21.t4 (a int);
+select round(rand()*8) into @var;
+insert into d21.t4 values (@var);
+create table d21.t3 (a int);
+select round(rand()*8) into @var;
+insert into d21.t3 values (@var);
+create table d21.t2 (a int);
+select round(rand()*8) into @var;
+insert into d21.t2 values (@var);
+create table d21.t1 (a int);
+select round(rand()*8) into @var;
+insert into d21.t1 values (@var);
+create database d20;
+create table d20.t8 (a int);
+select round(rand()*8) into @var;
+insert into d20.t8 values (@var);
+create table d20.t7 (a int);
+select round(rand()*8) into @var;
+insert into d20.t7 values (@var);
+create table d20.t6 (a int);
+select round(rand()*8) into @var;
+insert into d20.t6 values (@var);
+create table d20.t5 (a int);
+select round(rand()*8) into @var;
+insert into d20.t5 values (@var);
+create table d20.t4 (a int);
+select round(rand()*8) into @var;
+insert into d20.t4 values (@var);
+create table d20.t3 (a int);
+select round(rand()*8) into @var;
+insert into d20.t3 values (@var);
+create table d20.t2 (a int);
+select round(rand()*8) into @var;
+insert into d20.t2 values (@var);
+create table d20.t1 (a int);
+select round(rand()*8) into @var;
+insert into d20.t1 values (@var);
+create database d19;
+create table d19.t8 (a int);
+select round(rand()*8) into @var;
+insert into d19.t8 values (@var);
+create table d19.t7 (a int);
+select round(rand()*8) into @var;
+insert into d19.t7 values (@var);
+create table d19.t6 (a int);
+select round(rand()*8) into @var;
+insert into d19.t6 values (@var);
+create table d19.t5 (a int);
+select round(rand()*8) into @var;
+insert into d19.t5 values (@var);
+create table d19.t4 (a int);
+select round(rand()*8) into @var;
+insert into d19.t4 values (@var);
+create table d19.t3 (a int);
+select round(rand()*8) into @var;
+insert into d19.t3 values (@var);
+create table d19.t2 (a int);
+select round(rand()*8) into @var;
+insert into d19.t2 values (@var);
+create table d19.t1 (a int);
+select round(rand()*8) into @var;
+insert into d19.t1 values (@var);
+create database d18;
+create table d18.t8 (a int);
+select round(rand()*8) into @var;
+insert into d18.t8 values (@var);
+create table d18.t7 (a int);
+select round(rand()*8) into @var;
+insert into d18.t7 values (@var);
+create table d18.t6 (a int);
+select round(rand()*8) into @var;
+insert into d18.t6 values (@var);
+create table d18.t5 (a int);
+select round(rand()*8) into @var;
+insert into d18.t5 values (@var);
+create table d18.t4 (a int);
+select round(rand()*8) into @var;
+insert into d18.t4 values (@var);
+create table d18.t3 (a int);
+select round(rand()*8) into @var;
+insert into d18.t3 values (@var);
+create table d18.t2 (a int);
+select round(rand()*8) into @var;
+insert into d18.t2 values (@var);
+create table d18.t1 (a int);
+select round(rand()*8) into @var;
+insert into d18.t1 values (@var);
+create database d17;
+create table d17.t8 (a int);
+select round(rand()*8) into @var;
+insert into d17.t8 values (@var);
+create table d17.t7 (a int);
+select round(rand()*8) into @var;
+insert into d17.t7 values (@var);
+create table d17.t6 (a int);
+select round(rand()*8) into @var;
+insert into d17.t6 values (@var);
+create table d17.t5 (a int);
+select round(rand()*8) into @var;
+insert into d17.t5 values (@var);
+create table d17.t4 (a int);
+select round(rand()*8) into @var;
+insert into d17.t4 values (@var);
+create table d17.t3 (a int);
+select round(rand()*8) into @var;
+insert into d17.t3 values (@var);
+create table d17.t2 (a int);
+select round(rand()*8) into @var;
+insert into d17.t2 values (@var);
+create table d17.t1 (a int);
+select round(rand()*8) into @var;
+insert into d17.t1 values (@var);
+create database d16;
+create table d16.t8 (a int);
+select round(rand()*8) into @var;
+insert into d16.t8 values (@var);
+create table d16.t7 (a int);
+select round(rand()*8) into @var;
+insert into d16.t7 values (@var);
+create table d16.t6 (a int);
+select round(rand()*8) into @var;
+insert into d16.t6 values (@var);
+create table d16.t5 (a int);
+select round(rand()*8) into @var;
+insert into d16.t5 values (@var);
+create table d16.t4 (a int);
+select round(rand()*8) into @var;
+insert into d16.t4 values (@var);
+create table d16.t3 (a int);
+select round(rand()*8) into @var;
+insert into d16.t3 values (@var);
+create table d16.t2 (a int);
+select round(rand()*8) into @var;
+insert into d16.t2 values (@var);
+create table d16.t1 (a int);
+select round(rand()*8) into @var;
+insert into d16.t1 values (@var);
+create database d15;
+create table d15.t8 (a int);
+select round(rand()*8) into @var;
+insert into d15.t8 values (@var);
+create table d15.t7 (a int);
+select round(rand()*8) into @var;
+insert into d15.t7 values (@var);
+create table d15.t6 (a int);
+select round(rand()*8) into @var;
+insert into d15.t6 values (@var);
+create table d15.t5 (a int);
+select round(rand()*8) into @var;
+insert into d15.t5 values (@var);
+create table d15.t4 (a int);
+select round(rand()*8) into @var;
+insert into d15.t4 values (@var);
+create table d15.t3 (a int);
+select round(rand()*8) into @var;
+insert into d15.t3 values (@var);
+create table d15.t2 (a int);
+select round(rand()*8) into @var;
+insert into d15.t2 values (@var);
+create table d15.t1 (a int);
+select round(rand()*8) into @var;
+insert into d15.t1 values (@var);
+create database d14;
+create table d14.t8 (a int);
+select round(rand()*8) into @var;
+insert into d14.t8 values (@var);
+create table d14.t7 (a int);
+select round(rand()*8) into @var;
+insert into d14.t7 values (@var);
+create table d14.t6 (a int);
+select round(rand()*8) into @var;
+insert into d14.t6 values (@var);
+create table d14.t5 (a int);
+select round(rand()*8) into @var;
+insert into d14.t5 values (@var);
+create table d14.t4 (a int);
+select round(rand()*8) into @var;
+insert into d14.t4 values (@var);
+create table d14.t3 (a int);
+select round(rand()*8) into @var;
+insert into d14.t3 values (@var);
+create table d14.t2 (a int);
+select round(rand()*8) into @var;
+insert into d14.t2 values (@var);
+create table d14.t1 (a int);
+select round(rand()*8) into @var;
+insert into d14.t1 values (@var);
+create database d13;
+create table d13.t8 (a int);
+select round(rand()*8) into @var;
+insert into d13.t8 values (@var);
+create table d13.t7 (a int);
+select round(rand()*8) into @var;
+insert into d13.t7 values (@var);
+create table d13.t6 (a int);
+select round(rand()*8) into @var;
+insert into d13.t6 values (@var);
+create table d13.t5 (a int);
+select round(rand()*8) into @var;
+insert into d13.t5 values (@var);
+create table d13.t4 (a int);
+select round(rand()*8) into @var;
+insert into d13.t4 values (@var);
+create table d13.t3 (a int);
+select round(rand()*8) into @var;
+insert into d13.t3 values (@var);
+create table d13.t2 (a int);
+select round(rand()*8) into @var;
+insert into d13.t2 values (@var);
+create table d13.t1 (a int);
+select round(rand()*8) into @var;
+insert into d13.t1 values (@var);
+create database d12;
+create table d12.t8 (a int);
+select round(rand()*8) into @var;
+insert into d12.t8 values (@var);
+create table d12.t7 (a int);
+select round(rand()*8) into @var;
+insert into d12.t7 values (@var);
+create table d12.t6 (a int);
+select round(rand()*8) into @var;
+insert into d12.t6 values (@var);
+create table d12.t5 (a int);
+select round(rand()*8) into @var;
+insert into d12.t5 values (@var);
+create table d12.t4 (a int);
+select round(rand()*8) into @var;
+insert into d12.t4 values (@var);
+create table d12.t3 (a int);
+select round(rand()*8) into @var;
+insert into d12.t3 values (@var);
+create table d12.t2 (a int);
+select round(rand()*8) into @var;
+insert into d12.t2 values (@var);
+create table d12.t1 (a int);
+select round(rand()*8) into @var;
+insert into d12.t1 values (@var);
+create database d11;
+create table d11.t8 (a int);
+select round(rand()*8) into @var;
+insert into d11.t8 values (@var);
+create table d11.t7 (a int);
+select round(rand()*8) into @var;
+insert into d11.t7 values (@var);
+create table d11.t6 (a int);
+select round(rand()*8) into @var;
+insert into d11.t6 values (@var);
+create table d11.t5 (a int);
+select round(rand()*8) into @var;
+insert into d11.t5 values (@var);
+create table d11.t4 (a int);
+select round(rand()*8) into @var;
+insert into d11.t4 values (@var);
+create table d11.t3 (a int);
+select round(rand()*8) into @var;
+insert into d11.t3 values (@var);
+create table d11.t2 (a int);
+select round(rand()*8) into @var;
+insert into d11.t2 values (@var);
+create table d11.t1 (a int);
+select round(rand()*8) into @var;
+insert into d11.t1 values (@var);
+create database d10;
+create table d10.t8 (a int);
+select round(rand()*8) into @var;
+insert into d10.t8 values (@var);
+create table d10.t7 (a int);
+select round(rand()*8) into @var;
+insert into d10.t7 values (@var);
+create table d10.t6 (a int);
+select round(rand()*8) into @var;
+insert into d10.t6 values (@var);
+create table d10.t5 (a int);
+select round(rand()*8) into @var;
+insert into d10.t5 values (@var);
+create table d10.t4 (a int);
+select round(rand()*8) into @var;
+insert into d10.t4 values (@var);
+create table d10.t3 (a int);
+select round(rand()*8) into @var;
+insert into d10.t3 values (@var);
+create table d10.t2 (a int);
+select round(rand()*8) into @var;
+insert into d10.t2 values (@var);
+create table d10.t1 (a int);
+select round(rand()*8) into @var;
+insert into d10.t1 values (@var);
+create database d9;
+create table d9.t8 (a int);
+select round(rand()*8) into @var;
+insert into d9.t8 values (@var);
+create table d9.t7 (a int);
+select round(rand()*8) into @var;
+insert into d9.t7 values (@var);
+create table d9.t6 (a int);
+select round(rand()*8) into @var;
+insert into d9.t6 values (@var);
+create table d9.t5 (a int);
+select round(rand()*8) into @var;
+insert into d9.t5 values (@var);
+create table d9.t4 (a int);
+select round(rand()*8) into @var;
+insert into d9.t4 values (@var);
+create table d9.t3 (a int);
+select round(rand()*8) into @var;
+insert into d9.t3 values (@var);
+create table d9.t2 (a int);
+select round(rand()*8) into @var;
+insert into d9.t2 values (@var);
+create table d9.t1 (a int);
+select round(rand()*8) into @var;
+insert into d9.t1 values (@var);
+create database d8;
+create table d8.t8 (a int);
+select round(rand()*8) into @var;
+insert into d8.t8 values (@var);
+create table d8.t7 (a int);
+select round(rand()*8) into @var;
+insert into d8.t7 values (@var);
+create table d8.t6 (a int);
+select round(rand()*8) into @var;
+insert into d8.t6 values (@var);
+create table d8.t5 (a int);
+select round(rand()*8) into @var;
+insert into d8.t5 values (@var);
+create table d8.t4 (a int);
+select round(rand()*8) into @var;
+insert into d8.t4 values (@var);
+create table d8.t3 (a int);
+select round(rand()*8) into @var;
+insert into d8.t3 values (@var);
+create table d8.t2 (a int);
+select round(rand()*8) into @var;
+insert into d8.t2 values (@var);
+create table d8.t1 (a int);
+select round(rand()*8) into @var;
+insert into d8.t1 values (@var);
+create database d7;
+create table d7.t8 (a int);
+select round(rand()*8) into @var;
+insert into d7.t8 values (@var);
+create table d7.t7 (a int);
+select round(rand()*8) into @var;
+insert into d7.t7 values (@var);
+create table d7.t6 (a int);
+select round(rand()*8) into @var;
+insert into d7.t6 values (@var);
+create table d7.t5 (a int);
+select round(rand()*8) into @var;
+insert into d7.t5 values (@var);
+create table d7.t4 (a int);
+select round(rand()*8) into @var;
+insert into d7.t4 values (@var);
+create table d7.t3 (a int);
+select round(rand()*8) into @var;
+insert into d7.t3 values (@var);
+create table d7.t2 (a int);
+select round(rand()*8) into @var;
+insert into d7.t2 values (@var);
+create table d7.t1 (a int);
+select round(rand()*8) into @var;
+insert into d7.t1 values (@var);
+create database d6;
+create table d6.t8 (a int);
+select round(rand()*8) into @var;
+insert into d6.t8 values (@var);
+create table d6.t7 (a int);
+select round(rand()*8) into @var;
+insert into d6.t7 values (@var);
+create table d6.t6 (a int);
+select round(rand()*8) into @var;
+insert into d6.t6 values (@var);
+create table d6.t5 (a int);
+select round(rand()*8) into @var;
+insert into d6.t5 values (@var);
+create table d6.t4 (a int);
+select round(rand()*8) into @var;
+insert into d6.t4 values (@var);
+create table d6.t3 (a int);
+select round(rand()*8) into @var;
+insert into d6.t3 values (@var);
+create table d6.t2 (a int);
+select round(rand()*8) into @var;
+insert into d6.t2 values (@var);
+create table d6.t1 (a int);
+select round(rand()*8) into @var;
+insert into d6.t1 values (@var);
+create database d5;
+create table d5.t8 (a int);
+select round(rand()*8) into @var;
+insert into d5.t8 values (@var);
+create table d5.t7 (a int);
+select round(rand()*8) into @var;
+insert into d5.t7 values (@var);
+create table d5.t6 (a int);
+select round(rand()*8) into @var;
+insert into d5.t6 values (@var);
+create table d5.t5 (a int);
+select round(rand()*8) into @var;
+insert into d5.t5 values (@var);
+create table d5.t4 (a int);
+select round(rand()*8) into @var;
+insert into d5.t4 values (@var);
+create table d5.t3 (a int);
+select round(rand()*8) into @var;
+insert into d5.t3 values (@var);
+create table d5.t2 (a int);
+select round(rand()*8) into @var;
+insert into d5.t2 values (@var);
+create table d5.t1 (a int);
+select round(rand()*8) into @var;
+insert into d5.t1 values (@var);
+create database d4;
+create table d4.t8 (a int);
+select round(rand()*8) into @var;
+insert into d4.t8 values (@var);
+create table d4.t7 (a int);
+select round(rand()*8) into @var;
+insert into d4.t7 values (@var);
+create table d4.t6 (a int);
+select round(rand()*8) into @var;
+insert into d4.t6 values (@var);
+create table d4.t5 (a int);
+select round(rand()*8) into @var;
+insert into d4.t5 values (@var);
+create table d4.t4 (a int);
+select round(rand()*8) into @var;
+insert into d4.t4 values (@var);
+create table d4.t3 (a int);
+select round(rand()*8) into @var;
+insert into d4.t3 values (@var);
+create table d4.t2 (a int);
+select round(rand()*8) into @var;
+insert into d4.t2 values (@var);
+create table d4.t1 (a int);
+select round(rand()*8) into @var;
+insert into d4.t1 values (@var);
+create database d3;
+create table d3.t8 (a int);
+select round(rand()*8) into @var;
+insert into d3.t8 values (@var);
+create table d3.t7 (a int);
+select round(rand()*8) into @var;
+insert into d3.t7 values (@var);
+create table d3.t6 (a int);
+select round(rand()*8) into @var;
+insert into d3.t6 values (@var);
+create table d3.t5 (a int);
+select round(rand()*8) into @var;
+insert into d3.t5 values (@var);
+create table d3.t4 (a int);
+select round(rand()*8) into @var;
+insert into d3.t4 values (@var);
+create table d3.t3 (a int);
+select round(rand()*8) into @var;
+insert into d3.t3 values (@var);
+create table d3.t2 (a int);
+select round(rand()*8) into @var;
+insert into d3.t2 values (@var);
+create table d3.t1 (a int);
+select round(rand()*8) into @var;
+insert into d3.t1 values (@var);
+create database d2;
+create table d2.t8 (a int);
+select round(rand()*8) into @var;
+insert into d2.t8 values (@var);
+create table d2.t7 (a int);
+select round(rand()*8) into @var;
+insert into d2.t7 values (@var);
+create table d2.t6 (a int);
+select round(rand()*8) into @var;
+insert into d2.t6 values (@var);
+create table d2.t5 (a int);
+select round(rand()*8) into @var;
+insert into d2.t5 values (@var);
+create table d2.t4 (a int);
+select round(rand()*8) into @var;
+insert into d2.t4 values (@var);
+create table d2.t3 (a int);
+select round(rand()*8) into @var;
+insert into d2.t3 values (@var);
+create table d2.t2 (a int);
+select round(rand()*8) into @var;
+insert into d2.t2 values (@var);
+create table d2.t1 (a int);
+select round(rand()*8) into @var;
+insert into d2.t1 values (@var);
+create database d1;
+create table d1.t8 (a int);
+select round(rand()*8) into @var;
+insert into d1.t8 values (@var);
+create table d1.t7 (a int);
+select round(rand()*8) into @var;
+insert into d1.t7 values (@var);
+create table d1.t6 (a int);
+select round(rand()*8) into @var;
+insert into d1.t6 values (@var);
+create table d1.t5 (a int);
+select round(rand()*8) into @var;
+insert into d1.t5 values (@var);
+create table d1.t4 (a int);
+select round(rand()*8) into @var;
+insert into d1.t4 values (@var);
+create table d1.t3 (a int);
+select round(rand()*8) into @var;
+insert into d1.t3 values (@var);
+create table d1.t2 (a int);
+select round(rand()*8) into @var;
+insert into d1.t2 values (@var);
+create table d1.t1 (a int);
+select round(rand()*8) into @var;
+insert into d1.t1 values (@var);
+include/start_slave.inc
+Warnings:
+Note	1726	Temporary failed transaction retry is not supported in Parallel Slave. Such failure will force the slave to stop.
+include/diff_tables.inc [master:d32.t8, slave:d32.t8]
+include/diff_tables.inc [master:d32.t7, slave:d32.t7]
+include/diff_tables.inc [master:d32.t6, slave:d32.t6]
+include/diff_tables.inc [master:d32.t5, slave:d32.t5]
+include/diff_tables.inc [master:d32.t4, slave:d32.t4]
+include/diff_tables.inc [master:d32.t3, slave:d32.t3]
+include/diff_tables.inc [master:d32.t2, slave:d32.t2]
+include/diff_tables.inc [master:d32.t1, slave:d32.t1]
+include/diff_tables.inc [master:d31.t8, slave:d31.t8]
+include/diff_tables.inc [master:d31.t7, slave:d31.t7]
+include/diff_tables.inc [master:d31.t6, slave:d31.t6]
+include/diff_tables.inc [master:d31.t5, slave:d31.t5]
+include/diff_tables.inc [master:d31.t4, slave:d31.t4]
+include/diff_tables.inc [master:d31.t3, slave:d31.t3]
+include/diff_tables.inc [master:d31.t2, slave:d31.t2]
+include/diff_tables.inc [master:d31.t1, slave:d31.t1]
+include/diff_tables.inc [master:d30.t8, slave:d30.t8]
+include/diff_tables.inc [master:d30.t7, slave:d30.t7]
+include/diff_tables.inc [master:d30.t6, slave:d30.t6]
+include/diff_tables.inc [master:d30.t5, slave:d30.t5]
+include/diff_tables.inc [master:d30.t4, slave:d30.t4]
+include/diff_tables.inc [master:d30.t3, slave:d30.t3]
+include/diff_tables.inc [master:d30.t2, slave:d30.t2]
+include/diff_tables.inc [master:d30.t1, slave:d30.t1]
+include/diff_tables.inc [master:d29.t8, slave:d29.t8]
+include/diff_tables.inc [master:d29.t7, slave:d29.t7]
+include/diff_tables.inc [master:d29.t6, slave:d29.t6]
+include/diff_tables.inc [master:d29.t5, slave:d29.t5]
+include/diff_tables.inc [master:d29.t4, slave:d29.t4]
+include/diff_tables.inc [master:d29.t3, slave:d29.t3]
+include/diff_tables.inc [master:d29.t2, slave:d29.t2]
+include/diff_tables.inc [master:d29.t1, slave:d29.t1]
+include/diff_tables.inc [master:d28.t8, slave:d28.t8]
+include/diff_tables.inc [master:d28.t7, slave:d28.t7]
+include/diff_tables.inc [master:d28.t6, slave:d28.t6]
+include/diff_tables.inc [master:d28.t5, slave:d28.t5]
+include/diff_tables.inc [master:d28.t4, slave:d28.t4]
+include/diff_tables.inc [master:d28.t3, slave:d28.t3]
+include/diff_tables.inc [master:d28.t2, slave:d28.t2]
+include/diff_tables.inc [master:d28.t1, slave:d28.t1]
+include/diff_tables.inc [master:d27.t8, slave:d27.t8]
+include/diff_tables.inc [master:d27.t7, slave:d27.t7]
+include/diff_tables.inc [master:d27.t6, slave:d27.t6]
+include/diff_tables.inc [master:d27.t5, slave:d27.t5]
+include/diff_tables.inc [master:d27.t4, slave:d27.t4]
+include/diff_tables.inc [master:d27.t3, slave:d27.t3]
+include/diff_tables.inc [master:d27.t2, slave:d27.t2]
+include/diff_tables.inc [master:d27.t1, slave:d27.t1]
+include/diff_tables.inc [master:d26.t8, slave:d26.t8]
+include/diff_tables.inc [master:d26.t7, slave:d26.t7]
+include/diff_tables.inc [master:d26.t6, slave:d26.t6]
+include/diff_tables.inc [master:d26.t5, slave:d26.t5]
+include/diff_tables.inc [master:d26.t4, slave:d26.t4]
+include/diff_tables.inc [master:d26.t3, slave:d26.t3]
+include/diff_tables.inc [master:d26.t2, slave:d26.t2]
+include/diff_tables.inc [master:d26.t1, slave:d26.t1]
+include/diff_tables.inc [master:d25.t8, slave:d25.t8]
+include/diff_tables.inc [master:d25.t7, slave:d25.t7]
+include/diff_tables.inc [master:d25.t6, slave:d25.t6]
+include/diff_tables.inc [master:d25.t5, slave:d25.t5]
+include/diff_tables.inc [master:d25.t4, slave:d25.t4]
+include/diff_tables.inc [master:d25.t3, slave:d25.t3]
+include/diff_tables.inc [master:d25.t2, slave:d25.t2]
+include/diff_tables.inc [master:d25.t1, slave:d25.t1]
+include/diff_tables.inc [master:d24.t8, slave:d24.t8]
+include/diff_tables.inc [master:d24.t7, slave:d24.t7]
+include/diff_tables.inc [master:d24.t6, slave:d24.t6]
+include/diff_tables.inc [master:d24.t5, slave:d24.t5]
+include/diff_tables.inc [master:d24.t4, slave:d24.t4]
+include/diff_tables.inc [master:d24.t3, slave:d24.t3]
+include/diff_tables.inc [master:d24.t2, slave:d24.t2]
+include/diff_tables.inc [master:d24.t1, slave:d24.t1]
+include/diff_tables.inc [master:d23.t8, slave:d23.t8]
+include/diff_tables.inc [master:d23.t7, slave:d23.t7]
+include/diff_tables.inc [master:d23.t6, slave:d23.t6]
+include/diff_tables.inc [master:d23.t5, slave:d23.t5]
+include/diff_tables.inc [master:d23.t4, slave:d23.t4]
+include/diff_tables.inc [master:d23.t3, slave:d23.t3]
+include/diff_tables.inc [master:d23.t2, slave:d23.t2]
+include/diff_tables.inc [master:d23.t1, slave:d23.t1]
+include/diff_tables.inc [master:d22.t8, slave:d22.t8]
+include/diff_tables.inc [master:d22.t7, slave:d22.t7]
+include/diff_tables.inc [master:d22.t6, slave:d22.t6]
+include/diff_tables.inc [master:d22.t5, slave:d22.t5]
+include/diff_tables.inc [master:d22.t4, slave:d22.t4]
+include/diff_tables.inc [master:d22.t3, slave:d22.t3]
+include/diff_tables.inc [master:d22.t2, slave:d22.t2]
+include/diff_tables.inc [master:d22.t1, slave:d22.t1]
+include/diff_tables.inc [master:d21.t8, slave:d21.t8]
+include/diff_tables.inc [master:d21.t7, slave:d21.t7]
+include/diff_tables.inc [master:d21.t6, slave:d21.t6]
+include/diff_tables.inc [master:d21.t5, slave:d21.t5]
+include/diff_tables.inc [master:d21.t4, slave:d21.t4]
+include/diff_tables.inc [master:d21.t3, slave:d21.t3]
+include/diff_tables.inc [master:d21.t2, slave:d21.t2]
+include/diff_tables.inc [master:d21.t1, slave:d21.t1]
+include/diff_tables.inc [master:d20.t8, slave:d20.t8]
+include/diff_tables.inc [master:d20.t7, slave:d20.t7]
+include/diff_tables.inc [master:d20.t6, slave:d20.t6]
+include/diff_tables.inc [master:d20.t5, slave:d20.t5]
+include/diff_tables.inc [master:d20.t4, slave:d20.t4]
+include/diff_tables.inc [master:d20.t3, slave:d20.t3]
+include/diff_tables.inc [master:d20.t2, slave:d20.t2]
+include/diff_tables.inc [master:d20.t1, slave:d20.t1]
+include/diff_tables.inc [master:d19.t8, slave:d19.t8]
+include/diff_tables.inc [master:d19.t7, slave:d19.t7]
+include/diff_tables.inc [master:d19.t6, slave:d19.t6]
+include/diff_tables.inc [master:d19.t5, slave:d19.t5]
+include/diff_tables.inc [master:d19.t4, slave:d19.t4]
+include/diff_tables.inc [master:d19.t3, slave:d19.t3]
+include/diff_tables.inc [master:d19.t2, slave:d19.t2]
+include/diff_tables.inc [master:d19.t1, slave:d19.t1]
+include/diff_tables.inc [master:d18.t8, slave:d18.t8]
+include/diff_tables.inc [master:d18.t7, slave:d18.t7]
+include/diff_tables.inc [master:d18.t6, slave:d18.t6]
+include/diff_tables.inc [master:d18.t5, slave:d18.t5]
+include/diff_tables.inc [master:d18.t4, slave:d18.t4]
+include/diff_tables.inc [master:d18.t3, slave:d18.t3]
+include/diff_tables.inc [master:d18.t2, slave:d18.t2]
+include/diff_tables.inc [master:d18.t1, slave:d18.t1]
+include/diff_tables.inc [master:d17.t8, slave:d17.t8]
+include/diff_tables.inc [master:d17.t7, slave:d17.t7]
+include/diff_tables.inc [master:d17.t6, slave:d17.t6]
+include/diff_tables.inc [master:d17.t5, slave:d17.t5]
+include/diff_tables.inc [master:d17.t4, slave:d17.t4]
+include/diff_tables.inc [master:d17.t3, slave:d17.t3]
+include/diff_tables.inc [master:d17.t2, slave:d17.t2]
+include/diff_tables.inc [master:d17.t1, slave:d17.t1]
+include/diff_tables.inc [master:d16.t8, slave:d16.t8]
+include/diff_tables.inc [master:d16.t7, slave:d16.t7]
+include/diff_tables.inc [master:d16.t6, slave:d16.t6]
+include/diff_tables.inc [master:d16.t5, slave:d16.t5]
+include/diff_tables.inc [master:d16.t4, slave:d16.t4]
+include/diff_tables.inc [master:d16.t3, slave:d16.t3]
+include/diff_tables.inc [master:d16.t2, slave:d16.t2]
+include/diff_tables.inc [master:d16.t1, slave:d16.t1]
+include/diff_tables.inc [master:d15.t8, slave:d15.t8]
+include/diff_tables.inc [master:d15.t7, slave:d15.t7]
+include/diff_tables.inc [master:d15.t6, slave:d15.t6]
+include/diff_tables.inc [master:d15.t5, slave:d15.t5]
+include/diff_tables.inc [master:d15.t4, slave:d15.t4]
+include/diff_tables.inc [master:d15.t3, slave:d15.t3]
+include/diff_tables.inc [master:d15.t2, slave:d15.t2]
+include/diff_tables.inc [master:d15.t1, slave:d15.t1]
+include/diff_tables.inc [master:d14.t8, slave:d14.t8]
+include/diff_tables.inc [master:d14.t7, slave:d14.t7]
+include/diff_tables.inc [master:d14.t6, slave:d14.t6]
+include/diff_tables.inc [master:d14.t5, slave:d14.t5]
+include/diff_tables.inc [master:d14.t4, slave:d14.t4]
+include/diff_tables.inc [master:d14.t3, slave:d14.t3]
+include/diff_tables.inc [master:d14.t2, slave:d14.t2]
+include/diff_tables.inc [master:d14.t1, slave:d14.t1]
+include/diff_tables.inc [master:d13.t8, slave:d13.t8]
+include/diff_tables.inc [master:d13.t7, slave:d13.t7]
+include/diff_tables.inc [master:d13.t6, slave:d13.t6]
+include/diff_tables.inc [master:d13.t5, slave:d13.t5]
+include/diff_tables.inc [master:d13.t4, slave:d13.t4]
+include/diff_tables.inc [master:d13.t3, slave:d13.t3]
+include/diff_tables.inc [master:d13.t2, slave:d13.t2]
+include/diff_tables.inc [master:d13.t1, slave:d13.t1]
+include/diff_tables.inc [master:d12.t8, slave:d12.t8]
+include/diff_tables.inc [master:d12.t7, slave:d12.t7]
+include/diff_tables.inc [master:d12.t6, slave:d12.t6]
+include/diff_tables.inc [master:d12.t5, slave:d12.t5]
+include/diff_tables.inc [master:d12.t4, slave:d12.t4]
+include/diff_tables.inc [master:d12.t3, slave:d12.t3]
+include/diff_tables.inc [master:d12.t2, slave:d12.t2]
+include/diff_tables.inc [master:d12.t1, slave:d12.t1]
+include/diff_tables.inc [master:d11.t8, slave:d11.t8]
+include/diff_tables.inc [master:d11.t7, slave:d11.t7]
+include/diff_tables.inc [master:d11.t6, slave:d11.t6]
+include/diff_tables.inc [master:d11.t5, slave:d11.t5]
+include/diff_tables.inc [master:d11.t4, slave:d11.t4]
+include/diff_tables.inc [master:d11.t3, slave:d11.t3]
+include/diff_tables.inc [master:d11.t2, slave:d11.t2]
+include/diff_tables.inc [master:d11.t1, slave:d11.t1]
+include/diff_tables.inc [master:d10.t8, slave:d10.t8]
+include/diff_tables.inc [master:d10.t7, slave:d10.t7]
+include/diff_tables.inc [master:d10.t6, slave:d10.t6]
+include/diff_tables.inc [master:d10.t5, slave:d10.t5]
+include/diff_tables.inc [master:d10.t4, slave:d10.t4]
+include/diff_tables.inc [master:d10.t3, slave:d10.t3]
+include/diff_tables.inc [master:d10.t2, slave:d10.t2]
+include/diff_tables.inc [master:d10.t1, slave:d10.t1]
+include/diff_tables.inc [master:d9.t8, slave:d9.t8]
+include/diff_tables.inc [master:d9.t7, slave:d9.t7]
+include/diff_tables.inc [master:d9.t6, slave:d9.t6]
+include/diff_tables.inc [master:d9.t5, slave:d9.t5]
+include/diff_tables.inc [master:d9.t4, slave:d9.t4]
+include/diff_tables.inc [master:d9.t3, slave:d9.t3]
+include/diff_tables.inc [master:d9.t2, slave:d9.t2]
+include/diff_tables.inc [master:d9.t1, slave:d9.t1]
+include/diff_tables.inc [master:d8.t8, slave:d8.t8]
+include/diff_tables.inc [master:d8.t7, slave:d8.t7]
+include/diff_tables.inc [master:d8.t6, slave:d8.t6]
+include/diff_tables.inc [master:d8.t5, slave:d8.t5]
+include/diff_tables.inc [master:d8.t4, slave:d8.t4]
+include/diff_tables.inc [master:d8.t3, slave:d8.t3]
+include/diff_tables.inc [master:d8.t2, slave:d8.t2]
+include/diff_tables.inc [master:d8.t1, slave:d8.t1]
+include/diff_tables.inc [master:d7.t8, slave:d7.t8]
+include/diff_tables.inc [master:d7.t7, slave:d7.t7]
+include/diff_tables.inc [master:d7.t6, slave:d7.t6]
+include/diff_tables.inc [master:d7.t5, slave:d7.t5]
+include/diff_tables.inc [master:d7.t4, slave:d7.t4]
+include/diff_tables.inc [master:d7.t3, slave:d7.t3]
+include/diff_tables.inc [master:d7.t2, slave:d7.t2]
+include/diff_tables.inc [master:d7.t1, slave:d7.t1]
+include/diff_tables.inc [master:d6.t8, slave:d6.t8]
+include/diff_tables.inc [master:d6.t7, slave:d6.t7]
+include/diff_tables.inc [master:d6.t6, slave:d6.t6]
+include/diff_tables.inc [master:d6.t5, slave:d6.t5]
+include/diff_tables.inc [master:d6.t4, slave:d6.t4]
+include/diff_tables.inc [master:d6.t3, slave:d6.t3]
+include/diff_tables.inc [master:d6.t2, slave:d6.t2]
+include/diff_tables.inc [master:d6.t1, slave:d6.t1]
+include/diff_tables.inc [master:d5.t8, slave:d5.t8]
+include/diff_tables.inc [master:d5.t7, slave:d5.t7]
+include/diff_tables.inc [master:d5.t6, slave:d5.t6]
+include/diff_tables.inc [master:d5.t5, slave:d5.t5]
+include/diff_tables.inc [master:d5.t4, slave:d5.t4]
+include/diff_tables.inc [master:d5.t3, slave:d5.t3]
+include/diff_tables.inc [master:d5.t2, slave:d5.t2]
+include/diff_tables.inc [master:d5.t1, slave:d5.t1]
+include/diff_tables.inc [master:d4.t8, slave:d4.t8]
+include/diff_tables.inc [master:d4.t7, slave:d4.t7]
+include/diff_tables.inc [master:d4.t6, slave:d4.t6]
+include/diff_tables.inc [master:d4.t5, slave:d4.t5]
+include/diff_tables.inc [master:d4.t4, slave:d4.t4]
+include/diff_tables.inc [master:d4.t3, slave:d4.t3]
+include/diff_tables.inc [master:d4.t2, slave:d4.t2]
+include/diff_tables.inc [master:d4.t1, slave:d4.t1]
+include/diff_tables.inc [master:d3.t8, slave:d3.t8]
+include/diff_tables.inc [master:d3.t7, slave:d3.t7]
+include/diff_tables.inc [master:d3.t6, slave:d3.t6]
+include/diff_tables.inc [master:d3.t5, slave:d3.t5]
+include/diff_tables.inc [master:d3.t4, slave:d3.t4]
+include/diff_tables.inc [master:d3.t3, slave:d3.t3]
+include/diff_tables.inc [master:d3.t2, slave:d3.t2]
+include/diff_tables.inc [master:d3.t1, slave:d3.t1]
+include/diff_tables.inc [master:d2.t8, slave:d2.t8]
+include/diff_tables.inc [master:d2.t7, slave:d2.t7]
+include/diff_tables.inc [master:d2.t6, slave:d2.t6]
+include/diff_tables.inc [master:d2.t5, slave:d2.t5]
+include/diff_tables.inc [master:d2.t4, slave:d2.t4]
+include/diff_tables.inc [master:d2.t3, slave:d2.t3]
+include/diff_tables.inc [master:d2.t2, slave:d2.t2]
+include/diff_tables.inc [master:d2.t1, slave:d2.t1]
+include/diff_tables.inc [master:d1.t8, slave:d1.t8]
+include/diff_tables.inc [master:d1.t7, slave:d1.t7]
+include/diff_tables.inc [master:d1.t6, slave:d1.t6]
+include/diff_tables.inc [master:d1.t5, slave:d1.t5]
+include/diff_tables.inc [master:d1.t4, slave:d1.t4]
+include/diff_tables.inc [master:d1.t3, slave:d1.t3]
+include/diff_tables.inc [master:d1.t2, slave:d1.t2]
+include/diff_tables.inc [master:d1.t1, slave:d1.t1]
+set @@global.mts_slave_parallel_workers= @save.mts_slave_parallel_workers;

=== added file 'mysql-test/suite/rpl/t/rpl_parallel_ddl.test'
--- a/mysql-test/suite/rpl/t/rpl_parallel_ddl.test	1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/rpl/t/rpl_parallel_ddl.test	2011-02-19 16:26:33 +0000
@@ -0,0 +1,174 @@
+#
+# WL#5569 MTS
+#
+# The test verifies correctness of DDL Query event parallelization
+#
+
+
+--source include/master-slave.inc
+--source include/have_binlog_format_statement.inc
+
+
+# restart in Parallel
+
+let $workers= 4;
+
+connection slave;
+
+source include/stop_slave.inc;
+set @save.mts_slave_parallel_workers= @@global.mts_slave_parallel_workers;
+eval set @@global.mts_slave_parallel_workers= $workers;
+
+let $dbs= 32;
+let $tables= 8;
+let $queries= `select $dbs*$tables * 8`;
+
+#
+# D1. CREATE/DROP database
+#
+#
+# D2. CREATE/DROP/ALTER/RENAME table
+#
+
+
+let $n= $dbs;
+while ($n)
+{
+  connection master;
+  eval create database d$n;
+
+  let $m= $tables;
+  while ($m)
+  {
+     eval create table d$n.t$m (a int);
+     eval select round(rand()*$tables) into @var;
+     eval insert into d$n.t$m values (@var);
+
+     dec $m;
+  }
+  dec $n;
+
+  connection master1;
+  eval create database d$n;
+
+  let $m= $tables;
+  while ($m)
+  {
+     eval create table d$n.t$m (a int);
+     eval select round(rand()*$tables) into @var;
+     eval insert into d$n.t$m values (@var);
+
+     dec $m;
+  }
+  dec $n;
+}
+
+let $k= $queries;
+
+while ($k)
+{
+   let $n_1 = `select floor(rand()*$dbs) + 1`;
+   let $n_2 = `select floor(rand()*$dbs) + 1`;
+   let $n1_1= `select floor(rand()*$dbs) + 1`;
+   let $n1_2= `select floor(rand()*$dbs) + 1`;
+   let $m= `select floor(rand()*$tables) + 1`;
+
+   if ($n1)
+   {
+       --error 0,ER_TABLE_EXISTS_ERROR
+       eval rename d$n_1.t$m to d$n1_1.t$m, d$n_2.t$m to d$n1_2.t$m;
+       --error 0,ER_TABLE_EXISTS_ERROR
+       eval rename d$n1_1.t$m to d$n1.t$m,  d$n1_2.t$m to d$n2.t$m;
+   }
+   dec $k;
+}
+
+
+### sync_slave_with_master;
+
+#
+# D3. CREATE/DROP Stored Proc, Stored Func, Trigger, Func
+
+connection master;
+
+let $n= $dbs;
+# n'th db tables won't have any trigger to avoid circular dependency
+let $n1= $n;
+dec $n1;
+
+--disable_query_log
+while ($n1)
+{
+  let $m= $tables;
+
+  while ($m)
+  {
+     eval create trigger `d$n1`.`trg_t$m` before insert on `d$n1`.`t$m` for each row insert into `d$n`.`t$m` values(1);
+
+     delimiter |;
+
+     eval create function `d$n`.`func_$m` (a int) returns int
+          begin
+	  insert into `d$n`.`t$m` values(1);
+	  return 1;
+	  end|
+
+     eval create procedure `d$n`.`proc_$m`(a int)
+          begin
+	  insert into `d$n`.`t$m` values(1);
+	  end|
+	  
+     delimiter ;|
+
+     dec $m;
+  }
+  dec $n;
+  dec $n1;
+}
+--enable_query_log
+
+connection slave;
+source include/start_slave.inc;
+
+connection master;
+sync_slave_with_master;
+
+#
+# Consistency check
+#
+
+let $n = $dbs;
+while($n)
+{
+  let $m= $tables;
+  while ($m)
+  {
+    let $diff_tables=master:d$n.t$m, slave:d$n.t$m;
+    source include/diff_tables.inc;
+    dec $m;
+  }
+  dec $n;
+}
+
+#
+# Clean-up
+#
+
+connection master;
+
+--disable_query_log
+
+let $n= $dbs;
+while ($n)
+{
+  eval drop database d$n;
+  dec $n;
+}
+
+--enable_query_log
+
+sync_slave_with_master;
+
+set @@global.mts_slave_parallel_workers= @save.mts_slave_parallel_workers;
+
+### TODO: --source include/rpl_end.inc

=== modified file 'sql/binlog.cc'
--- a/sql/binlog.cc	2011-02-17 19:56:48 +0000
+++ b/sql/binlog.cc	2011-02-19 16:26:33 +0000
@@ -4535,6 +4535,44 @@ THD::binlog_set_pending_rows_event(Rows_
 }
 
 /**
+   @param db    a c-string to be added sorted way to
+                THD::binlog_updated_db_names
+*/
+void
+THD::add_to_binlog_updated_dbs(const char *db)
+{
+  char *after_db= strdup_root(mem_root, db);
+  if (binlog_updated_db_names->elements != 0)
+  {
+    List_iterator<char> it(*get_binlog_updated_db_names());
+
+    while (it++)
+    {
+      char *swap= NULL;
+      char **ref_cur_db= it.ref();
+      int cmp= strcmp(after_db, *ref_cur_db);
+
+      DBUG_ASSERT(!swap || cmp < 0);
+      
+      if (cmp == 0)
+      {
+        after_db= NULL;  /* dup to ignore */
+        break;
+      }
+      else if (swap || cmp > 0)
+      {
+        swap= *ref_cur_db;
+        *ref_cur_db= after_db;
+        after_db= swap;
+      }
+    }
+  }
+  if (after_db)
+    binlog_updated_db_names->push_back(after_db);
+}
+
+
+/**
   Decide on logging format to use for the statement and issue errors
   or warnings as needed.  The decision depends on the following
   parameters:
@@ -4751,36 +4789,7 @@ int THD::decide_logging_format(TABLE_LIS
             binlog_updated_db_names= new List<char>; /* thd->mem_root is used */
           }
           if (binlog_updated_db_names->elements <  MAX_DBS_IN_QUERY_MTS + 1)
-          {
-            char *after_db= strdup_root(mem_root, table->db);
-            if (binlog_updated_db_names->elements != 0)
-            {
-              List_iterator<char> it(*get_binlog_updated_db_names());
-              
-              while (it++)
-              {
-                char *swap= NULL;
-                char **ref_cur_db= it.ref();
-                int cmp= strcmp(after_db, *ref_cur_db);
-                
-                DBUG_ASSERT(!swap || cmp < 0);
-                
-                if (cmp == 0)
-                {
-                  after_db= NULL;  /* dup to ignore */
-                  break;
-                }
-                else if (swap || cmp > 0)
-                {
-                  swap= *ref_cur_db;
-                  *ref_cur_db= after_db;
-                  after_db= swap;
-                }
-              }
-            }
-            if (after_db)
-              binlog_updated_db_names->push_back(after_db);
-          }
+            add_to_binlog_updated_dbs(table->db);
         }
       }
 

=== modified file 'sql/events.cc'
--- a/sql/events.cc	2010-11-18 16:34:56 +0000
+++ b/sql/events.cc	2011-02-19 16:26:33 +0000
@@ -384,6 +384,7 @@ Events::create_event(THD *thd, Event_par
       }
       else
       {
+        thd->add_one_db_to_binlog_updated_dbs(parse_data->dbname.str);
         /* If the definer is not set or set to CURRENT_USER, the value of CURRENT_USER
            will be written into the binary log as the definer for the SQL thread. */
         ret= write_bin_log(thd, TRUE, log_query.c_ptr(), log_query.length());
@@ -502,6 +503,12 @@ Events::update_event(THD *thd, Event_par
                                   new_element);
       /* Binlog the alter event. */
       DBUG_ASSERT(thd->query() && thd->query_length());
+
+      thd->set_binlog_updated_db_names(new List<char>);
+      thd->add_to_binlog_updated_dbs(parse_data->dbname.str);
+      if (new_dbname)
+        thd->add_to_binlog_updated_dbs(new_dbname->str);
+
       ret= write_bin_log(thd, TRUE, thd->query(), thd->query_length());
     }
   }
@@ -568,6 +575,8 @@ Events::drop_event(THD *thd, LEX_STRING 
       event_queue->drop_event(thd, dbname, name);
     /* Binlog the drop event. */
     DBUG_ASSERT(thd->query() && thd->query_length());
+
+    thd->add_one_db_to_binlog_updated_dbs(dbname.str);
     ret= write_bin_log(thd, TRUE, thd->query(), thd->query_length());
   }
   /* Restore the state of binlog format */

=== modified file 'sql/sp.cc'
--- a/sql/sp.cc	2010-12-16 18:18:20 +0000
+++ b/sql/sp.cc	2011-02-19 16:26:33 +0000
@@ -1150,6 +1150,7 @@ sp_create_routine(THD *thd, int type, sp
       }
       /* restore sql_mode when binloging */
       thd->variables.sql_mode= saved_mode;
+      thd->add_one_db_to_binlog_updated_dbs(sp->m_db.str);
       /* Such a statement can always go directly to binlog, no trans cache */
       if (thd->binlog_query(THD::STMT_QUERY_TYPE,
                             log_query.c_ptr(), log_query.length(),
@@ -1223,6 +1224,7 @@ sp_drop_routine(THD *thd, int type, sp_n
 
   if (ret == SP_OK)
   {
+    thd->add_one_db_to_binlog_updated_dbs(name->m_db.str);
     if (write_bin_log(thd, TRUE, thd->query(), thd->query_length()))
       ret= SP_INTERNAL_ERROR;
     sp_cache_invalidate();

=== modified file 'sql/sql_class.h'
--- a/sql/sql_class.h	2011-02-17 19:56:48 +0000
+++ b/sql/sql_class.h	2011-02-19 16:26:33 +0000
@@ -1184,7 +1184,7 @@ public:
   bool last_insert_id_used;
   SAVEPOINT *savepoints;
   enum enum_check_fields count_cuted_fields;
-  List<char> *binlog_updated_db_names;
+  //List<char> *binlog_updated_db_names;
 };
 
 
@@ -1723,7 +1723,7 @@ private:
   */
   uint binlog_table_maps;
   /*
-    String space-separated db names listing to be updated by the query databases
+    MTS: db names listing to be updated by the query databases
   */
   List<char> *binlog_updated_db_names;
 
@@ -1736,10 +1736,24 @@ public:
   void clear_binlog_table_maps() {
     binlog_table_maps= 0;
   }
+
+  /*
+    MTS: collection of methods to operate on binlog_updated_db_names
+  */
   List<char> * get_binlog_updated_db_names() {
     return binlog_updated_db_names;
   }
+  void set_binlog_updated_db_names(List<char>* arg)
+  {
+    binlog_updated_db_names= arg;
+  }
   void clear_binlog_updated_db_names() { binlog_updated_db_names= NULL; }
+  void add_to_binlog_updated_dbs(const char *db);
+  void add_one_db_to_binlog_updated_dbs(const char *db)
+  {
+    set_binlog_updated_db_names(new List<char>);
+    binlog_updated_db_names->push_back(strdup_root(mem_root, db));
+  }
 
 #endif /* MYSQL_CLIENT */
 

=== modified file 'sql/sql_db.cc'
--- a/sql/sql_db.cc	2010-12-10 12:52:55 +0000
+++ b/sql/sql_db.cc	2011-02-19 16:26:33 +0000
@@ -660,7 +660,7 @@ not_silent:
       */
       qinfo.db     = db;
       qinfo.db_len = strlen(db);
-
+      thd->add_one_db_to_binlog_updated_dbs(db);
       /*
         These DDL methods and logging are protected with the exclusive
         metadata lock on the schema
@@ -964,6 +964,7 @@ update_binlog:
 
     if (query_pos != query_data_start)
     {
+      thd->add_one_db_to_binlog_updated_dbs(db);
       /*
         These DDL methods and logging are protected with the exclusive
         metadata lock on the schema.

=== modified file 'sql/sql_rename.cc'
--- a/sql/sql_rename.cc	2010-11-18 16:34:56 +0000
+++ b/sql/sql_rename.cc	2011-02-19 16:26:33 +0000
@@ -317,6 +317,14 @@ do_rename(THD *thd, TABLE_LIST *ren_tabl
       my_error(ER_FILE_NOT_FOUND, MYF(0), name, my_errno);
       break;
   }
+
+  if (!thd->get_binlog_updated_db_names())
+  {
+    thd->set_binlog_updated_db_names(new List<char>);
+  }
+  thd->add_to_binlog_updated_dbs(ren_table->db);
+  thd->add_to_binlog_updated_dbs(new_db);
+
   if (rc && !skip_error)
     DBUG_RETURN(1);
 

=== modified file 'sql/sql_table.cc'
--- a/sql/sql_table.cc	2010-12-17 18:43:38 +0000
+++ b/sql/sql_table.cc	2011-02-19 16:26:33 +0000
@@ -2236,6 +2236,14 @@ int mysql_rm_table_no_locks(THD *thd, TA
                   find_temporary_table(thd, table) &&
                   table->mdl_request.ticket != NULL));
 
+    /* MTS: similarly to decide_logging_format() gathering of the db names */
+    if (!thd->get_binlog_updated_db_names())
+    {
+      thd->set_binlog_updated_db_names(new List<char>);
+    }
+    if (thd->get_binlog_updated_db_names()->elements <  MAX_DBS_IN_QUERY_MTS + 1)
+      thd->add_to_binlog_updated_dbs(table->db);
+
     /*
       drop_temporary_table may return one of the following error codes:
       .  0 - a temporary table was successfully dropped.
@@ -4562,7 +4570,13 @@ bool mysql_create_table(THD *thd, TABLE_
       (!thd->is_current_stmt_binlog_format_row() ||
        (thd->is_current_stmt_binlog_format_row() &&
         !(create_info->options & HA_LEX_CREATE_TMP_TABLE))))
+  {
+
+    DBUG_ASSERT(!thd->get_binlog_updated_db_names());
+
+    thd->add_one_db_to_binlog_updated_dbs(create_table->db);
     result= write_bin_log(thd, TRUE, thd->query(), thd->query_length(), is_trans);
+  }
 
 end:
   DBUG_RETURN(result);
@@ -5942,6 +5956,15 @@ bool mysql_alter_table(THD *thd,char *ne
   db=table_list->db;
   if (!new_db || !my_strcasecmp(table_alias_charset, new_db, db))
     new_db= db;
+
+  if (!thd->get_binlog_updated_db_names())
+  {
+    thd->set_binlog_updated_db_names(new List<char>);
+  }
+  thd->add_to_binlog_updated_dbs(db);
+  if (new_db != db)
+    thd->add_to_binlog_updated_dbs(new_db);
+
   build_table_filename(reg_path, sizeof(reg_path) - 1, db, table_name, reg_ext, 0);
   build_table_filename(path, sizeof(path) - 1, db, table_name, "", 0);
 

=== modified file 'sql/sql_trigger.cc'
--- a/sql/sql_trigger.cc	2010-11-29 16:27:58 +0000
+++ b/sql/sql_trigger.cc	2011-02-19 16:26:33 +0000
@@ -521,6 +521,8 @@ bool mysql_create_or_drop_trigger(THD *t
 end:
   if (!result)
   {
+    if (tables)
+      thd->add_one_db_to_binlog_updated_dbs(tables->db);
     result= write_bin_log(thd, TRUE, stmt_query.ptr(), stmt_query.length());
   }
 


Attachment: [text/bzr-bundle] bzr/andrei.elkin@oracle.com-20110219162633-graaj89ad7v88dlh.bundle
Thread
bzr commit into mysql-next-mr-wl5569 branch (andrei.elkin:3271) WL#5754Andrei Elkin19 Feb