mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-04-04 14:25:37 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
mariadb/mysql-test/main/backup_log.result
Monty e62dc52420 MDEV-25292 Atomic CREATE OR REPLACE TABLE 
Atomic CREATE OR REPLACE allows to keep an old table intact if the
command fails or during the crash. That is done by renaming the
original table to temporary name, as a backup and restoring it if the
CREATE fails. When the command is complete and logged the backup
table is deleted.

Atomic replace algorithm

  Two DDL chains are used for CREATE OR REPLACE:
  ddl_log_state_create (C) and ddl_log_state_rm (D).

  1. (C) Log rename of ORIG to TMP table (Rename TMP to original).
  2. Rename orignal to TMP.
  3. (C) Log CREATE_TABLE_ACTION of ORIG (drops ORIG);
  4. Do everything with ORIG (like insert data)
  5. (D) Log drop of TMP
  6. Write query to binlog (this marks (C) to be closed in
     case of failure)
  7. Execute drop of TMP through (D)
  8. Close (C) and (D)

  If there is a failure before 6) we revert the changes in (C)
  Chain (D) is only executed if 6) succeded (C is closed on
  crash recovery).

Foreign key errors will be found at the 1) stage.

Additional notes

  - CREATE TABLE without REPLACE and temporary tables is not affected
    by this commit.
    set @@drop_before_create_or_replace=1 can be used to
    get old behaviour where existing tables are dropped
    in CREATE OR REPLACE.

  - CREATE TABLE is reverted if binlogging the query fails.

  - Engines having HTON_EXPENSIVE_RENAME flag set are not affected by
    this commit. Conflicting tables marked with this flag will be
    deleted with CREATE OR REPLACE.

  - Replication execution is not affected by this commit.
    - Replication will first drop the conflicting table and then
      creating the new one.

  - CREATE TABLE .. SELECT XID usage is fixed and now there is no need
    to log DROP TABLE via DDL_CREATE_TABLE_PHASE_LOG (see comments in
    do_postlock()). XID is now correctly updated so it disables
    DDL_LOG_DROP_TABLE_ACTION. Note that binary log is flushed at the
    final stage when the table is ready. So if we have XID in the
    binary log we don't need to drop the table.

  - Three variations of CREATE OR REPLACE handled:

    1. CREATE OR REPLACE TABLE t1 (..);
    2. CREATE OR REPLACE TABLE t1 LIKE t2;
    3. CREATE OR REPLACE TABLE t1 SELECT ..;

  - Test case uses 6 combinations for engines (aria, aria_notrans,
    myisam, ib, lock_tables, expensive_rename) and 2 combinations for
    binlog types (row, stmt). Combinations help to check differences
    between the results. Error failures are tested for the above three
    variations.

  - expensive_rename tests CREATE OR REPLACE without atomic
    replace. The effect should be the same as with the old behaviour
    before this commit.

  - Triggers mechanism is unaffected by this change. This is tested in
    create_replace.test.

  - LOCK TABLES is affected. Lock restoration must be done after new
    table is created or TMP is renamed back to ORIG

  - Moved ddl_log_complete() from send_eof() to finalize_ddl(). This
    checkpoint was not executed before for normal CREATE TABLE but is
    executed now.

  - CREATE TABLE will now rollback also if writing to the binary
    logging failed. See rpl_gtid_strict.test

backup ddl log changes

- In case of a successfull CREATE OR REPLACE we only log
  the CREATE event, not the DROP TABLE event of the old table.

ddl_log.cc changes

  ddl_log_execute_action() now properly return error conditions.
  ddl_log_disable_entry() added to allow one to disable one entry.
  The entry on disk is still reserved until ddl_log_complete() is
  executed.

On XID usage

  Like with all other atomic DDL operations XID is used to avoid
  inconsistency between master and slave in the case of a crash after
  binary log is written and before ddl_log_state_create is closed. On
  recovery XIDs are taken from binary log and corresponding DDL log
  events get disabled.  That is done by
  ddl_log_close_binlogged_events().

On linking two chains together

  Chains are executed in the ascending order of entry_pos of execute
  entries. But entry_pos assignment order is undefined: it may assign
  bigger number for the first chain and then smaller number for the
  second chain. So the execution order in that case will be reverse:
  second chain will be executed first.

  To avoid that we link one chain to another. While the base chain
  (ddl_log_state_create) is active the secondary chain
  (ddl_log_state_rm) is not executed. That is: only one chain can be
  executed in two linked chains.

  The interface ddl_log_link_chains() was defined in "MDEV-22166
  ddl_log_write_execute_entry() extension".

Atomic info parameters in HA_CREATE_INFO

  Many functions in CREATE TABLE pass the same parameters. These
  parameters are part of table creation info and should be in
  HA_CREATE_INFO (or whatever). Passing parameters via single
  structure is much easier for adding new data and
  refactoring.

InnoDB changes
  Added ha_innobase::can_be_renamed_to_backup() to check if
  a table with foreign keys can be renamed.

Aria changes:
- Fixed issue in Aria engine with CREATE + locked tables
  that data was not properly commited in some cases in
  case of crashes.

Known issues:
- InnoDB tables with foreign key definitions are not fully supported
  with atomic create and replace:
  - ha_innobase::can_be_renamed_to_backup() can detect some cases
    where InnoDB does not support renaming table with foreign key
    constraints.  In this case MariaDB will drop the old table before
    creating the new one.
    The detected cases are:
    - The new and old table is using the same foreign key constraint
      name.
    - The old table has self referencing constraints.
  - If the old and new table uses the same name for a constraint the
    create of the new table will fail. The orignal table will be
    restored in this case.
  - The above issues will be fixed in a future commit.
- CREATE OR REPLACE TEMPORARY table is not full atomic. Any conflicting
  table will always be dropped before creating a new one. (Old behaviour).
2025-03-18 18:28:16 +01:00

282 lines
8.2 KiB
Text
Raw Permalink Blame History

CREATE TABLE t_exists (a INT);
CREATE TABLE t_exists_template (a INT);
connect con1,localhost,root,,;
BACKUP STAGE START;
connection default;
#
# Testing with normal tables
#
create table t1 (a int) engine=myisam ;
insert into t1 values (1),(2);
alter table t1 add column b int;
alter table t1 rename as t2;
rename table t2 to t1;
truncate table t1;
repair table t1;
Table Op Msg_type Msg_text
test.t1 repair status OK
optimize table t1;
Table Op Msg_type Msg_text
test.t1 optimize status OK
drop table t1;
#
# Reading backup ddl log file
#
CREATE,MyISAM,0,test,t1,id: 1,,0,,,
ALTER,MyISAM,0,test,t1,id: 1,MyISAM,0,test,t1,id: 2
RENAME,MyISAM,0,test,t1,id: 2,MyISAM,0,test,t2,id: 2
RENAME,MyISAM,0,test,t2,id: 2,MyISAM,0,test,t1,id: 2
repair,MyISAM,0,test,t1,id: 2,,0,,,
optimize,MyISAM,0,test,t1,id: 2,,0,,,
DROP,MyISAM,0,test,t1,id: 2,,0,,,
create table t1_innodb (a int) engine=innodb ;
insert into t1_innodb values (1),(2);
alter table t1_innodb add column b int;
alter table t1_innodb rename as t2_innodb;
rename table t2_innodb to t1_innodb;
truncate table t1_innodb;
repair table t1_innodb;
Table Op Msg_type Msg_text
test.t1_innodb repair status OK
optimize table t1_innodb;
Table Op Msg_type Msg_text
test.t1_innodb optimize note Table does not support optimize, doing recreate + analyze instead
test.t1_innodb optimize status OK
drop table t1_innodb;
#
# Reading backup ddl log file
#
CREATE,InnoDB,0,test,t1_innodb,id: 1,,0,,,
ALTER,InnoDB,0,test,t1_innodb,id: 1,InnoDB,0,test,t1_innodb,id: 2
RENAME,InnoDB,0,test,t1_innodb,id: 2,InnoDB,0,test,t2_innodb,id: 2
RENAME,InnoDB,0,test,t2_innodb,id: 2,InnoDB,0,test,t1_innodb,id: 2
TRUNCATE,InnoDB,0,test,t1_innodb,id: 2,,0,,,
repair,InnoDB,0,test,t1_innodb,id: 2,,0,test,t1_innodb,id: 3
optimize,InnoDB,0,test,t1_innodb,id: 3,,0,test,t1_innodb,id: 4
DROP,InnoDB,0,test,t1_innodb,id: 4,,0,,,
#
# Testing with temporary tables (should not be logged)
#
create temporary table tmp_t10 (a int) engine=myisam;
alter table tmp_t10 add column b int;
alter table tmp_t10 rename as tmp_t11;
rename table tmp_t11 to tmp_t10;
truncate table tmp_t10;
drop table tmp_t10;
#
# Reading backup ddl log file
#
#
# Testing with mix of normal and temporary tables
#
create temporary table tmp_t20 (a int);
create table t20 (a int) ;
drop table tmp_t20,t20;
create temporary table tmp_t21 (a int);
create table t21 (a int) ;
drop temporary table if exists tmp_t21,t21;
Warnings:
Note 1051 Unknown table 'test.t21'
drop table if exists tmp_t21,t21;
Warnings:
Note 1051 Unknown table 'test.tmp_t21'
#
# Reading backup ddl log file
#
CREATE,MyISAM,0,test,t20,id: 1,,0,,,
DROP,MyISAM,0,test,t20,id: 1,,0,,,
CREATE,MyISAM,0,test,t21,id: 2,,0,,,
DROP,MyISAM,0,test,t21,id: 2,,0,,,
#
# Testing create select
#
create table t30 (a int) ;
insert into t30 values (1),(1);
create table t31 (a int primary key) select * from t30 limit 1;
create or replace table t31 select * from t30 limit 1;
create or replace temporary table t30_dup select * from t30 limit 1;
create or replace table t31 (a int primary key) select * from t30;
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
create table t32 (a int) ;
drop table if exists t30,t31,t32,tmp_t30;
Warnings:
Note 1051 Unknown table 'test.tmp_t30'
#
# Reading backup ddl log file
#
CREATE,MyISAM,0,test,t30,id: 1,,0,,,
CREATE,MyISAM,0,test,t31,id: 2,,0,,,
CREATE,MyISAM,0,test,t31,id: 3,,0,,,
CREATE,MyISAM,0,test,t32,id: 4,,0,,,
DROP,MyISAM,0,test,t30,id: 1,,0,,,
DROP,MyISAM,0,test,t31,id: 3,,0,,,
DROP,MyISAM,0,test,t32,id: 4,,0,,,
#
# Testing create LIKE
#
create table t40 (a int) engine=myisam ;
create table t41 (a int, b int) engine=innodb ;
create table t42 like t40;
create temporary table t43_tmp like t40;
create or replace table t42 like t41;
show create table t42;
Table Create Table
t42 CREATE TABLE `t42` (
`a` int(11) DEFAULT NULL,
`b` int(11) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_uca1400_ai_ci
drop table t40, t41, t42;
#
# Reading backup ddl log file
#
CREATE,MyISAM,0,test,t40,id: 1,,0,,,
CREATE,InnoDB,0,test,t41,id: 2,,0,,,
CREATE,MyISAM,0,test,t42,id: 3,,0,,,
CREATE,InnoDB,0,test,t42,id: 4,,0,,,
DROP,MyISAM,0,test,t40,id: 1,,0,,,
DROP,InnoDB,0,test,t41,id: 2,,0,,,
DROP,InnoDB,0,test,t42,id: 4,,0,,,
#
# Testing rename
#
create table t50 (a int) ;
create table t51 (a int, b int) ;
rename table t50 to t52, t51 to t53;
rename table t52 to tmp, t53 to t52, tmp to t53;
drop table t52,t53;
#
# Reading backup ddl log file
#
CREATE,MyISAM,0,test,t50,id: 1,,0,,,
CREATE,MyISAM,0,test,t51,id: 2,,0,,,
RENAME,MyISAM,0,test,t50,id: 1,MyISAM,0,test,t52,id: 1
RENAME,MyISAM,0,test,t51,id: 2,MyISAM,0,test,t53,id: 2
RENAME,MyISAM,0,test,t52,id: 1,MyISAM,0,test,tmp,id: 1
RENAME,MyISAM,0,test,t53,id: 2,MyISAM,0,test,t52,id: 2
RENAME,MyISAM,0,test,tmp,id: 1,MyISAM,0,test,t53,id: 1
DROP,MyISAM,0,test,t52,id: 2,,0,,,
DROP,MyISAM,0,test,t53,id: 1,,0,,,
#
# Testing enable/disable keys
#
CREATE TABLE t60 (a int(10), index(a) ) ENGINE=Aria ;
INSERT INTO t60 VALUES(1),(2),(3);
ALTER TABLE t60 DISABLE KEYS;
INSERT INTO t60 VALUES(4),(5),(6);
ALTER TABLE t60 ENABLE KEYS;
DROP TABLE t60;
CREATE TEMPORARY TABLE t61 (i int(10), index(i) ) ENGINE=Aria;
INSERT INTO t61 VALUES(1),(2),(3);
ALTER TABLE t61 DISABLE KEYS;
DROP TABLE t61;
#
# Reading backup ddl log file
#
CREATE,Aria,0,test,t60,id: 1,,0,,,
CHANGE_INDEX,Aria,0,test,t60,id: 1,,0,,,
CHANGE_INDEX,Aria,0,test,t60,id: 1,,0,,,
DROP,Aria,0,test,t60,id: 1,,0,,,
#
# Testing load data
#
create table t70 (a date, b date, c date not null, d date) engine=aria ;
load data infile '../../std_data/loaddata1.dat' ignore into table t70 fields terminated by ',';
load data infile '../../std_data/loaddata1.dat' ignore into table t70 fields terminated by ',';
truncate table t70;
lock table t70 write;
load data infile '../../std_data/loaddata1.dat' ignore into table t70 fields terminated by ',';
load data infile '../../std_data/loaddata1.dat' ignore into table t70 fields terminated by ',';
unlock tables;
create table t71 (a date, b date, c date not null, d date) engine=aria ;
lock tables t71 write, t70 read;
insert into t71 select * from t70;
unlock tables;
drop table t70,t71;
#
# Reading backup ddl log file
#
CREATE,Aria,0,test,t70,id: 1,,0,,,
BULK_INSERT,Aria,0,test,t70,id: 1,,0,,,
BULK_INSERT,Aria,0,test,t70,id: 1,,0,,,
CREATE,Aria,0,test,t71,id: 2,,0,,,
BULK_INSERT,Aria,0,test,t71,id: 2,,0,,,
DROP,Aria,0,test,t70,id: 1,,0,,,
DROP,Aria,0,test,t71,id: 2,,0,,,
#
# Testing strange table names
#
create table `t 1` (a int) ;
drop table `t 1`;
#
# Reading backup ddl log file
#
CREATE,MyISAM,0,test,t@00201,id: 1,,0,,,
DROP,MyISAM,0,test,t@00201,id: 1,,0,,,
#
# Testing views and triggers
#
create table t80 (a int, b int) engine=myisam ;
create view v1 as select * from t80;
create trigger trg before insert on t80 for each row set @b:=1;
drop trigger trg;
drop view v1;
drop table t80;
#
# Reading backup ddl log file
#
CREATE,MyISAM,0,test,t80,id: 1,,0,,,
CREATE,VIEW,0,test,v1,,,0,,,
CREATE,TRIGGER,0,test,trg,,,0,,,
DROP,TRIGGER,0,test,trg,,,0,,,
DROP,VIEW,0,test,v1,,,0,,,
DROP,MyISAM,0,test,t80,id: 1,,0,,,
#
# Testing alter to a new storage engine
#
create table t85 (a int primary key, b int) engine=myisam ;
alter table t85 engine=innodb;
drop table t85;
#
# Reading backup ddl log file
#
CREATE,MyISAM,0,test,t85,id: 1,,0,,,
ALTER,MyISAM,0,test,t85,id: 1,InnoDB,0,test,t85,id: 2
DROP,InnoDB,0,test,t85,id: 2,,0,,,
#
# Testing create/drop/alter database
#
create database mysqltest;
create table mysqltest.t90 (a int primary key, b int) engine=myisam;
create table mysqltest.t91 (a int primary key, b int) engine=innodb;
alter database mysqltest character set utf8;
drop database mysqltest;
#
# Reading backup ddl log file
#
CREATE,DATABASE,0,mysqltest,,,,0,,,
CREATE,MyISAM,0,mysqltest,t90,id: 1,,0,,,
CREATE,InnoDB,0,mysqltest,t91,id: 2,,0,,,
ALTER,DATABASE,0,mysqltest,,,,0,,,
DROP,MyISAM,0,mysqltest,t90,id: 1,,0,,,
DROP,InnoDB,0,mysqltest,t91,id: 2,,0,,,
DROP,DATABASE,0,mysqltest,,,,0,,,
#
# MENT-222 bug testing
#
CREATE TABLE IF NOT EXISTS t_exists LIKE t_exists_template;
Warnings:
Note 1050 Table 't_exists' already exists
#
# Reading backup ddl log file
#
#
# Cleanup
#
DROP TABLE t_exists;
DROP TABLE t_exists_template;
#
# Reading backup ddl log file
#
DROP,MyISAM,0,test,t_exists,id: 1,,0,,,
DROP,MyISAM,0,test,t_exists_template,id: 2,,0,,,
disconnect con1;
Reference in a new issue View git blame Copy permalink