2005-12-22 06:39:02 +01:00
|
|
|
stop slave;
|
|
|
|
drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
|
|
|
|
reset master;
|
|
|
|
reset slave;
|
|
|
|
drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
|
|
|
|
start slave;
|
2008-12-03 20:55:49 +01:00
|
|
|
**** Resetting master and slave ****
|
2009-01-23 13:22:05 +01:00
|
|
|
include/stop_slave.inc
|
2008-12-03 20:55:49 +01:00
|
|
|
RESET SLAVE;
|
|
|
|
RESET MASTER;
|
2009-01-23 13:22:05 +01:00
|
|
|
include/start_slave.inc
|
2005-12-22 06:39:02 +01:00
|
|
|
CREATE TABLE t1 (a INT, b INT);
|
|
|
|
CREATE TABLE t2 (a INT, b INT) ENGINE=Merge;
|
|
|
|
CREATE TABLE t3 (a INT, b INT) CHARSET=utf8;
|
|
|
|
CREATE TABLE t4 (a INT, b INT) ENGINE=Merge CHARSET=utf8;
|
2008-12-03 20:55:49 +01:00
|
|
|
SHOW BINLOG EVENTS FROM 106;
|
2005-12-22 06:39:02 +01:00
|
|
|
Log_name #
|
2008-12-03 20:55:49 +01:00
|
|
|
Pos 106
|
2005-12-22 06:39:02 +01:00
|
|
|
Event_type Query
|
|
|
|
Server_id #
|
2008-12-03 20:55:49 +01:00
|
|
|
End_log_pos 199
|
2005-12-22 06:39:02 +01:00
|
|
|
Info use `test`; CREATE TABLE t1 (a INT, b INT)
|
|
|
|
Log_name #
|
2008-12-03 20:55:49 +01:00
|
|
|
Pos 199
|
2005-12-22 06:39:02 +01:00
|
|
|
Event_type Query
|
|
|
|
Server_id #
|
2008-12-03 20:55:49 +01:00
|
|
|
End_log_pos 305
|
2005-12-22 06:39:02 +01:00
|
|
|
Info use `test`; CREATE TABLE t2 (a INT, b INT) ENGINE=Merge
|
|
|
|
Log_name #
|
2008-12-03 20:55:49 +01:00
|
|
|
Pos 305
|
2005-12-22 06:39:02 +01:00
|
|
|
Event_type Query
|
|
|
|
Server_id #
|
2008-12-03 20:55:49 +01:00
|
|
|
End_log_pos 411
|
2005-12-22 06:39:02 +01:00
|
|
|
Info use `test`; CREATE TABLE t3 (a INT, b INT) CHARSET=utf8
|
|
|
|
Log_name #
|
2008-12-03 20:55:49 +01:00
|
|
|
Pos 411
|
2005-12-22 06:39:02 +01:00
|
|
|
Event_type Query
|
|
|
|
Server_id #
|
2008-12-03 20:55:49 +01:00
|
|
|
End_log_pos 530
|
2005-12-22 06:39:02 +01:00
|
|
|
Info use `test`; CREATE TABLE t4 (a INT, b INT) ENGINE=Merge CHARSET=utf8
|
|
|
|
**** On Master ****
|
|
|
|
SHOW CREATE TABLE t1;
|
|
|
|
Table t1
|
|
|
|
Create Table CREATE TABLE `t1` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
) ENGINE=MyISAM DEFAULT CHARSET=latin1
|
|
|
|
SHOW CREATE TABLE t2;
|
|
|
|
Table t2
|
|
|
|
Create Table CREATE TABLE `t2` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2008-03-14 21:37:19 +01:00
|
|
|
) ENGINE=MRG_MyISAM DEFAULT CHARSET=latin1
|
2005-12-22 06:39:02 +01:00
|
|
|
SHOW CREATE TABLE t3;
|
|
|
|
Table t3
|
|
|
|
Create Table CREATE TABLE `t3` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
) ENGINE=MyISAM DEFAULT CHARSET=utf8
|
|
|
|
**** On Slave ****
|
|
|
|
SHOW CREATE TABLE t1;
|
|
|
|
Table t1
|
|
|
|
Create Table CREATE TABLE `t1` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
) ENGINE=MEMORY DEFAULT CHARSET=latin1
|
|
|
|
SHOW CREATE TABLE t2;
|
|
|
|
Table t2
|
|
|
|
Create Table CREATE TABLE `t2` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2008-03-14 21:37:19 +01:00
|
|
|
) ENGINE=MRG_MyISAM DEFAULT CHARSET=latin1
|
2005-12-22 06:39:02 +01:00
|
|
|
SHOW CREATE TABLE t3;
|
|
|
|
Table t3
|
|
|
|
Create Table CREATE TABLE `t3` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
) ENGINE=MEMORY DEFAULT CHARSET=utf8
|
|
|
|
CREATE TABLE t5 (b INT, c INT) SELECT * FROM t3;
|
|
|
|
CREATE TEMPORARY TABLE tt3 (a INT, b INT);
|
|
|
|
INSERT INTO tt3 VALUES (1,2), (2,4), (3,6), (4,2), (5,10), (6,12);
|
|
|
|
CREATE TABLE t6 (b INT, c INT) SELECT * FROM tt3;
|
|
|
|
**** On Master ****
|
|
|
|
SHOW CREATE TABLE t5;
|
|
|
|
Table t5
|
|
|
|
Create Table CREATE TABLE `t5` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`c` int(11) DEFAULT NULL,
|
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
) ENGINE=MyISAM DEFAULT CHARSET=latin1
|
|
|
|
SELECT * FROM t5 ORDER BY a,b,c;
|
|
|
|
c a b
|
|
|
|
SHOW CREATE TABLE t6;
|
|
|
|
Table t6
|
|
|
|
Create Table CREATE TABLE `t6` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`c` int(11) DEFAULT NULL,
|
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
) ENGINE=MyISAM DEFAULT CHARSET=latin1
|
|
|
|
SELECT * FROM t6 ORDER BY a,b,c;
|
|
|
|
c a b
|
|
|
|
NULL 1 2
|
|
|
|
NULL 2 4
|
|
|
|
NULL 3 6
|
|
|
|
NULL 4 2
|
|
|
|
NULL 5 10
|
|
|
|
NULL 6 12
|
|
|
|
**** On Slave ****
|
|
|
|
SHOW CREATE TABLE t5;
|
|
|
|
Table t5
|
|
|
|
Create Table CREATE TABLE `t5` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`c` int(11) DEFAULT NULL,
|
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
) ENGINE=MEMORY DEFAULT CHARSET=latin1
|
|
|
|
SELECT * FROM t5 ORDER BY a,b,c;
|
|
|
|
c a b
|
|
|
|
SHOW CREATE TABLE t6;
|
|
|
|
Table t6
|
|
|
|
Create Table CREATE TABLE `t6` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`c` int(11) DEFAULT NULL,
|
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
) ENGINE=MEMORY DEFAULT CHARSET=latin1
|
|
|
|
SELECT * FROM t6 ORDER BY a,b,c;
|
|
|
|
c a b
|
|
|
|
NULL 1 2
|
|
|
|
NULL 2 4
|
|
|
|
NULL 3 6
|
|
|
|
NULL 4 2
|
|
|
|
NULL 5 10
|
|
|
|
NULL 6 12
|
2008-12-03 20:55:49 +01:00
|
|
|
**** Resetting master and slave ****
|
2009-01-23 13:22:05 +01:00
|
|
|
include/stop_slave.inc
|
2008-12-03 20:55:49 +01:00
|
|
|
RESET SLAVE;
|
|
|
|
RESET MASTER;
|
2009-01-23 13:22:05 +01:00
|
|
|
include/start_slave.inc
|
2005-12-22 06:39:02 +01:00
|
|
|
CREATE TABLE t7 (UNIQUE(b)) SELECT a,b FROM tt3;
|
2006-02-13 12:58:33 +01:00
|
|
|
ERROR 23000: Duplicate entry '2' for key 'b'
|
2008-12-03 20:55:49 +01:00
|
|
|
SHOW BINLOG EVENTS FROM 106;
|
2005-12-22 06:39:02 +01:00
|
|
|
Log_name Pos Event_type Server_id End_log_pos Info
|
|
|
|
CREATE TABLE t7 (a INT, b INT UNIQUE);
|
|
|
|
INSERT INTO t7 SELECT a,b FROM tt3;
|
2006-02-13 12:58:33 +01:00
|
|
|
ERROR 23000: Duplicate entry '2' for key 'b'
|
2005-12-22 06:39:02 +01:00
|
|
|
SELECT * FROM t7 ORDER BY a,b;
|
|
|
|
a b
|
|
|
|
1 2
|
|
|
|
2 4
|
|
|
|
3 6
|
2008-12-03 20:55:49 +01:00
|
|
|
SHOW BINLOG EVENTS FROM 106;
|
2005-12-22 06:39:02 +01:00
|
|
|
Log_name Pos Event_type Server_id End_log_pos Info
|
2008-12-03 20:55:49 +01:00
|
|
|
# 106 Query # 206 use `test`; CREATE TABLE t7 (a INT, b INT UNIQUE)
|
2009-05-31 13:44:41 +08:00
|
|
|
# 206 Query # 274 BEGIN
|
2008-12-03 20:55:49 +01:00
|
|
|
# 274 Table_map # 316 table_id: # (test.t7)
|
|
|
|
# 316 Write_rows # 372 table_id: # flags: STMT_END_F
|
2009-05-31 13:44:41 +08:00
|
|
|
# 372 Query # 443 ROLLBACK
|
2005-12-22 06:39:02 +01:00
|
|
|
SELECT * FROM t7 ORDER BY a,b;
|
|
|
|
a b
|
|
|
|
1 2
|
|
|
|
2 4
|
|
|
|
3 6
|
2008-12-03 20:55:49 +01:00
|
|
|
**** Resetting master and slave ****
|
2009-01-23 13:22:05 +01:00
|
|
|
include/stop_slave.inc
|
2008-12-03 20:55:49 +01:00
|
|
|
RESET SLAVE;
|
|
|
|
RESET MASTER;
|
2009-01-23 13:22:05 +01:00
|
|
|
include/start_slave.inc
|
2005-12-22 06:39:02 +01:00
|
|
|
CREATE TEMPORARY TABLE tt4 (a INT, b INT);
|
|
|
|
INSERT INTO tt4 VALUES (4,8), (5,10), (6,12);
|
|
|
|
BEGIN;
|
|
|
|
INSERT INTO t7 SELECT a,b FROM tt4;
|
|
|
|
ROLLBACK;
|
|
|
|
Warnings:
|
|
|
|
Warning 1196 Some non-transactional changed tables couldn't be rolled back
|
2008-12-03 20:55:49 +01:00
|
|
|
SHOW BINLOG EVENTS FROM 106;
|
2005-12-22 06:39:02 +01:00
|
|
|
Log_name Pos Event_type Server_id End_log_pos Info
|
2009-05-31 13:44:41 +08:00
|
|
|
# 106 Query # 174 BEGIN
|
2008-12-03 20:55:49 +01:00
|
|
|
# 174 Table_map # 216 table_id: # (test.t7)
|
|
|
|
# 216 Write_rows # 272 table_id: # flags: STMT_END_F
|
2009-05-31 13:44:41 +08:00
|
|
|
# 272 Query # 343 ROLLBACK
|
2005-12-22 06:39:02 +01:00
|
|
|
SELECT * FROM t7 ORDER BY a,b;
|
|
|
|
a b
|
|
|
|
1 2
|
|
|
|
2 4
|
|
|
|
3 6
|
|
|
|
4 8
|
|
|
|
5 10
|
|
|
|
6 12
|
|
|
|
SELECT * FROM t7 ORDER BY a,b;
|
|
|
|
a b
|
|
|
|
1 2
|
|
|
|
2 4
|
|
|
|
3 6
|
|
|
|
4 8
|
|
|
|
5 10
|
|
|
|
6 12
|
2008-12-03 20:55:49 +01:00
|
|
|
**** Resetting master and slave ****
|
2009-01-23 13:22:05 +01:00
|
|
|
include/stop_slave.inc
|
2008-12-03 20:55:49 +01:00
|
|
|
RESET SLAVE;
|
|
|
|
RESET MASTER;
|
2009-01-23 13:22:05 +01:00
|
|
|
include/start_slave.inc
|
2005-12-22 06:39:02 +01:00
|
|
|
CREATE TABLE t8 LIKE t4;
|
|
|
|
CREATE TABLE t9 LIKE tt4;
|
|
|
|
CREATE TEMPORARY TABLE tt5 LIKE t4;
|
|
|
|
CREATE TEMPORARY TABLE tt6 LIKE tt4;
|
2006-06-20 10:40:36 +02:00
|
|
|
CREATE TEMPORARY TABLE tt7 SELECT 1;
|
2005-12-22 06:39:02 +01:00
|
|
|
**** On Master ****
|
|
|
|
SHOW CREATE TABLE t8;
|
|
|
|
Table t8
|
|
|
|
Create Table CREATE TABLE `t8` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2008-03-14 21:37:19 +01:00
|
|
|
) ENGINE=MRG_MyISAM DEFAULT CHARSET=utf8
|
2005-12-22 06:39:02 +01:00
|
|
|
SHOW CREATE TABLE t9;
|
|
|
|
Table t9
|
|
|
|
Create Table CREATE TABLE `t9` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
) ENGINE=MyISAM DEFAULT CHARSET=latin1
|
2008-12-03 20:55:49 +01:00
|
|
|
SHOW BINLOG EVENTS FROM 106;
|
2005-12-22 06:39:02 +01:00
|
|
|
Log_name Pos Event_type Server_id End_log_pos Info
|
2008-12-03 20:55:49 +01:00
|
|
|
# 106 Query # 192 use `test`; CREATE TABLE t8 LIKE t4
|
|
|
|
# 192 Query # 331 use `test`; CREATE TABLE `t9` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
)
|
|
|
|
**** On Slave ****
|
|
|
|
SHOW CREATE TABLE t8;
|
|
|
|
Table t8
|
|
|
|
Create Table CREATE TABLE `t8` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2008-03-14 21:37:19 +01:00
|
|
|
) ENGINE=MRG_MyISAM DEFAULT CHARSET=utf8
|
2005-12-22 06:39:02 +01:00
|
|
|
SHOW CREATE TABLE t9;
|
|
|
|
Table t9
|
|
|
|
Create Table CREATE TABLE `t9` (
|
2006-03-06 20:12:48 +01:00
|
|
|
`a` int(11) DEFAULT NULL,
|
|
|
|
`b` int(11) DEFAULT NULL
|
2005-12-22 06:39:02 +01:00
|
|
|
) ENGINE=MEMORY DEFAULT CHARSET=latin1
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
DROP TABLE IF EXISTS t1,t2,t3,t4,t5,t6,t7,t8,t9;
|
|
|
|
STOP SLAVE;
|
|
|
|
SET GLOBAL storage_engine=@storage_engine;
|
|
|
|
START SLAVE;
|
|
|
|
================ BUG#22864 ================
|
|
|
|
STOP SLAVE;
|
|
|
|
RESET SLAVE;
|
|
|
|
RESET MASTER;
|
|
|
|
START SLAVE;
|
|
|
|
SET AUTOCOMMIT=0;
|
|
|
|
CREATE TABLE t1 (a INT);
|
|
|
|
INSERT INTO t1 VALUES (1),(2),(3);
|
|
|
|
CREATE TABLE t2 ENGINE=INNODB SELECT * FROM t1;
|
|
|
|
ROLLBACK;
|
|
|
|
CREATE TABLE t3 ENGINE=INNODB SELECT * FROM t1;
|
|
|
|
INSERT INTO t3 VALUES (4),(5),(6);
|
|
|
|
ROLLBACK;
|
|
|
|
CREATE TABLE t4 ENGINE=INNODB SELECT * FROM t1;
|
|
|
|
INSERT INTO t1 VALUES (4),(5),(6);
|
|
|
|
ROLLBACK;
|
|
|
|
Warnings:
|
|
|
|
Warning 1196 Some non-transactional changed tables couldn't be rolled back
|
|
|
|
SHOW TABLES;
|
|
|
|
Tables_in_test
|
|
|
|
t1
|
|
|
|
t2
|
|
|
|
t3
|
|
|
|
t4
|
|
|
|
SELECT TABLE_NAME,ENGINE
|
|
|
|
FROM INFORMATION_SCHEMA.TABLES
|
|
|
|
WHERE TABLE_NAME LIKE 't_'
|
|
|
|
ORDER BY TABLE_NAME;
|
|
|
|
TABLE_NAME ENGINE
|
|
|
|
t1 MyISAM
|
|
|
|
t2 InnoDB
|
|
|
|
t3 InnoDB
|
|
|
|
t4 InnoDB
|
|
|
|
SELECT * FROM t1 ORDER BY a;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
4
|
|
|
|
5
|
|
|
|
6
|
|
|
|
SELECT * FROM t2 ORDER BY a;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
SELECT * FROM t3 ORDER BY a;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
SELECT * FROM t4 ORDER BY a;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
2008-12-03 20:55:49 +01:00
|
|
|
SHOW BINLOG EVENTS FROM 106;
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
Log_name Pos Event_type Server_id End_log_pos Info
|
2007-03-30 10:27:08 +02:00
|
|
|
# 106 Query # 192 use `test`; CREATE TABLE t1 (a INT)
|
2009-05-31 13:44:41 +08:00
|
|
|
# 192 Query # 260 BEGIN
|
2008-03-28 13:16:41 +01:00
|
|
|
# 260 Table_map # 301 table_id: # (test.t1)
|
|
|
|
# 301 Write_rows # 345 table_id: # flags: STMT_END_F
|
2009-05-31 13:44:41 +08:00
|
|
|
# 345 Query # 414 COMMIT
|
|
|
|
# 414 Query # 482 BEGIN
|
2008-03-28 13:16:41 +01:00
|
|
|
# 482 Query # 607 use `test`; CREATE TABLE `t2` (
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
`a` int(11) DEFAULT NULL
|
|
|
|
) ENGINE=InnoDB
|
2008-03-28 13:16:41 +01:00
|
|
|
# 607 Table_map # 648 table_id: # (test.t2)
|
|
|
|
# 648 Write_rows # 692 table_id: # flags: STMT_END_F
|
|
|
|
# 692 Xid # 719 COMMIT /* XID */
|
2009-05-31 13:44:41 +08:00
|
|
|
# 719 Query # 787 BEGIN
|
2008-03-28 13:16:41 +01:00
|
|
|
# 787 Query # 912 use `test`; CREATE TABLE `t3` (
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
`a` int(11) DEFAULT NULL
|
|
|
|
) ENGINE=InnoDB
|
2008-03-28 13:16:41 +01:00
|
|
|
# 912 Table_map # 953 table_id: # (test.t3)
|
|
|
|
# 953 Write_rows # 997 table_id: # flags: STMT_END_F
|
|
|
|
# 997 Xid # 1024 COMMIT /* XID */
|
2009-05-31 13:44:41 +08:00
|
|
|
# 1024 Query # 1092 BEGIN
|
2008-03-28 13:16:41 +01:00
|
|
|
# 1092 Query # 1217 use `test`; CREATE TABLE `t4` (
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
`a` int(11) DEFAULT NULL
|
|
|
|
) ENGINE=InnoDB
|
2008-03-28 13:16:41 +01:00
|
|
|
# 1217 Table_map # 1258 table_id: # (test.t4)
|
|
|
|
# 1258 Write_rows # 1302 table_id: # flags: STMT_END_F
|
|
|
|
# 1302 Xid # 1329 COMMIT /* XID */
|
2009-05-31 13:44:41 +08:00
|
|
|
# 1329 Query # 1397 BEGIN
|
2008-03-28 13:16:41 +01:00
|
|
|
# 1397 Table_map # 1438 table_id: # (test.t1)
|
|
|
|
# 1438 Write_rows # 1482 table_id: # flags: STMT_END_F
|
2009-05-31 13:44:41 +08:00
|
|
|
# 1482 Query # 1553 ROLLBACK
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
SHOW TABLES;
|
|
|
|
Tables_in_test
|
|
|
|
t1
|
|
|
|
t2
|
|
|
|
t3
|
|
|
|
t4
|
|
|
|
SELECT TABLE_NAME,ENGINE
|
|
|
|
FROM INFORMATION_SCHEMA.TABLES
|
|
|
|
WHERE TABLE_NAME LIKE 't_'
|
|
|
|
ORDER BY TABLE_NAME;
|
|
|
|
TABLE_NAME ENGINE
|
|
|
|
t1 MyISAM
|
|
|
|
t2 InnoDB
|
|
|
|
t3 InnoDB
|
|
|
|
t4 InnoDB
|
|
|
|
SELECT * FROM t1 ORDER BY a;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
4
|
|
|
|
5
|
|
|
|
6
|
|
|
|
SELECT * FROM t2 ORDER BY a;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
SELECT * FROM t3 ORDER BY a;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
SELECT * FROM t4 ORDER BY a;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
DROP TABLE IF EXISTS t1,t2,t3,t4;
|
|
|
|
SET AUTOCOMMIT=1;
|
|
|
|
STOP SLAVE;
|
|
|
|
RESET SLAVE;
|
|
|
|
RESET MASTER;
|
|
|
|
START SLAVE;
|
|
|
|
CREATE TABLE t1 (a INT);
|
|
|
|
INSERT INTO t1 VALUES (1),(2),(3);
|
|
|
|
CREATE TABLE t2 (a INT) ENGINE=INNODB;
|
|
|
|
BEGIN;
|
|
|
|
INSERT INTO t2 SELECT a*a FROM t1;
|
|
|
|
CREATE TEMPORARY TABLE tt1
|
|
|
|
SELECT a+1 AS a
|
|
|
|
FROM t1
|
|
|
|
WHERE a MOD 2 = 1;
|
|
|
|
INSERT INTO t2 SELECT a+2 FROM tt1;
|
|
|
|
COMMIT;
|
|
|
|
SELECT * FROM t2 ORDER BY a;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
4
|
|
|
|
4
|
|
|
|
6
|
|
|
|
9
|
2008-12-03 20:55:49 +01:00
|
|
|
SHOW BINLOG EVENTS FROM 106;
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
Log_name Pos Event_type Server_id End_log_pos Info
|
2007-03-30 10:27:08 +02:00
|
|
|
# 106 Query # 192 use `test`; CREATE TABLE t1 (a INT)
|
2009-05-31 13:44:41 +08:00
|
|
|
# 192 Query # 260 BEGIN
|
2008-03-28 13:16:41 +01:00
|
|
|
# 260 Table_map # 301 table_id: # (test.t1)
|
|
|
|
# 301 Write_rows # 345 table_id: # flags: STMT_END_F
|
2009-05-31 13:44:41 +08:00
|
|
|
# 345 Query # 414 COMMIT
|
2008-03-28 13:16:41 +01:00
|
|
|
# 414 Query # 514 use `test`; CREATE TABLE t2 (a INT) ENGINE=INNODB
|
2009-05-31 13:44:41 +08:00
|
|
|
# 514 Query # 582 BEGIN
|
2008-03-28 13:16:41 +01:00
|
|
|
# 582 Table_map # 623 table_id: # (test.t2)
|
|
|
|
# 623 Write_rows # 667 table_id: # flags: STMT_END_F
|
|
|
|
# 667 Table_map # 708 table_id: # (test.t2)
|
|
|
|
# 708 Write_rows # 747 table_id: # flags: STMT_END_F
|
|
|
|
# 747 Xid # 774 COMMIT /* XID */
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
SELECT * FROM t2 ORDER BY a;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
4
|
|
|
|
4
|
|
|
|
6
|
|
|
|
9
|
|
|
|
TRUNCATE TABLE t2;
|
2008-12-03 20:55:49 +01:00
|
|
|
**** Resetting master and slave ****
|
2009-01-23 13:22:05 +01:00
|
|
|
include/stop_slave.inc
|
2008-12-03 20:55:49 +01:00
|
|
|
RESET SLAVE;
|
|
|
|
RESET MASTER;
|
2009-01-23 13:22:05 +01:00
|
|
|
include/start_slave.inc
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
BEGIN;
|
|
|
|
INSERT INTO t2 SELECT a*a FROM t1;
|
|
|
|
CREATE TEMPORARY TABLE tt2
|
|
|
|
SELECT a+1 AS a
|
|
|
|
FROM t1
|
|
|
|
WHERE a MOD 2 = 1;
|
|
|
|
INSERT INTO t2 SELECT a+2 FROM tt2;
|
|
|
|
ROLLBACK;
|
2007-07-31 18:04:05 +03:00
|
|
|
Warnings:
|
|
|
|
Warning 1196 Some non-transactional changed tables couldn't be rolled back
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
SELECT * FROM t2 ORDER BY a;
|
|
|
|
a
|
2008-12-03 20:55:49 +01:00
|
|
|
SHOW BINLOG EVENTS FROM 106;
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
Log_name Pos Event_type Server_id End_log_pos Info
|
2009-05-31 13:44:41 +08:00
|
|
|
# 106 Query # 174 BEGIN
|
2008-12-03 20:55:49 +01:00
|
|
|
# 174 Table_map # 215 table_id: # (test.t2)
|
|
|
|
# 215 Write_rows # 259 table_id: # flags: STMT_END_F
|
|
|
|
# 259 Table_map # 300 table_id: # (test.t2)
|
|
|
|
# 300 Write_rows # 339 table_id: # flags: STMT_END_F
|
2009-05-31 13:44:41 +08:00
|
|
|
# 339 Query # 410 ROLLBACK
|
BUG#22864 (Rollback following CREATE... SELECT discards 'CREATE TABLE'
from log):
When row-based logging is used, the CREATE-SELECT is written as two
parts: as a CREATE TABLE statement and as the rows for the table. For
both transactional and non-transactional tables, the CREATE TABLE
statement was written to the transaction cache, as were the rows, and
on statement end, the entire transaction cache was written to the binary
log if the table was non-transactional. For transactional tables, the
events were kept in the transaction cache until end of transaction (or
statement that were not part of a transaction).
For the case when AUTOCOMMIT=0 and we are creating a transactional table
using a create select, we would then keep the CREATE TABLE statement and
the rows for the CREATE-SELECT, while executing the following statements.
On a rollback, the transaction cache would then be cleared, which would
also remove the CREATE TABLE statement. Hence no table would be created
on the slave, while there is an empty table on the master.
This relates to BUG#22865 where the table being created exists on the
master, but not on the slave during insertion of rows into the newly
created table. This occurs since the CREATE TABLE statement were still
in the transaction cache until the statement finished executing, and
possibly longer if the table was transactional.
This patch changes the behaviour of the CREATE-SELECT statement by
adding an implicit commit at the end of the statement when creating
non-temporary tables. Hence, non-temporary tables will be written to the
binary log on completion, and in the even of AUTOCOMMIT=0, a new
transaction will be started. Temporary tables do not commit an ongoing
transaction: neither as a pre- not a post-commit.
The events for both transactional and non-transactional tables are
saved in the transaction cache, and written to the binary log at end
of the statement.
2006-12-21 09:29:02 +01:00
|
|
|
SELECT * FROM t2 ORDER BY a;
|
|
|
|
a
|
|
|
|
DROP TABLE t1,t2;
|
2008-04-08 10:43:00 +03:00
|
|
|
CREATE TABLE t1 (a INT);
|
|
|
|
INSERT INTO t1 VALUES (1),(1);
|
|
|
|
CREATE TABLE t2 (a INT UNIQUE) ENGINE=INNODB SELECT * FROM t1;
|
|
|
|
ERROR 23000: Duplicate entry '1' for key 'a'
|
|
|
|
INSERT INTO t1 VALUES (2);
|
|
|
|
*** the proof of the fix:
|
|
|
|
select must show that the last insert performed on the slave ***
|
|
|
|
SELECT * FROM t1;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
1
|
|
|
|
2
|
|
|
|
DROP TABLE t1;
|
2008-08-19 13:18:59 +02:00
|
|
|
stop slave;
|
|
|
|
drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
|
|
|
|
reset master;
|
|
|
|
reset slave;
|
|
|
|
drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
|
|
|
|
start slave;
|
2008-11-27 15:04:48 +03:00
|
|
|
DROP DATABASE IF EXISTS mysqltest1;
|
2008-08-19 13:18:59 +02:00
|
|
|
CREATE DATABASE mysqltest1;
|
|
|
|
CREATE TABLE mysqltest1.without_select (f1 BIGINT);
|
|
|
|
CREATE TABLE mysqltest1.with_select AS SELECT 1 AS f1;
|
|
|
|
show binlog events from <binlog_start>;
|
|
|
|
Log_name Pos Event_type Server_id End_log_pos Info
|
2008-11-27 15:04:48 +03:00
|
|
|
master-bin.000001 # Query # # DROP DATABASE IF EXISTS mysqltest1
|
2008-08-19 13:18:59 +02:00
|
|
|
master-bin.000001 # Query # # CREATE DATABASE mysqltest1
|
|
|
|
master-bin.000001 # Query # # use `test`; CREATE TABLE mysqltest1.without_select (f1 BIGINT)
|
2009-05-31 13:44:41 +08:00
|
|
|
master-bin.000001 # Query # # BEGIN
|
2008-08-19 13:18:59 +02:00
|
|
|
master-bin.000001 # Query # # use `test`; CREATE TABLE `mysqltest1`.`with_select` (
|
|
|
|
`f1` int(1) NOT NULL DEFAULT '0'
|
|
|
|
)
|
|
|
|
master-bin.000001 # Table_map # # table_id: # (mysqltest1.with_select)
|
|
|
|
master-bin.000001 # Write_rows # # table_id: # flags: STMT_END_F
|
2009-05-31 13:44:41 +08:00
|
|
|
master-bin.000001 # Query # # COMMIT
|
2008-08-19 13:18:59 +02:00
|
|
|
DROP DATABASE mysqltest1;
|
2008-04-08 10:43:00 +03:00
|
|
|
end of the tests
|