1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

dead code - related to vtmd

Browse Source 
(will be added back when it'll be used)
This commit is contained in:
Sergei Golubchik 2018-02-26 17:17:17 +01:00
parent 09e6280147
commit 35678c9572
36 changed files with 55 additions and 2658 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
libmysqld/CMakeLists.txt
View File

@ -121,7 +121,6 @@ SET(SQL_EMBEDDED_SOURCES emb_qcache.cc libmysqld.c lib_sql.cc
../sql/sql_tvc.cc ../sql/sql_tvc.h ../sql/sql_tvc.cc ../sql/sql_tvc.h
../sql/opt_split.cc ../sql/opt_split.cc
../sql/item_vers.cc ../sql/item_vers.cc
../sql/vtmd.cc
${GEN_SOURCES} ${GEN_SOURCES}
${MYSYS_LIBWRAP_SOURCE} ${MYSYS_LIBWRAP_SOURCE}
) )

3
mysql-test/suite/versioning/disabled.def
View File

@ -9,7 +9,4 @@
# Do not use any TAB characters for whitespace. # Do not use any TAB characters for whitespace.
# #
############################################################################## ##############################################################################
ddl : DDL Survival WIP
vtmd : DDL Survival WIP
vtmd_show : DDL Survival WIP
cte: MDEV-14820 cte: MDEV-14820

211
mysql-test/suite/versioning/r/ddl.result
View File

@ -1,211 +0,0 @@
set @@session.time_zone='+00:00';
select ifnull(max(transaction_id), 0) into @start_trx_id from mysql.transaction_registry;
set @test_start=now(6);
create procedure if not exists verify_vtq()
begin
set @i= 0;
select
@i:= @i + 1 as No,
transaction_id > 0 as A,
commit_id > transaction_id as B,
begin_timestamp > @test_start as C,
commit_timestamp >= begin_timestamp as D
from mysql.transaction_registry
where transaction_id > @start_trx_id;
select ifnull(max(transaction_id), 0)
into @start_trx_id
from mysql.transaction_registry;
end~~
create function if not exists default_engine()
returns varchar(255)
deterministic
begin
declare e varchar(255);
select lower(engine) from information_schema.engines where support='DEFAULT' into e;
return e;
end~~
create function if not exists sys_datatype()
returns varchar(255)
deterministic
begin
if default_engine() = 'innodb' then
return 'bigint unsigned';
elseif default_engine() = 'myisam' then
return 'timestamp(6)';
end if;
return NULL;
end~~
create function if not exists sys_commit_ts(sys_field varchar(255))
returns varchar(255)
deterministic
begin
if default_engine() = 'innodb' then
return concat('vtq_commit_ts(', sys_field, ')');
elseif default_engine() = 'myisam' then
return sys_field;
end if;
return NULL;
end~~
create procedure if not exists innodb_verify_vtq(recs int)
begin
declare i int default 1;
if default_engine() = 'innodb' then
call verify_vtq;
elseif default_engine() = 'myisam' then
create temporary table tmp (No int, A bool, B bool, C bool, D bool);
while i <= recs do
insert into tmp values (i, 1, 1, 1, 1);
set i= i + 1;
end while;
select * from tmp;
drop table tmp;
end if;
end~~
create procedure concat_exec2(a varchar(255), b varchar(255))
begin
prepare stmt from concat(a, b);
execute stmt;
deallocate prepare stmt;
end~~
create procedure concat_exec3(a varchar(255), b varchar(255), c varchar(255))
begin
prepare stmt from concat(a, b, c);
execute stmt;
deallocate prepare stmt;
end~~
create function get_archive_table_name()
returns varchar(255)
begin
return (select archive_name from t_vtmd for system_time all where archive_name is not NULL
order by start desc limit 1);
end~~
create procedure drop_last_archive()
begin
call concat_exec2('drop table ', get_archive_table_name());
end~~
set versioning_alter_history= survive;
create or replace table t (a int) with system versioning;
insert into t values (1);
update t set a=2 where a=1;
select sys_trx_start from t where a=2 into @tm;
alter table t add column b int;
select * from t;
a b
2 NULL
call concat_exec3('select * from ', get_archive_table_name(), ' for system_time all');
a
2
1
call concat_exec3('select @tm=sys_trx_start from ', get_archive_table_name(), ' for system_time all where a=2');
@tm=sys_trx_start
1
select @tm<sys_trx_start from t where a=2;
@tm<sys_trx_start
1
select sys_trx_start from t where a=2 into @tm;
call concat_exec3('select @tm=sys_trx_end from ', get_archive_table_name(), ' for system_time all where a=2');
@tm=sys_trx_end
1
call drop_last_archive();
set versioning_alter_history= keep;
drop table t_vtmd;
drop table t;
set versioning_alter_history= survive;
create or replace table t (a int) with system versioning;
insert into t values (1);
update t set a=2 where a=1;
select sys_trx_start from t where a=2 into @tm;
alter table t add column b int;
select * from t;
a b
2 NULL
call concat_exec3('select * from ', get_archive_table_name(), ' for system_time all');
a
2
1
call concat_exec3('select @tm=sys_trx_start from ', get_archive_table_name(), ' for system_time all where a=2');
@tm=sys_trx_start
1
select @tm<sys_trx_start from t where a=2;
@tm<sys_trx_start
1
select sys_trx_start from t where a=2 into @tm;
call concat_exec3('select @tm=sys_trx_end from ', get_archive_table_name(), ' for system_time all where a=2');
@tm=sys_trx_end
1
call drop_last_archive();
set versioning_alter_history= keep;
drop table t_vtmd;
drop table t;
set versioning_alter_history= survive;
create or replace table t (a int) with system versioning engine innodb;
insert into t values (1);
update t set a=2 where a=1;
select sys_trx_start from t where a=2 into @tm;
alter table t add column b int;
select * from t;
a b
2 NULL
call concat_exec3('select * from ', get_archive_table_name(), ' for system_time all');
a
2
1
call concat_exec3('select @tm=sys_trx_start from ', get_archive_table_name(), ' for system_time all where a=2');
@tm=sys_trx_start
1
select @tm<sys_trx_start from t where a=2;
@tm<sys_trx_start
1
select sys_trx_start from t where a=2 into @tm;
call concat_exec3('select @tm=sys_trx_end from ', get_archive_table_name(), ' for system_time all where a=2');
@tm=sys_trx_end
1
call drop_last_archive();
set versioning_alter_history= keep;
drop table t_vtmd;
drop table t;
set versioning_alter_history= survive;
create or replace table t (a int) with system versioning engine innodb;
insert into t values (1);
update t set a=2 where a=1;
alter table t add column b int, algorithm=inplace;
set versioning_alter_history = keep;
drop function get_archive_table_name;
drop procedure drop_last_archive;
select * from mysql.vtmd_template;
start end name archive_name col_renames
show create table mysql.vtmd_template;
Table Create Table
vtmd_template CREATE TABLE `vtmd_template` (
`start` bigint(20) unsigned GENERATED ALWAYS AS ROW START COMMENT 'TRX_ID of table lifetime start',
`end` bigint(20) unsigned GENERATED ALWAYS AS ROW END NOT NULL COMMENT 'TRX_ID of table lifetime end',
`name` varchar(64) COLLATE utf8_bin NOT NULL COMMENT 'Table name during current lifetime period',
`archive_name` varchar(64) COLLATE utf8_bin DEFAULT NULL COMMENT 'Name of archive table',
`col_renames` blob DEFAULT NULL COMMENT 'Column name mappings from previous lifetime',
PRIMARY KEY (`end`),
KEY `archive_name` (`archive_name`),
PERIOD FOR SYSTEM_TIME (`start`, `end`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin STATS_PERSISTENT=0 WITH SYSTEM VERSIONING
call verify_vtq;
No A B C D
1 1 1 1 1
2 1 1 1 1
3 1 1 1 1
4 1 1 1 1
5 1 1 1 1
6 1 1 1 1
7 1 1 1 1
8 1 1 1 1
9 1 1 1 1
10 1 1 1 1
11 1 1 1 1
12 1 1 1 1
drop table t;
drop table t_vtmd;
drop procedure verify_vtq;
drop procedure innodb_verify_vtq;
drop function default_engine;
drop function sys_commit_ts;
drop function sys_datatype;
drop procedure concat_exec2;
drop procedure concat_exec3;

365
mysql-test/suite/versioning/r/vtmd.result
View File

@ -1,365 +0,0 @@
create or replace procedure drop_archives (in vtmd_name varchar(64))
begin
declare archive_name varchar(64);
declare cur_done bool default false;
declare cur cursor for
select cur_tmp.archive_name from cur_tmp;
declare continue handler for not found set cur_done = true;
set @tmp= concat('
create or replace temporary table
cur_tmp as
select vtmd.archive_name from ', vtmd_name, '
for system_time all as vtmd
where vtmd.archive_name is not null
group by vtmd.archive_name');
prepare stmt from @tmp; execute stmt; drop prepare stmt;
open cur;
fetch_loop: loop
fetch cur into archive_name;
if cur_done then
leave fetch_loop;
end if;
set @tmp= concat('drop table ', archive_name);
prepare stmt from @tmp; execute stmt; drop prepare stmt;
end loop;
drop table cur_tmp;
end~~
create or replace procedure check_vtmd (in vtmd_name varchar(64))
begin
set @tmp= concat('
create or replace temporary table
tmp_vtmd with system versioning as
select * from ', vtmd_name, '
for system_time all as vtmd');
prepare stmt from @tmp; execute stmt; drop prepare stmt;
set @inf= 0xFFFFFFFFFFFFFFFF + 0;
set @start= null;
select start from tmp_vtmd for system_time all order by start limit 1 into @start;
select @start > 0 and @start < @inf;
select
start >= @start as A_start,
(@start:= end) and end = @inf as B_end,
name,
substr(archive_name, 1, instr(archive_name, '_')) as C_archive_name
from tmp_vtmd for system_time all;
drop table tmp_vtmd;
end~~
create or replace procedure show_tables()
begin
show tables;
select table_name, table_schema from information_schema.tables
where table_schema not in ('mysql', 'performance_schema', 'information_schema', 'mtr')
order by table_name;
end~~
set versioning_alter_history= keep;
create table t0 (z int) with system versioning;
show tables;
Tables_in_test
t0
set versioning_alter_history= survive;
create or replace table t0 (y int) with system versioning;
show tables;
Tables_in_test
t0
t0_vtmd
show create table t0_vtmd;
Table Create Table
t0_vtmd CREATE TABLE `t0_vtmd` (
`start` bigint(20) unsigned GENERATED ALWAYS AS ROW START COMMENT 'TRX_ID of table lifetime start',
`end` bigint(20) unsigned GENERATED ALWAYS AS ROW END NOT NULL COMMENT 'TRX_ID of table lifetime end',
`name` varchar(64) COLLATE utf8_bin NOT NULL COMMENT 'Table name during current lifetime period',
`archive_name` varchar(64) COLLATE utf8_bin DEFAULT NULL COMMENT 'Name of archive table',
`col_renames` blob DEFAULT NULL COMMENT 'Column name mappings from previous lifetime',
PRIMARY KEY (`end`),
KEY `archive_name` (`archive_name`),
PERIOD FOR SYSTEM_TIME (`start`, `end`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin STATS_PERSISTENT=0 WITH SYSTEM VERSIONING
call check_vtmd('t0_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 1 t0 NULL
set versioning_alter_history= keep;
drop table t0;
set versioning_alter_history= survive;
create table t0 (x int) with system versioning;
ERROR HY000: VTMD error: `test.t0_vtmd` exists and not empty!
drop table t0_vtmd;
create table t0 (y int) with system versioning;
create or replace table t0 (x int) with system versioning;
insert into t0 values (1);
set @t0= now(6);
alter table t0 add column (y int);
select * from t0 for system_time as of @t0;
x
1
select * from t0;
x y
1 NULL
call check_vtmd('t0_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 0 t0 t0_
1 0 t0 t0_
1 1 t0 NULL
call drop_archives('t0_vtmd');
drop table t0_vtmd;
alter table t0 drop column y;
call check_vtmd('t0_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 1 t0 t0_
call drop_archives('t0_vtmd');
set versioning_alter_history= keep;
drop tables t0, t0_vtmd;
set versioning_alter_history= survive;
set versioning_alter_history= keep;
create or replace table x0 (x int) with system versioning;
set versioning_alter_history= survive;
rename table x0 to d0;
show tables;
Tables_in_test
d0
set versioning_alter_history= keep;
drop table d0;
set versioning_alter_history= survive;
create or replace table x0 (x int) with system versioning;
rename table x0 to d0;
show tables;
Tables_in_test
d0
d0_vtmd
call check_vtmd('d0_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 0 x0 NULL
1 1 d0 NULL
set versioning_alter_history= keep;
drop table d0;
set versioning_alter_history= survive;
create or replace table x0 (x int) with system versioning;
rename table x0 to d0;
ERROR HY000: VTMD error: `test.d0_vtmd` table already exists!
show tables;
Tables_in_test
d0_vtmd
x0
x0_vtmd
drop table x0_vtmd;
rename table x0 to d0;
Warnings:
Warning 4122 `test.d0_vtmd` table already exists!
show tables;
Tables_in_test
d0
d0_vtmd
rename table d0 to duck;
rename table duck to bay;
rename table bay to sheer;
rename table sheer to t0;
call check_vtmd('t0_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 0 x0 NULL
1 0 d0 NULL
1 0 duck NULL
1 0 bay NULL
1 0 sheer NULL
1 1 t0 NULL
alter table t0 add column (y int);
call check_vtmd('t0_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 0 x0 t0_
1 0 d0 t0_
1 0 duck t0_
1 0 bay t0_
1 0 sheer t0_
1 0 t0 t0_
1 1 t0 NULL
alter table t0 add column (z int);
alter table t0 drop column y;
alter table t0 drop column z;
create database db0;
rename table t0 to db0.t0;
show tables;
Tables_in_test
use db0;
show tables;
Tables_in_db0
t0
t0_vtmd
call test.check_vtmd('db0.t0_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 0 x0 t0_
1 0 d0 t0_
1 0 duck t0_
1 0 bay t0_
1 0 sheer t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 t0_
1 1 t0 NULL
create database db1;
rename table t0 to db1.other_name;
show tables;
Tables_in_db0
use db1;
show tables;
Tables_in_db1
other_name
other_name_vtmd
call test.check_vtmd('db1.other_name_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 0 x0 t0_
1 0 d0 t0_
1 0 duck t0_
1 0 bay t0_
1 0 sheer t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 NULL
1 1 other_name NULL
alter table other_name rename to t1;
call test.check_vtmd('db1.t1_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 0 x0 t0_
1 0 d0 t0_
1 0 duck t0_
1 0 bay t0_
1 0 sheer t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 NULL
1 0 other_name NULL
1 1 t1 NULL
alter table t1 rename to test.t2, add column (y int);
use test;
show tables;
Tables_in_test
t2
t2_vtmd
call check_vtmd('t2_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 0 x0 t0_
1 0 d0 t0_
1 0 duck t0_
1 0 bay t0_
1 0 sheer t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 t0_
1 0 t0 t1_
1 0 other_name t1_
1 0 t1 t1_
1 1 t2 NULL
create or replace table t3 (x int) with system versioning;
alter table t3 change x x bigint;
alter table t3 change x x bigint after sys_trx_start;
call check_vtmd('t3_vtmd');
@start > 0 and @start < @inf
1
A_start B_end name C_archive_name
1 0 t3 t3_
1 0 t3 t3_
1 1 t3 NULL
set versioning_hide= auto;
call show_tables();
Tables_in_test
t2
t2_vtmd
t3
t3_vtmd
table_name table_schema
t2 test
t2_vtmd test
t3 test
t3_vtmd test
set versioning_hide= implicit;
call show_tables();
Tables_in_test
t2
t2_vtmd
t3
t3_vtmd
table_name table_schema
t2 test
t2_vtmd test
t3 test
t3_vtmd test
set versioning_hide= full;
call show_tables();
Tables_in_test
t2
t2_vtmd
t3
t3_vtmd
table_name table_schema
t2 test
t2_vtmd test
t3 test
t3_vtmd test
set versioning_hide= never;
call show_tables();
Tables_in_test
t0_TIMESTAMP_SUFFIX
t0_TIMESTAMP_SUFFIX
t0_TIMESTAMP_SUFFIX
t0_TIMESTAMP_SUFFIX
t2
t2_vtmd
t3
t3_TIMESTAMP_SUFFIX
t3_TIMESTAMP_SUFFIX
t3_vtmd
table_name table_schema
t0_TIMESTAMP_SUFFIX test
t0_TIMESTAMP_SUFFIX test
t0_TIMESTAMP_SUFFIX test
t0_TIMESTAMP_SUFFIX test
t1_TIMESTAMP_SUFFIX db1
t2 test
t2_vtmd test
t3 test
t3_TIMESTAMP_SUFFIX test
t3_TIMESTAMP_SUFFIX test
t3_vtmd test
set versioning_hide= auto;
create or replace table u0_vtmd (x int) with system versioning;
show tables;
Tables_in_test
t2
t2_vtmd
t3
t3_vtmd
u0_vtmd
u0_vtmd_vtmd
Warnings:
Warning 4122 Table `test.u0_vtmd` is not a VTMD table
set versioning_alter_history= survive;
create or replace table t (x int) with system versioning;
select * from t for system_time all;
x sys_trx_start sys_trx_end
drop database db0;
drop database db1;
drop database test;
create database test;

229
mysql-test/suite/versioning/r/vtmd_show.result
View File

@ -1,229 +0,0 @@
create or replace procedure drop_archives (in vtmd_name varchar(64))
begin
declare archive_name varchar(64);
declare cur_done bool default false;
declare cur cursor for
select cur_tmp.archive_name from cur_tmp;
declare continue handler for not found set cur_done = true;
set @tmp= concat('
create or replace temporary table
cur_tmp as
select vtmd.archive_name from ', vtmd_name, '
for system_time all as vtmd
where vtmd.archive_name is not null
group by vtmd.archive_name');
prepare stmt from @tmp; execute stmt; drop prepare stmt;
open cur;
fetch_loop: loop
fetch cur into archive_name;
if cur_done then
leave fetch_loop;
end if;
set @tmp= concat('drop table ', archive_name);
prepare stmt from @tmp; execute stmt; drop prepare stmt;
end loop;
drop table cur_tmp;
end~~
create procedure test_01(in engine varchar(64))
begin
set @tmp = concat('create table t (a int) with system versioning engine ', engine);
prepare stmt from @tmp; execute stmt; drop prepare stmt;
set @tm1 = now(6);
alter table t add column b int;
set @tm2 = now(6);
alter table t add column c int;
show create table t for system_time as of timestamp @tm1;
show create table t for system_time as of timestamp @tm2;
show create table t for system_time as of now;
show create table t for system_time as of timestamp now(6);
show create table t;
set @tm3 = now(6);
rename table t to tt;
show create table tt for system_time as of timestamp @tm3;
set @tm4 = now(6);
alter table tt add column d int;
show create table tt for system_time as of timestamp @tm3;
show create table tt for system_time as of timestamp @tm4;
show create table tt;
drop table tt;
call drop_archives('tt_vtmd');
drop table tt_vtmd;
end~~
create table t (a int) with system versioning;
show create table t for system_time as of now;
ERROR HY000: VTMD error: Table 'test.t_vtmd' doesn't exist
set versioning_alter_history=survive;
create or replace table t (a int) with system versioning;
show create table t for system_time between timestamp @tm1 and timestamp @tm1;
ERROR HY000: SYSTEM_TIME range selector is prohibited
show create table t for system_time from timestamp @tm1 to timestamp @tm1;
ERROR HY000: SYSTEM_TIME range selector is prohibited
show create table t for system_time as of timestamp '01-01-1990';
ERROR HY000: VTMD error: Table 'test.t' doesn't exist
show create table t for system_time as of timestamp '01-01-2020';
ERROR HY000: VTMD error: Table 'test.t' doesn't exist
drop table t;
call drop_archives('t_vtmd');
drop table t_vtmd;
call test_01('myisam');
Table Create Table
t CREATE TABLE `t` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` timestamp(6) GENERATED ALWAYS AS ROW START,
`sys_trx_end` timestamp(6) GENERATED ALWAYS AS ROW END,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
t CREATE TABLE `t` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` timestamp(6) GENERATED ALWAYS AS ROW START,
`sys_trx_end` timestamp(6) GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
t CREATE TABLE `t` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` timestamp(6) GENERATED ALWAYS AS ROW START,
`sys_trx_end` timestamp(6) GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
t CREATE TABLE `t` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` timestamp(6) GENERATED ALWAYS AS ROW START,
`sys_trx_end` timestamp(6) GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
t CREATE TABLE `t` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` timestamp(6) GENERATED ALWAYS AS ROW START,
`sys_trx_end` timestamp(6) GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
tt CREATE TABLE `tt` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` timestamp(6) GENERATED ALWAYS AS ROW START,
`sys_trx_end` timestamp(6) GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
tt CREATE TABLE `tt` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` timestamp(6) GENERATED ALWAYS AS ROW START,
`sys_trx_end` timestamp(6) GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
tt CREATE TABLE `tt` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` timestamp(6) GENERATED ALWAYS AS ROW START,
`sys_trx_end` timestamp(6) GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
tt CREATE TABLE `tt` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` timestamp(6) GENERATED ALWAYS AS ROW START,
`sys_trx_end` timestamp(6) GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
`d` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
call test_01('innodb');
Table Create Table
t CREATE TABLE `t` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` bigint(20) unsigned GENERATED ALWAYS AS ROW START,
`sys_trx_end` bigint(20) unsigned GENERATED ALWAYS AS ROW END,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
t CREATE TABLE `t` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` bigint(20) unsigned GENERATED ALWAYS AS ROW START,
`sys_trx_end` bigint(20) unsigned GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
t CREATE TABLE `t` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` bigint(20) unsigned GENERATED ALWAYS AS ROW START,
`sys_trx_end` bigint(20) unsigned GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
t CREATE TABLE `t` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` bigint(20) unsigned GENERATED ALWAYS AS ROW START,
`sys_trx_end` bigint(20) unsigned GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
t CREATE TABLE `t` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` bigint(20) unsigned GENERATED ALWAYS AS ROW START,
`sys_trx_end` bigint(20) unsigned GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
tt CREATE TABLE `tt` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` bigint(20) unsigned GENERATED ALWAYS AS ROW START,
`sys_trx_end` bigint(20) unsigned GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
tt CREATE TABLE `tt` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` bigint(20) unsigned GENERATED ALWAYS AS ROW START,
`sys_trx_end` bigint(20) unsigned GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
tt CREATE TABLE `tt` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` bigint(20) unsigned GENERATED ALWAYS AS ROW START,
`sys_trx_end` bigint(20) unsigned GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
Table Create Table
tt CREATE TABLE `tt` (
`a` int(11) DEFAULT NULL,
`sys_trx_start` bigint(20) unsigned GENERATED ALWAYS AS ROW START,
`sys_trx_end` bigint(20) unsigned GENERATED ALWAYS AS ROW END,
`b` int(11) DEFAULT NULL,
`c` int(11) DEFAULT NULL,
`d` int(11) DEFAULT NULL,
PERIOD FOR SYSTEM_TIME (`sys_trx_start`, `sys_trx_end`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 WITH SYSTEM VERSIONING
drop procedure test_01;
drop procedure drop_archives;

105
mysql-test/suite/versioning/t/ddl.test
View File

@ -1,105 +0,0 @@
-- source suite/versioning/common.inc
delimiter ~~;
create function get_archive_table_name()
returns varchar(255)
begin
return (select archive_name from t_vtmd for system_time all where archive_name is not NULL
order by start desc limit 1);
end~~
create procedure drop_last_archive()
begin
call concat_exec2('drop table ', get_archive_table_name());
end~~
delimiter ;~~
set versioning_alter_history= survive;
create or replace table t (a int) with system versioning;
insert into t values (1);
update t set a=2 where a=1;
select sys_trx_start from t where a=2 into @tm;
alter table t add column b int;
select * from t;
call concat_exec3('select * from ', get_archive_table_name(), ' for system_time all');
call concat_exec3('select @tm=sys_trx_start from ', get_archive_table_name(), ' for system_time all where a=2');
select @tm<sys_trx_start from t where a=2;
select sys_trx_start from t where a=2 into @tm;
call concat_exec3('select @tm=sys_trx_end from ', get_archive_table_name(), ' for system_time all where a=2');
call drop_last_archive();
set versioning_alter_history= keep;
drop table t_vtmd;
drop table t;
set versioning_alter_history= survive;
# same for INNODB ALGORITHM=COPY
create or replace table t (a int) with system versioning;
insert into t values (1);
update t set a=2 where a=1;
select sys_trx_start from t where a=2 into @tm;
alter table t add column b int;
select * from t;
call concat_exec3('select * from ', get_archive_table_name(), ' for system_time all');
call concat_exec3('select @tm=sys_trx_start from ', get_archive_table_name(), ' for system_time all where a=2');
select @tm<sys_trx_start from t where a=2;
select sys_trx_start from t where a=2 into @tm;
call concat_exec3('select @tm=sys_trx_end from ', get_archive_table_name(), ' for system_time all where a=2');
call drop_last_archive();
set versioning_alter_history= keep;
drop table t_vtmd;
drop table t;
set versioning_alter_history= survive;
# same for INNODB default ALGORITHM
create or replace table t (a int) with system versioning engine innodb;
insert into t values (1);
update t set a=2 where a=1;
select sys_trx_start from t where a=2 into @tm;
alter table t add column b int;
select * from t;
call concat_exec3('select * from ', get_archive_table_name(), ' for system_time all');
call concat_exec3('select @tm=sys_trx_start from ', get_archive_table_name(), ' for system_time all where a=2');
select @tm<sys_trx_start from t where a=2;
select sys_trx_start from t where a=2 into @tm;
call concat_exec3('select @tm=sys_trx_end from ', get_archive_table_name(), ' for system_time all where a=2');
call drop_last_archive();
set versioning_alter_history= keep;
drop table t_vtmd;
drop table t;
set versioning_alter_history= survive;
# no DDL for INNODB explicit ALGORITHM=INPLACE
create or replace table t (a int) with system versioning engine innodb;
insert into t values (1);
update t set a=2 where a=1;
alter table t add column b int, algorithm=inplace;
set versioning_alter_history = keep;
drop function get_archive_table_name;
drop procedure drop_last_archive;
select * from mysql.vtmd_template;
show create table mysql.vtmd_template;
call verify_vtq;
drop table t;
drop table t_vtmd;
-- source suite/versioning/common_finish.inc

206
mysql-test/suite/versioning/t/vtmd.test
View File

@ -1,206 +0,0 @@
-- source include/have_innodb.inc
set default_storage_engine=innodb;
delimiter ~~;
create or replace procedure drop_archives (in vtmd_name varchar(64))
begin
declare archive_name varchar(64);
declare cur_done bool default false;
declare cur cursor for
select cur_tmp.archive_name from cur_tmp;
declare continue handler for not found set cur_done = true;
set @tmp= concat('
create or replace temporary table
cur_tmp as
select vtmd.archive_name from ', vtmd_name, '
for system_time all as vtmd
where vtmd.archive_name is not null
group by vtmd.archive_name');
prepare stmt from @tmp; execute stmt; drop prepare stmt;
open cur;
fetch_loop: loop
fetch cur into archive_name;
if cur_done then
leave fetch_loop;
end if;
set @tmp= concat('drop table ', archive_name);
prepare stmt from @tmp; execute stmt; drop prepare stmt;
end loop;
drop table cur_tmp;
end~~
delimiter ;~~
delimiter ~~;
create or replace procedure check_vtmd (in vtmd_name varchar(64))
begin
set @tmp= concat('
create or replace temporary table
tmp_vtmd with system versioning as
select * from ', vtmd_name, '
for system_time all as vtmd');
prepare stmt from @tmp; execute stmt; drop prepare stmt;
set @inf= 0xFFFFFFFFFFFFFFFF + 0;
set @start= null;
select start from tmp_vtmd for system_time all order by start limit 1 into @start;
select @start > 0 and @start < @inf;
select
start >= @start as A_start,
(@start:= end) and end = @inf as B_end,
name,
substr(archive_name, 1, instr(archive_name, '_')) as C_archive_name
from tmp_vtmd for system_time all;
drop table tmp_vtmd;
end~~
delimiter ;~~
delimiter ~~;
create or replace procedure show_tables()
begin
show tables;
select table_name, table_schema from information_schema.tables
where table_schema not in ('mysql', 'performance_schema', 'information_schema', 'mtr')
order by table_name;
end~~
delimiter ;~~
# create
set versioning_alter_history= keep;
create table t0 (z int) with system versioning;
show tables;
set versioning_alter_history= survive;
create or replace table t0 (y int) with system versioning;
show tables;
show create table t0_vtmd;
call check_vtmd('t0_vtmd');
set versioning_alter_history= keep;
drop table t0;
set versioning_alter_history= survive;
--error ER_VERS_VTMD_ERROR
create table t0 (x int) with system versioning;
drop table t0_vtmd;
create table t0 (y int) with system versioning;
create or replace table t0 (x int) with system versioning;
# alter
insert into t0 values (1);
set @t0= now(6);
alter table t0 add column (y int);
select * from t0 for system_time as of @t0;
select * from t0;
call check_vtmd('t0_vtmd');
call drop_archives('t0_vtmd');
drop table t0_vtmd;
alter table t0 drop column y;
call check_vtmd('t0_vtmd');
call drop_archives('t0_vtmd');
set versioning_alter_history= keep;
drop tables t0, t0_vtmd;
set versioning_alter_history= survive;
# rename
set versioning_alter_history= keep;
create or replace table x0 (x int) with system versioning;
set versioning_alter_history= survive;
rename table x0 to d0;
show tables;
set versioning_alter_history= keep;
drop table d0;
set versioning_alter_history= survive;
create or replace table x0 (x int) with system versioning;
rename table x0 to d0;
show tables;
call check_vtmd('d0_vtmd');
set versioning_alter_history= keep;
drop table d0;
set versioning_alter_history= survive;
create or replace table x0 (x int) with system versioning;
--error ER_VERS_VTMD_ERROR
rename table x0 to d0;
show tables;
drop table x0_vtmd;
rename table x0 to d0;
show tables;
rename table d0 to duck;
rename table duck to bay;
rename table bay to sheer;
rename table sheer to t0;
call check_vtmd('t0_vtmd');
alter table t0 add column (y int);
call check_vtmd('t0_vtmd');
# rename to different schema
alter table t0 add column (z int);
alter table t0 drop column y;
alter table t0 drop column z;
create database db0;
rename table t0 to db0.t0;
show tables;
use db0;
show tables;
call test.check_vtmd('db0.t0_vtmd');
create database db1;
rename table t0 to db1.other_name;
show tables;
use db1;
show tables;
call test.check_vtmd('db1.other_name_vtmd');
# alter rename
alter table other_name rename to t1;
call test.check_vtmd('db1.t1_vtmd');
# alter rename and modify to different schema
alter table t1 rename to test.t2, add column (y int);
use test;
show tables;
call check_vtmd('t2_vtmd');
create or replace table t3 (x int) with system versioning;
alter table t3 change x x bigint;
alter table t3 change x x bigint after sys_trx_start;
call check_vtmd('t3_vtmd');
# hide archive tables
set versioning_hide= auto;
call show_tables();
set versioning_hide= implicit;
call show_tables();
set versioning_hide= full;
call show_tables();
set versioning_hide= never;
--replace_regex /\d{8}_\d{6}_\d{6}/TIMESTAMP_SUFFIX/
call show_tables();
# wrong VTMD handling
set versioning_hide= auto;
create or replace table u0_vtmd (x int) with system versioning;
show tables;
set versioning_alter_history= survive;
create or replace table t (x int) with system versioning;
select * from t for system_time all;
drop database db0;
drop database db1;
drop database test;
create database test;

92
mysql-test/suite/versioning/t/vtmd_show.test
View File

@ -1,92 +0,0 @@
-- source include/have_innodb.inc
delimiter ~~;
create or replace procedure drop_archives (in vtmd_name varchar(64))
begin
declare archive_name varchar(64);
declare cur_done bool default false;
declare cur cursor for
select cur_tmp.archive_name from cur_tmp;
declare continue handler for not found set cur_done = true;
set @tmp= concat('
create or replace temporary table
cur_tmp as
select vtmd.archive_name from ', vtmd_name, '
for system_time all as vtmd
where vtmd.archive_name is not null
group by vtmd.archive_name');
prepare stmt from @tmp; execute stmt; drop prepare stmt;
open cur;
fetch_loop: loop
fetch cur into archive_name;
if cur_done then
leave fetch_loop;
end if;
set @tmp= concat('drop table ', archive_name);
prepare stmt from @tmp; execute stmt; drop prepare stmt;
end loop;
drop table cur_tmp;
end~~
delimiter ;~~
delimiter ~~;
create procedure test_01(in engine varchar(64))
begin
set @tmp = concat('create table t (a int) with system versioning engine ', engine);
prepare stmt from @tmp; execute stmt; drop prepare stmt;
set @tm1 = now(6);
alter table t add column b int;
set @tm2 = now(6);
alter table t add column c int;
show create table t for system_time as of timestamp @tm1;
show create table t for system_time as of timestamp @tm2;
show create table t for system_time as of now;
show create table t for system_time as of timestamp now(6);
show create table t;
set @tm3 = now(6);
rename table t to tt;
show create table tt for system_time as of timestamp @tm3;
set @tm4 = now(6);
alter table tt add column d int;
show create table tt for system_time as of timestamp @tm3;
show create table tt for system_time as of timestamp @tm4;
show create table tt;
drop table tt;
call drop_archives('tt_vtmd');
drop table tt_vtmd;
end~~
delimiter ;~~
create table t (a int) with system versioning;
--error ER_VERS_VTMD_ERROR
show create table t for system_time as of now;
set versioning_alter_history=survive;
create or replace table t (a int) with system versioning;
--error ER_VERS_RANGE_PROHIBITED
show create table t for system_time between timestamp @tm1 and timestamp @tm1;
--error ER_VERS_RANGE_PROHIBITED
show create table t for system_time from timestamp @tm1 to timestamp @tm1;
--error ER_VERS_VTMD_ERROR
show create table t for system_time as of timestamp '01-01-1990';
--error ER_VERS_VTMD_ERROR
show create table t for system_time as of timestamp '01-01-2020';
drop table t;
call drop_archives('t_vtmd');
drop table t_vtmd;
call test_01('myisam');
call test_01('innodb');
drop procedure test_01;
drop procedure drop_archives;

1
sql/CMakeLists.txt
View File

@ -153,7 +153,6 @@ SET (SQL_SOURCE
${CMAKE_CURRENT_BINARY_DIR}/sql_builtin.cc ${CMAKE_CURRENT_BINARY_DIR}/sql_builtin.cc
${GEN_SOURCES} ${GEN_SOURCES}
${MYSYS_LIBWRAP_SOURCE} ${MYSYS_LIBWRAP_SOURCE}
vtmd.cc
) )
IF (CMAKE_SYSTEM_NAME MATCHES "Linux" OR IF (CMAKE_SYSTEM_NAME MATCHES "Linux" OR

6
sql/handler.h
View File

@ -414,7 +414,6 @@ enum enum_alter_inplace_result {
#define HA_CREATE_TMP_ALTER 8U #define HA_CREATE_TMP_ALTER 8U
#define HA_LEX_CREATE_SEQUENCE 16U #define HA_LEX_CREATE_SEQUENCE 16U
#define HA_VERSIONED_TABLE 32U #define HA_VERSIONED_TABLE 32U
#define HA_VTMD 64U
#define HA_MAX_REC_LENGTH 65535 #define HA_MAX_REC_LENGTH 65535
@ -2076,11 +2075,6 @@ struct Table_scope_and_contents_source_st
{ {
return options & HA_VERSIONED_TABLE; return options & HA_VERSIONED_TABLE;
} }
bool vtmd() const
{
return options & HA_VTMD;
}
}; };

4
sql/mysqld.h
View File

@ -202,9 +202,7 @@ struct vers_asof_timestamp_t
enum vers_alter_history_enum enum vers_alter_history_enum
{ {
VERS_ALTER_HISTORY_ERROR= 0, VERS_ALTER_HISTORY_ERROR= 0,
VERS_ALTER_HISTORY_KEEP, VERS_ALTER_HISTORY_KEEP
VERS_ALTER_HISTORY_SURVIVE,
VERS_ALTER_HISTORY_DROP
}; };
/* System Versioning end */ /* System Versioning end */

24
sql/partition_info.cc
View File

@ -2647,30 +2647,6 @@ bool partition_info::has_same_partitioning(partition_info *new_part_info)
} }
bool partition_info::vers_trx_id_to_ts(THD* thd, Field* in_trx_id, Field_timestamp& out_ts)
{
DBUG_ASSERT(table);
handlerton *hton= plugin_hton(table->s->db_plugin);
DBUG_ASSERT(hton);
ulonglong trx_id= in_trx_id->val_int();
TR_table trt(thd);
bool found= trt.query(trx_id);
if (!found)
{
push_warning_printf(thd,
Sql_condition::WARN_LEVEL_WARN,
WARN_VERS_TRX_MISSING,
ER_THD(thd, WARN_VERS_TRX_MISSING),
trx_id);
return true;
}
MYSQL_TIME ts;
trt[TR_table::FLD_COMMIT_TS]->get_date(&ts, 0);
out_ts.store_time_dec(&ts, 6);
return false;
}
void partition_info::print_debug(const char *str, uint *value) void partition_info::print_debug(const char *str, uint *value)
{ {
DBUG_ENTER("print_debug"); DBUG_ENTER("print_debug");

1
sql/partition_info.h
View File

@ -424,7 +424,6 @@ public:
} }
return NULL; return NULL;
} }
bool vers_trx_id_to_ts(THD *thd, Field *in_trx_id, Field_timestamp &out_ts);
}; };
uint32 get_next_partition_id_range(struct st_partition_iter* part_iter); uint32 get_next_partition_id_range(struct st_partition_iter* part_iter);

12
sql/share/errmsg-utf8.txt
View File

@ -7844,8 +7844,8 @@ WARN_VERS_PARAMETERS
ER_VERS_DROP_PARTITION_INTERVAL ER_VERS_DROP_PARTITION_INTERVAL
eng "Can only drop oldest partitions when rotating by INTERVAL" eng "Can only drop oldest partitions when rotating by INTERVAL"
WARN_VERS_TRX_MISSING ER_UNUSED_25
eng "VTQ missing transaction ID %lu" eng "You should never see it"
WARN_VERS_PART_NON_HISTORICAL WARN_VERS_PART_NON_HISTORICAL
eng "Partition %`s contains non-historical data" eng "Partition %`s contains non-historical data"
@ -7859,8 +7859,8 @@ ER_VERS_ALTER_ENGINE_PROHIBITED
ER_VERS_RANGE_PROHIBITED ER_VERS_RANGE_PROHIBITED
eng "SYSTEM_TIME range selector is prohibited" eng "SYSTEM_TIME range selector is prohibited"
ER_VERS_VTMD_ERROR ER_UNUSED_26
eng "VTMD error: %s" eng "You should never see it"
ER_VERS_TABLE_MUST_HAVE_COLUMNS ER_VERS_TABLE_MUST_HAVE_COLUMNS
eng "Table %`s must have at least one versioned column" eng "Table %`s must have at least one versioned column"
@ -7889,8 +7889,8 @@ ER_VERS_ALTER_SYSTEM_FIELD
ER_DROP_VERSIONING_SYSTEM_TIME_PARTITION ER_DROP_VERSIONING_SYSTEM_TIME_PARTITION
eng "Can not DROP SYSTEM VERSIONING for table %`s partitioned BY SYSTEM_TIME" eng "Can not DROP SYSTEM VERSIONING for table %`s partitioned BY SYSTEM_TIME"
ER_NOT_LOG_TABLE ER_UNUSED_27
eng "Table %`s.%`s is not a log table" eng "You should never see it"
ER_VERS_TRT_IS_DISABLED ER_VERS_TRT_IS_DISABLED
eng "Transaction registry is disabled" eng "Transaction registry is disabled"

5
sql/sp_cache.cc
View File

@ -238,11 +238,6 @@ void sp_cache_flush_obsolete(sp_cache **cp, sp_head **sp)
} }
} }
void sp_cache_flush(sp_cache *cp, sp_head *sp)
{
cp->remove(sp);
}
/** /**
Return the current global version of the cache. Return the current global version of the cache.
*/ */

1
sql/sp_cache.h
View File

@ -60,7 +60,6 @@ void sp_cache_insert(sp_cache **cp, sp_head *sp);
sp_head *sp_cache_lookup(sp_cache **cp, const Database_qualified_name *name); sp_head *sp_cache_lookup(sp_cache **cp, const Database_qualified_name *name);
void sp_cache_invalidate(); void sp_cache_invalidate();
void sp_cache_flush_obsolete(sp_cache **cp, sp_head **sp); void sp_cache_flush_obsolete(sp_cache **cp, sp_head **sp);
void sp_cache_flush(sp_cache *cp, sp_head *sp);
ulong sp_cache_version(); ulong sp_cache_version();
void sp_cache_enforce_limit(sp_cache *cp, ulong upper_limit_for_elements); void sp_cache_enforce_limit(sp_cache *cp, ulong upper_limit_for_elements);

12
sql/sql_alter.h
View File

@ -41,18 +41,6 @@ public:
ALTER_COLUMN_ORDER); ALTER_COLUMN_ORDER);
} }
bool partition_modifying() const
{
return partition_flags & (
ALTER_PARTITION_DROP |
ALTER_PARTITION_COALESCE |
ALTER_PARTITION_REORGANIZE |
ALTER_PARTITION_REMOVE |
ALTER_PARTITION_TABLE_REORG |
ALTER_PARTITION_EXCHANGE |
ALTER_PARTITION_TRUNCATE);
}
/** /**
The different values of the ALGORITHM clause. The different values of the ALGORITHM clause.
Describes which algorithm to use when altering the table. Describes which algorithm to use when altering the table.

23
sql/sql_base.cc
View File

@ -8821,32 +8821,11 @@ open_log_table(THD *thd, TABLE_LIST *one_table, Open_tables_backup *backup)
if ((table= open_ltable(thd, one_table, one_table->lock_type, flags))) if ((table= open_ltable(thd, one_table, one_table->lock_type, flags)))
{ {
if (table->s->table_category == TABLE_CATEGORY_LOG) DBUG_ASSERT(table->s->table_category == TABLE_CATEGORY_LOG);
{
/* Make sure all columns get assigned to a default value */ /* Make sure all columns get assigned to a default value */
table->use_all_columns(); table->use_all_columns();
DBUG_ASSERT(table->s->no_replicate); DBUG_ASSERT(table->s->no_replicate);
} }
else
{
my_error(ER_NOT_LOG_TABLE, MYF(0), table->s->db.str, table->s->table_name.str);
int error= 0;
if (table->current_lock != F_UNLCK)
{
table->current_lock= F_UNLCK;
error= table->file->ha_external_lock(thd, F_UNLCK);
}
if (error)
table->file->print_error(error, MYF(0));
else
{
tc_release_table(table);
thd->reset_open_tables_state(thd);
thd->restore_backup_open_tables_state(backup);
table= NULL;
}
}
}
else else
thd->restore_backup_open_tables_state(backup); thd->restore_backup_open_tables_state(backup);

2
sql/sql_error.h
View File

@ -1174,7 +1174,7 @@ public:
void copy_non_errors_from_wi(THD *thd, const Warning_info *src_wi); void copy_non_errors_from_wi(THD *thd, const Warning_info *src_wi);
protected: private:
Warning_info *get_warning_info() { return m_wi_stack.front(); } Warning_info *get_warning_info() { return m_wi_stack.front(); }
const Warning_info *get_warning_info() const { return m_wi_stack.front(); } const Warning_info *get_warning_info() const { return m_wi_stack.front(); }

14
sql/sql_lex.cc
View File

@ -7446,20 +7446,6 @@ int set_statement_var_if_exists(THD *thd, const char *var_name,
} }
Query_tables_backup::Query_tables_backup(THD* _thd) :
thd(_thd)
{
thd->lex->reset_n_backup_query_tables_list(&backup);
thd->lex->sql_command= backup.sql_command;
}
Query_tables_backup::~Query_tables_backup()
{
thd->lex->restore_backup_query_tables_list(&backup);
}
bool LEX::sp_add_cfetch(THD *thd, const LEX_CSTRING *name) bool LEX::sp_add_cfetch(THD *thd, const LEX_CSTRING *name)
{ {
uint offset; uint offset;

12
sql/sql_lex.h
View File

@ -1983,18 +1983,6 @@ private:
}; };
class Query_tables_backup
{
THD *thd;
Query_tables_list backup;
public:
Query_tables_backup(THD *_thd);
~Query_tables_backup();
const Query_tables_list& get() const { return backup; }
};
/* /*
st_parsing_options contains the flags for constructions that are st_parsing_options contains the flags for constructions that are
allowed in the current statement. allowed in the current statement.

21
sql/sql_parse.cc
View File

@ -111,7 +111,6 @@
#include "wsrep_mysqld.h" #include "wsrep_mysqld.h"
#include "wsrep_thd.h" #include "wsrep_thd.h"
#include "vtmd.h"
static void wsrep_mysql_parse(THD *thd, char *rawbuf, uint length, static void wsrep_mysql_parse(THD *thd, char *rawbuf, uint length,
Parser_state *parser_state, Parser_state *parser_state,
@ -3182,11 +3181,6 @@ bool Sql_cmd_call::execute(THD *thd)
if (do_execute_sp(thd, sp)) if (do_execute_sp(thd, sp))
return true; return true;
if (sp->sp_cache_version() == 0)
{
sp_cache_flush(thd->sp_proc_cache, sp);
}
/* /*
Disable slow log for the above call(), if calls are disabled. Disable slow log for the above call(), if calls are disabled.
Instead we will log the executed statements to the slow log. Instead we will log the executed statements to the slow log.
@ -6459,21 +6453,6 @@ static bool execute_sqlcom_select(THD *thd, TABLE_LIST *all_tables)
(ulonglong) thd->variables.select_limit); (ulonglong) thd->variables.select_limit);
} }
if (thd->variables.vers_alter_history == VERS_ALTER_HISTORY_SURVIVE)
{
for (TABLE_LIST *table= all_tables; table; table= table->next_local)
{
if (table->vers_conditions)
{
VTMD_exists vtmd(*table);
if (vtmd.check_exists(thd))
return 1;
if (vtmd.exists && vtmd.setup_select(thd))
return 1;
}
}
}
if (!(res= open_and_lock_tables(thd, all_tables, TRUE, 0))) if (!(res= open_and_lock_tables(thd, all_tables, TRUE, 0)))
{ {
if (lex->describe) if (lex->describe)

11
sql/sql_rename.cc
View File

@ -30,7 +30,6 @@
#include "sql_base.h" // tdc_remove_table, lock_table_names, #include "sql_base.h" // tdc_remove_table, lock_table_names,
#include "sql_handler.h" // mysql_ha_rm_tables #include "sql_handler.h" // mysql_ha_rm_tables
#include "sql_statistics.h" #include "sql_statistics.h"
#include "vtmd.h"
static TABLE_LIST *rename_tables(THD *thd, TABLE_LIST *table_list, static TABLE_LIST *rename_tables(THD *thd, TABLE_LIST *table_list,
bool skip_error); bool skip_error);
@ -298,22 +297,12 @@ do_rename(THD *thd, TABLE_LIST *ren_table, const LEX_CSTRING *new_db,
(void) rename_table_in_stat_tables(thd, &ren_table->db, (void) rename_table_in_stat_tables(thd, &ren_table->db,
&ren_table->table_name, &ren_table->table_name,
new_db, &new_alias); new_db, &new_alias);
VTMD_rename vtmd(*ren_table);
if (thd->variables.vers_alter_history == VERS_ALTER_HISTORY_SURVIVE)
{
rc= vtmd.try_rename(thd, new_db->str, new_alias.str);
if (rc)
goto revert_table_name;
}
if ((rc= Table_triggers_list::change_table_name(thd, &ren_table->db, if ((rc= Table_triggers_list::change_table_name(thd, &ren_table->db,
&old_alias, &old_alias,
&ren_table->table_name, &ren_table->table_name,
new_db, new_db,
&new_alias))) &new_alias)))
{ {
if (thd->variables.vers_alter_history == VERS_ALTER_HISTORY_SURVIVE)
vtmd.revert_rename(thd, new_db->str);
revert_table_name:
/* /*
We've succeeded in renaming table's .frm and in updating We've succeeded in renaming table's .frm and in updating
corresponding handler data, but have failed to update table's corresponding handler data, but have failed to update table's

81
sql/sql_show.cc
View File

@ -62,7 +62,6 @@
#ifdef WITH_PARTITION_STORAGE_ENGINE #ifdef WITH_PARTITION_STORAGE_ENGINE
#include "ha_partition.h" #include "ha_partition.h"
#endif #endif
#include "vtmd.h"
#include "transaction.h" #include "transaction.h"
enum enum_i_s_events_fields enum enum_i_s_events_fields
@ -1369,14 +1368,6 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list)
MDL_savepoint mdl_savepoint= thd->mdl_context.mdl_savepoint(); MDL_savepoint mdl_savepoint= thd->mdl_context.mdl_savepoint();
TABLE_LIST archive; TABLE_LIST archive;
bool versioned= table_list->vers_conditions;
if (versioned)
{
DBUG_ASSERT(table_list->vers_conditions == SYSTEM_TIME_AS_OF);
VTMD_table vtmd(*table_list);
if (vtmd.setup_select(thd))
goto exit;
}
if (mysqld_show_create_get_fields(thd, table_list, &field_list, &buffer)) if (mysqld_show_create_get_fields(thd, table_list, &field_list, &buffer))
goto exit; goto exit;
@ -1418,13 +1409,6 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list)
my_eof(thd); my_eof(thd);
exit: exit:
if (versioned)
{
/* If commit fails, we should be able to reset the OK status. */
thd->get_stmt_da()->set_overwrite_status(true);
trans_commit_stmt(thd);
thd->get_stmt_da()->set_overwrite_status(false);
}
close_thread_tables(thd); close_thread_tables(thd);
/* Release any metadata locks taken during SHOW CREATE. */ /* Release any metadata locks taken during SHOW CREATE. */
thd->mdl_context.rollback_to_savepoint(mdl_savepoint); thd->mdl_context.rollback_to_savepoint(mdl_savepoint);
@ -2150,7 +2134,7 @@ int show_create_table(THD *thd, TABLE_LIST *table_list, String *packet,
} }
else else
{ {
if (lower_case_table_names == 2 || table_list->vers_force_alias) if (lower_case_table_names == 2)
{ {
alias.str= table->alias.c_ptr(); alias.str= table->alias.c_ptr();
alias.length= table->alias.length(); alias.length= table->alias.length();
@ -4380,7 +4364,7 @@ int schema_tables_add(THD *thd, Dynamic_array<LEX_CSTRING*> *files,
@retval 2 Not fatal error; Safe to ignore this file list @retval 2 Not fatal error; Safe to ignore this file list
*/ */
int static int
make_table_name_list(THD *thd, Dynamic_array<LEX_CSTRING*> *table_names, make_table_name_list(THD *thd, Dynamic_array<LEX_CSTRING*> *table_names,
LEX *lex, LOOKUP_FIELD_VALUES *lookup_field_vals, LEX *lex, LOOKUP_FIELD_VALUES *lookup_field_vals,
LEX_CSTRING *db_name) LEX_CSTRING *db_name)
@ -5032,60 +5016,6 @@ public:
} }
}; };
static bool get_all_archive_tables(THD *thd,
Dynamic_array<String> &all_archive_tables)
{
if (thd->variables.vers_alter_history != VERS_ALTER_HISTORY_SURVIVE)
return false;
Dynamic_array<LEX_CSTRING *> all_db;
LOOKUP_FIELD_VALUES lookup_field_values= {
{C_STRING_WITH_LEN("%")}, {NULL, 0}, true, false};
if (make_db_list(thd, &all_db, &lookup_field_values))
return true;
LEX_STRING information_schema= {C_STRING_WITH_LEN("information_schema")};
for (size_t i= 0; i < all_db.elements(); i++)
{
LEX_CSTRING db= *all_db.at(i);
if (db.length == information_schema.length &&
!memcmp(db.str, information_schema.str, db.length))
{
all_db.del(i);
break;
}
}
for (size_t i= 0; i < all_db.elements(); i++)
{
LEX_CSTRING db_name= *all_db.at(i);
Dynamic_array<String> archive_tables;
if (VTMD_table::get_archive_tables(thd, db_name.str, db_name.length,
archive_tables))
return true;
for (size_t i= 0; i < archive_tables.elements(); i++)
if (all_archive_tables.push(archive_tables.at(i)))
return true;
}
return false;
}
static bool is_archive_table(const Dynamic_array<String> &all_archive_tables,
const LEX_CSTRING candidate)
{
for (size_t i= 0; i < all_archive_tables.elements(); i++)
{
const String &archive_table= all_archive_tables.at(i);
if (candidate.length == archive_table.length() &&
!memcmp(candidate.str, archive_table.ptr(), candidate.length))
{
return true;
}
}
return false;
}
/** /**
@brief Fill I_S tables whose data are retrieved @brief Fill I_S tables whose data are retrieved
from frm files and storage engine from frm files and storage engine
@ -5127,7 +5057,6 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
#endif #endif
uint table_open_method= tables->table_open_method; uint table_open_method= tables->table_open_method;
bool can_deadlock; bool can_deadlock;
Dynamic_array<String> all_archive_tables;
MEM_ROOT tmp_mem_root; MEM_ROOT tmp_mem_root;
DBUG_ENTER("get_all_tables"); DBUG_ENTER("get_all_tables");
@ -5187,9 +5116,6 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
if (make_db_list(thd, &db_names, &plan->lookup_field_vals)) if (make_db_list(thd, &db_names, &plan->lookup_field_vals))
goto err; goto err;
if (get_all_archive_tables(thd, all_archive_tables))
goto err;
/* Use tmp_mem_root to allocate data for opened tables */ /* Use tmp_mem_root to allocate data for opened tables */
init_alloc_root(&tmp_mem_root, "get_all_tables", SHOW_ALLOC_BLOCK_SIZE, init_alloc_root(&tmp_mem_root, "get_all_tables", SHOW_ALLOC_BLOCK_SIZE,
SHOW_ALLOC_BLOCK_SIZE, MY_THREAD_SPECIFIC); SHOW_ALLOC_BLOCK_SIZE, MY_THREAD_SPECIFIC);
@ -5219,9 +5145,6 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
LEX_CSTRING *table_name= table_names.at(i); LEX_CSTRING *table_name= table_names.at(i);
DBUG_ASSERT(table_name->length <= NAME_LEN); DBUG_ASSERT(table_name->length <= NAME_LEN);
if (is_archive_table(all_archive_tables, *table_name))
continue;
#ifndef NO_EMBEDDED_ACCESS_CHECKS #ifndef NO_EMBEDDED_ACCESS_CHECKS
if (!(thd->col_access & TABLE_ACLS)) if (!(thd->col_access & TABLE_ACLS))
{ {

4
sql/sql_show.h
View File

@ -203,10 +203,6 @@ typedef struct st_lookup_field_values
bool wild_table_value; bool wild_table_value;
} LOOKUP_FIELD_VALUES; } LOOKUP_FIELD_VALUES;
int make_table_name_list(THD *thd, Dynamic_array<LEX_CSTRING *> *table_names,
LEX *lex, LOOKUP_FIELD_VALUES *lookup_field_vals,
LEX_CSTRING *db_name);
/* /*
INFORMATION_SCHEMA: Execution plan for get_all_tables() call INFORMATION_SCHEMA: Execution plan for get_all_tables() call
*/ */

217
sql/sql_table.cc
View File

@ -56,7 +56,6 @@
#include "sql_audit.h" #include "sql_audit.h"
#include "sql_sequence.h" #include "sql_sequence.h"
#include "tztime.h" #include "tztime.h"
#include "vtmd.h" // System Versioning
#ifdef __WIN__ #ifdef __WIN__
@ -2313,7 +2312,6 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
bool table_creation_was_logged= 1; bool table_creation_was_logged= 1;
LEX_CSTRING db= table->db; LEX_CSTRING db= table->db;
handlerton *table_type= 0; handlerton *table_type= 0;
VTMD_drop vtmd(*table);
DBUG_PRINT("table", ("table_l: '%s'.'%s' table: %p s: %p", DBUG_PRINT("table", ("table_l: '%s'.'%s' table: %p s: %p",
table->db.str, table->table_name.str, table->table, table->db.str, table->table_name.str, table->table,
@ -2511,26 +2509,6 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
// Remove extension for delete // Remove extension for delete
*(end= path + path_length - reg_ext_length)= '\0'; *(end= path + path_length - reg_ext_length)= '\0';
if ((thd->lex->sql_command == SQLCOM_DROP_TABLE ||
thd->lex->sql_command == SQLCOM_CREATE_TABLE) &&
thd->variables.vers_alter_history == VERS_ALTER_HISTORY_SURVIVE &&
table_type && table_type != view_pseudo_hton)
{
error= vtmd.check_exists(thd);
if (error)
goto non_tmp_err;
if (!vtmd.exists)
goto drop_table;
{
const char *name= vtmd.archive_name(thd);
LEX_CSTRING new_name= { name, strlen(name) };
error= mysql_rename_table(table_type, &table->db, &table->table_name,
&table->db, &new_name, NO_FK_CHECKS);
}
}
else
{
drop_table:
error= ha_delete_table(thd, table_type, path, &db, &table->table_name, error= ha_delete_table(thd, table_type, path, &db, &table->table_name,
!dont_log_query); !dont_log_query);
if (!error) if (!error)
@ -2553,7 +2531,6 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
DBUG_ASSERT(frm_delete_error); DBUG_ASSERT(frm_delete_error);
} }
} }
}
if (!error) if (!error)
{ {
@ -2572,26 +2549,9 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
else if (frm_delete_error && if_exists) else if (frm_delete_error && if_exists)
thd->clear_error(); thd->clear_error();
} }
non_tmp_err:
non_tmp_error|= MY_TEST(error); non_tmp_error|= MY_TEST(error);
} }
if (!error && vtmd.exists)
{
enum_sql_command sql_command= thd->lex->sql_command;
thd->lex->sql_command= SQLCOM_DROP_TABLE;
error= vtmd.update(thd);
thd->lex->sql_command= sql_command;
if (error)
{
LEX_CSTRING archive_name;
archive_name.str= vtmd.archive_name();
archive_name.length= strlen(archive_name.str);
mysql_rename_table(table_type, &table->db, &archive_name,
&table->db, &table->table_name, NO_FK_CHECKS);
}
}
if (error) if (error)
{ {
if (wrong_tables.length()) if (wrong_tables.length())
@ -5227,20 +5187,6 @@ bool mysql_create_table(THD *thd, TABLE_LIST *create_table,
} }
} }
if (create_info->versioned() &&
thd->variables.vers_alter_history == VERS_ALTER_HISTORY_SURVIVE)
{
VTMD_table vtmd(*create_table);
if (vtmd.update(thd))
{
thd->variables.vers_alter_history = VERS_ALTER_HISTORY_KEEP;
mysql_rm_table_no_locks(thd, create_table, 0, 0, 0, 0, 1, 1);
thd->variables.vers_alter_history = VERS_ALTER_HISTORY_SURVIVE;
result= 1;
goto err;
}
}
err: err:
/* In RBR we don't need to log CREATE TEMPORARY TABLE */ /* In RBR we don't need to log CREATE TEMPORARY TABLE */
if (thd->is_current_stmt_binlog_format_row() && create_info->tmp_table()) if (thd->is_current_stmt_binlog_format_row() && create_info->tmp_table())
@ -5405,59 +5351,6 @@ bool operator!=(const MYSQL_TIME &lhs, const MYSQL_TIME &rhs)
lhs.time_type != rhs.time_type; lhs.time_type != rhs.time_type;
} }
// Sets row_end=MAX for rows with row_end=now(6)
static bool vers_reset_alter_copy(THD *thd, TABLE *table)
{
const MYSQL_TIME query_start= thd->query_start_TIME();
READ_RECORD info;
int error= 0;
bool will_batch= false;
ha_rows dup_key_found= 0;
if (init_read_record(&info, thd, table, NULL, NULL, 0, 1, true))
goto err;
will_batch= !table->file->start_bulk_update();
while (!(error= info.read_record()))
{
MYSQL_TIME current;
if (table->vers_end_field()->get_date(&current, 0))
goto err_read_record;
if (current != query_start)
{
continue;
}
store_record(table, record[1]);
table->vers_end_field()->set_max();
if (will_batch)
error= table->file->ha_bulk_update_row(table->record[1], table->record[0],
&dup_key_found);
else
error= table->file->ha_update_row(table->record[1], table->record[0]);
if (error && table->file->is_fatal_error(error, HA_CHECK_ALL))
{
table->file->print_error(error, MYF(ME_FATALERROR));
goto err_read_record;
}
}
if (will_batch && (error= table->file->exec_bulk_update(&dup_key_found)))
table->file->print_error(error, MYF(ME_FATALERROR));
if (will_batch)
table->file->end_bulk_update();
err_read_record:
end_read_record(&info);
err:
if (table->file->ha_external_lock(thd, F_UNLCK))
return true;
return error ? true : false;
}
/** /**
Rename a table. Rename a table.
@ -6609,9 +6502,6 @@ static bool fill_alter_inplace_info(THD *thd,
if (table->s->frm_version < FRM_VER_TRUE_VARCHAR && varchar) if (table->s->frm_version < FRM_VER_TRUE_VARCHAR && varchar)
ha_alter_info->handler_flags|= ALTER_STORED_COLUMN_TYPE; ha_alter_info->handler_flags|= ALTER_STORED_COLUMN_TYPE;
if (thd->variables.vers_alter_history == VERS_ALTER_HISTORY_DROP)
ha_alter_info->handler_flags|= ALTER_DROP_HISTORICAL;
DBUG_PRINT("info", ("handler_flags: %llu", ha_alter_info->handler_flags)); DBUG_PRINT("info", ("handler_flags: %llu", ha_alter_info->handler_flags));
/* /*
@ -8994,23 +8884,13 @@ simple_rename_or_index_change(THD *thd, TABLE_LIST *table_list,
if (mysql_rename_table(old_db_type, &alter_ctx->db, &alter_ctx->table_name, if (mysql_rename_table(old_db_type, &alter_ctx->db, &alter_ctx->table_name,
&alter_ctx->new_db, &alter_ctx->new_alias, 0)) &alter_ctx->new_db, &alter_ctx->new_alias, 0))
error= -1; error= -1;
else else if (Table_triggers_list::change_table_name(thd,
{
VTMD_rename vtmd(*table_list);
if (thd->variables.vers_alter_history == VERS_ALTER_HISTORY_SURVIVE &&
vtmd.try_rename(thd, alter_ctx->new_db.str, alter_ctx->new_alias.str))
goto revert_table_name;
if (Table_triggers_list::change_table_name(thd,
&alter_ctx->db, &alter_ctx->db,
&alter_ctx->alias, &alter_ctx->alias,
&alter_ctx->table_name, &alter_ctx->table_name,
&alter_ctx->new_db, &alter_ctx->new_db,
&alter_ctx->new_alias)) &alter_ctx->new_alias))
{ {
if (thd->variables.vers_alter_history == VERS_ALTER_HISTORY_SURVIVE)
vtmd.revert_rename(thd, alter_ctx->new_db.str);
revert_table_name:
(void) mysql_rename_table(old_db_type, (void) mysql_rename_table(old_db_type,
&alter_ctx->new_db, &alter_ctx->new_alias, &alter_ctx->new_db, &alter_ctx->new_alias,
&alter_ctx->db, &alter_ctx->table_name, &alter_ctx->db, &alter_ctx->table_name,
@ -9018,7 +8898,6 @@ simple_rename_or_index_change(THD *thd, TABLE_LIST *table_list,
error= -1; error= -1;
} }
} }
}
if (!error) if (!error)
{ {
@ -9150,7 +9029,6 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
TABLE *table= table_list->table; TABLE *table= table_list->table;
bool versioned= table && table->versioned(); bool versioned= table && table->versioned();
bool vers_survival_mod= false;
if (versioned) if (versioned)
{ {
@ -9166,12 +9044,7 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
DBUG_RETURN(true); DBUG_RETURN(true);
} }
} }
bool vers_data_mod= alter_info->data_modifying(); if (alter_info->data_modifying() && !thd->slave_thread &&
if (thd->variables.vers_alter_history == VERS_ALTER_HISTORY_SURVIVE)
{
vers_survival_mod= alter_info->data_modifying() || alter_info->partition_modifying();
}
else if (vers_data_mod && !thd->slave_thread &&
thd->variables.vers_alter_history == VERS_ALTER_HISTORY_ERROR) thd->variables.vers_alter_history == VERS_ALTER_HISTORY_ERROR)
{ {
my_error(ER_VERS_ALTER_NOT_ALLOWED, MYF(0), my_error(ER_VERS_ALTER_NOT_ALLOWED, MYF(0),
@ -9180,26 +9053,6 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
} }
} }
if (vers_survival_mod)
{
table_list->set_lock_type(thd, TL_WRITE);
if (thd->mdl_context.upgrade_shared_lock(table_list->table->mdl_ticket,
MDL_EXCLUSIVE,
thd->variables.lock_wait_timeout))
{
DBUG_RETURN(true);
}
if (table_list->table->versioned(VERS_TRX_ID) &&
alter_info->requested_algorithm ==
Alter_info::ALTER_TABLE_ALGORITHM_DEFAULT &&
IF_PARTITIONING(!table_list->table->s->partition_info_str, 1))
{
// Changle default ALGORITHM to COPY for INNODB
alter_info->requested_algorithm= Alter_info::ALTER_TABLE_ALGORITHM_COPY;
}
}
DEBUG_SYNC(thd, "alter_opened_table"); DEBUG_SYNC(thd, "alter_opened_table");
#ifdef WITH_WSREP #ifdef WITH_WSREP
@ -9509,9 +9362,7 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
Upgrade from MDL_SHARED_UPGRADABLE to MDL_SHARED_NO_WRITE. Upgrade from MDL_SHARED_UPGRADABLE to MDL_SHARED_NO_WRITE.
Afterwards it's safe to take the table level lock. Afterwards it's safe to take the table level lock.
*/ */
if ((!vers_survival_mod && if ((thd->mdl_context.upgrade_shared_lock(mdl_ticket, MDL_SHARED_NO_WRITE,
thd->mdl_context.upgrade_shared_lock(
mdl_ticket, MDL_SHARED_NO_WRITE,
thd->variables.lock_wait_timeout)) || thd->variables.lock_wait_timeout)) ||
lock_tables(thd, table_list, alter_ctx.tables_opened, 0)) lock_tables(thd, table_list, alter_ctx.tables_opened, 0))
{ {
@ -9575,7 +9426,6 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
handlerton *new_db_type= create_info->db_type; handlerton *new_db_type= create_info->db_type;
handlerton *old_db_type= table->s->db_type(); handlerton *old_db_type= table->s->db_type();
TABLE *new_table= NULL; TABLE *new_table= NULL;
bool new_versioned= false;
ha_rows copied=0,deleted=0; ha_rows copied=0,deleted=0;
/* /*
@ -9925,7 +9775,6 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
if (!new_table) if (!new_table)
goto err_new_table_cleanup; goto err_new_table_cleanup;
new_table->s->orig_table_name= table->s->table_name.str; new_table->s->orig_table_name= table->s->table_name.str;
new_versioned= new_table->versioned();
/* /*
Note: In case of MERGE table, we do not attach children. We do not Note: In case of MERGE table, we do not attach children. We do not
copy data for MERGE tables. Only the children have data. copy data for MERGE tables. Only the children have data.
@ -9953,11 +9802,6 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
alter_info->keys_onoff, alter_info->keys_onoff,
&alter_ctx)) &alter_ctx))
{ {
if (vers_survival_mod && new_versioned && table->versioned(VERS_TIMESTAMP))
{
// Failure of this function may result in corruption of an original table.
vers_reset_alter_copy(thd, table);
}
goto err_new_table_cleanup; goto err_new_table_cleanup;
} }
} }
@ -10058,13 +9902,6 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
LEX_CSTRING backup_name; LEX_CSTRING backup_name;
backup_name.str= backup_name_buff; backup_name.str= backup_name_buff;
if (vers_survival_mod)
{
VTMD_table::archive_name(thd, alter_ctx.table_name.str, backup_name_buff,
sizeof(backup_name_buff));
backup_name.length= strlen(backup_name_buff);
}
else
backup_name.length= my_snprintf(backup_name_buff, sizeof(backup_name_buff), backup_name.length= my_snprintf(backup_name_buff, sizeof(backup_name_buff),
"%s2-%lx-%lx", tmp_file_prefix, "%s2-%lx-%lx", tmp_file_prefix,
current_pid, (long) thd->thread_id); current_pid, (long) thd->thread_id);
@ -10095,17 +9932,6 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
goto err_with_mdl; goto err_with_mdl;
} }
if (vers_survival_mod && new_versioned)
{
DBUG_ASSERT(alter_info && table_list);
VTMD_rename vtmd(*table_list);
bool rc= alter_info->flags & ALTER_RENAME ?
vtmd.try_rename(thd, alter_ctx.new_db.str, alter_ctx.new_alias.str, backup_name.str) :
vtmd.update(thd, backup_name.str);
if (rc)
goto err_after_rename;
}
// Check if we renamed the table and if so update trigger files. // Check if we renamed the table and if so update trigger files.
if (alter_ctx.is_table_renamed()) if (alter_ctx.is_table_renamed())
{ {
@ -10116,7 +9942,6 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
&alter_ctx.new_db, &alter_ctx.new_db,
&alter_ctx.new_alias)) &alter_ctx.new_alias))
{ {
err_after_rename:
// Rename succeeded, delete the new table. // Rename succeeded, delete the new table.
(void) quick_rm_table(thd, new_db_type, (void) quick_rm_table(thd, new_db_type,
&alter_ctx.new_db, &alter_ctx.new_alias, 0); &alter_ctx.new_db, &alter_ctx.new_alias, 0);
@ -10131,8 +9956,7 @@ err_after_rename:
} }
// ALTER TABLE succeeded, delete the backup of the old table. // ALTER TABLE succeeded, delete the backup of the old table.
if (!(vers_survival_mod && new_versioned) && if (quick_rm_table(thd, old_db_type, &alter_ctx.db, &backup_name, FN_IS_TMP))
quick_rm_table(thd, old_db_type, &alter_ctx.db, &backup_name, FN_IS_TMP))
{ {
/* /*
The fact that deletion of the backup failed is not critical The fact that deletion of the backup failed is not critical
@ -10322,6 +10146,7 @@ copy_data_between_tables(THD *thd, TABLE *from, TABLE *to,
bool make_versioned= !from->versioned() && to->versioned(); bool make_versioned= !from->versioned() && to->versioned();
bool make_unversioned= from->versioned() && !to->versioned(); bool make_unversioned= from->versioned() && !to->versioned();
bool keep_versioned= from->versioned() && to->versioned(); bool keep_versioned= from->versioned() && to->versioned();
bool drop_history= false; // XXX
Field *to_row_start= NULL, *to_row_end= NULL, *from_row_end= NULL; Field *to_row_start= NULL, *to_row_end= NULL, *from_row_end= NULL;
MYSQL_TIME query_start; MYSQL_TIME query_start;
DBUG_ENTER("copy_data_between_tables"); DBUG_ENTER("copy_data_between_tables");
@ -10434,18 +10259,10 @@ copy_data_between_tables(THD *thd, TABLE *from, TABLE *to,
{ {
from_row_end= from->vers_end_field(); from_row_end= from->vers_end_field();
} }
else if (keep_versioned) else if (keep_versioned && drop_history)
{
if (thd->variables.vers_alter_history == VERS_ALTER_HISTORY_SURVIVE)
{
query_start= thd->query_start_TIME();
from_row_end= from->vers_end_field();
to_row_start= to->vers_start_field();
} else if (thd->variables.vers_alter_history == VERS_ALTER_HISTORY_DROP)
{ {
from_row_end= from->vers_end_field(); from_row_end= from->vers_end_field();
} }
}
THD_STAGE_INFO(thd, stage_copy_to_tmp_table); THD_STAGE_INFO(thd, stage_copy_to_tmp_table);
/* Tell handler that we have values for all columns in the to table */ /* Tell handler that we have values for all columns in the to table */
@ -10503,11 +10320,8 @@ copy_data_between_tables(THD *thd, TABLE *from, TABLE *to,
copy_ptr->do_copy(copy_ptr); copy_ptr->do_copy(copy_ptr);
} }
if (thd->variables.vers_alter_history == VERS_ALTER_HISTORY_DROP && if (drop_history && from_row_end && !from_row_end->is_max())
from_row_end && !from_row_end->is_max())
{
continue; continue;
}
if (make_versioned) if (make_versioned)
{ {
@ -10520,17 +10334,6 @@ copy_data_between_tables(THD *thd, TABLE *from, TABLE *to,
if (!from_row_end->is_max()) if (!from_row_end->is_max())
continue; // Drop history rows. continue; // Drop history rows.
} }
else if (keep_versioned &&
thd->variables.vers_alter_history == VERS_ALTER_HISTORY_SURVIVE)
{
if (!from_row_end->is_max())
continue; // Do not copy history rows.
store_record(from, record[1]);
from->vers_end_field()->store_time(&query_start);
from->file->ha_update_row(from->record[1], from->record[0]);
to_row_start->store_time(&query_start);
}
prev_insert_id= to->file->next_insert_id; prev_insert_id= to->file->next_insert_id;
if (to->default_field) if (to->default_field)
@ -10546,11 +10349,9 @@ copy_data_between_tables(THD *thd, TABLE *from, TABLE *to,
error= 1; error= 1;
break; break;
} }
if (keep_versioned && to->versioned(VERS_TRX_ID) && if (keep_versioned && to->versioned(VERS_TRX_ID))
thd->variables.vers_alter_history != VERS_ALTER_HISTORY_SURVIVE)
{
to->vers_write= false; to->vers_write= false;
}
error= to->file->ha_write_row(to->record[0]); error= to->file->ha_write_row(to->record[0]);
to->auto_increment_field_not_null= FALSE; to->auto_increment_field_not_null= FALSE;
if (error) if (error)

10
sql/sql_yacc.yy
View File

@ -13832,21 +13832,13 @@ show_param:
Lex->set_command(SQLCOM_SHOW_CREATE_DB, $3); Lex->set_command(SQLCOM_SHOW_CREATE_DB, $3);
Lex->name= $4; Lex->name= $4;
} }
| CREATE TABLE_SYM table_ident opt_for_system_time_clause | CREATE TABLE_SYM table_ident
{ {
LEX *lex= Lex; LEX *lex= Lex;
lex->sql_command = SQLCOM_SHOW_CREATE; lex->sql_command = SQLCOM_SHOW_CREATE;
if (!lex->select_lex.add_table_to_list(thd, $3, NULL,0)) if (!lex->select_lex.add_table_to_list(thd, $3, NULL,0))
MYSQL_YYABORT; MYSQL_YYABORT;
lex->create_info.storage_media= HA_SM_DEFAULT; lex->create_info.storage_media= HA_SM_DEFAULT;
if (lex->vers_conditions.type != SYSTEM_TIME_UNSPECIFIED &&
lex->vers_conditions.type != SYSTEM_TIME_AS_OF)
{
my_yyabort_error((ER_VERS_RANGE_PROHIBITED, MYF(0)));
}
if ($4)
Lex->last_table()->vers_conditions= Lex->vers_conditions;
} }
| CREATE VIEW_SYM table_ident | CREATE VIEW_SYM table_ident
{ {

6
sql/sys_vars.cc
View File

@ -396,13 +396,11 @@ static Sys_var_vers_asof Sys_vers_asof_timestamp(
SESSION_VAR(vers_asof_timestamp.type), NO_CMD_LINE, SESSION_VAR(vers_asof_timestamp.type), NO_CMD_LINE,
Sys_var_vers_asof::asof_keywords, DEFAULT(SYSTEM_TIME_UNSPECIFIED)); Sys_var_vers_asof::asof_keywords, DEFAULT(SYSTEM_TIME_UNSPECIFIED));
static const char *vers_alter_history_keywords[]= {"ERROR", "KEEP",/* "SURVIVE", "DROP",*/ NULL}; static const char *vers_alter_history_keywords[]= {"ERROR", "KEEP", NullS};
static Sys_var_enum Sys_vers_alter_history( static Sys_var_enum Sys_vers_alter_history(
"system_versioning_alter_history", "Versioning ALTER TABLE mode. " "system_versioning_alter_history", "Versioning ALTER TABLE mode. "
"ERROR: Fail ALTER with error; " /* TODO: fail only when history non-empty */ "ERROR: Fail ALTER with error; " /* TODO: fail only when history non-empty */
"KEEP: Keep historical system rows and subject them to ALTER; " "KEEP: Keep historical system rows and subject them to ALTER; ",
/*"SURVIVE: Keep historical system rows intact; "
"DROP: Drop historical system rows while processing ALTER"*/,
SESSION_VAR(vers_alter_history), CMD_LINE(REQUIRED_ARG), SESSION_VAR(vers_alter_history), CMD_LINE(REQUIRED_ARG),
vers_alter_history_keywords, DEFAULT(VERS_ALTER_HISTORY_ERROR)); vers_alter_history_keywords, DEFAULT(VERS_ALTER_HISTORY_ERROR));

35
sql/table.cc
View File

@ -1198,8 +1198,6 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
uint ext_key_parts= 0; uint ext_key_parts= 0;
plugin_ref se_plugin= 0; plugin_ref se_plugin= 0;
const uchar *system_period= 0; const uchar *system_period= 0;
bool vtmd_used= false;
share->vtmd= false;
bool vers_can_native= false; bool vers_can_native= false;
const uchar *extra2_field_flags= 0; const uchar *extra2_field_flags= 0;
size_t extra2_field_flags_length= 0; size_t extra2_field_flags_length= 0;
@ -1302,17 +1300,6 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
goto err; goto err;
system_period = extra2; system_period = extra2;
break; break;
case EXTRA2_VTMD:
if (vtmd_used)
goto err;
share->vtmd= *extra2;
if (share->vtmd)
{
share->table_category= TABLE_CATEGORY_LOG;
share->no_replicate= true;
}
vtmd_used= true;
break;
case EXTRA2_FIELD_FLAGS: case EXTRA2_FIELD_FLAGS:
if (extra2_field_flags) if (extra2_field_flags)
goto err; goto err;
@ -7785,28 +7772,6 @@ void TABLE::vers_update_end()
DBUG_ASSERT(0); DBUG_ASSERT(0);
} }
bool TABLE_LIST::vers_vtmd_name(String& out) const
{
static const char *vtmd_suffix= "_vtmd";
static const size_t vtmd_suffix_len= strlen(vtmd_suffix);
if (table_name.length > NAME_CHAR_LEN - vtmd_suffix_len)
{
my_printf_error(ER_VERS_VTMD_ERROR, "Table name is longer than %d characters", MYF(0),
int(NAME_CHAR_LEN - vtmd_suffix_len));
return true;
}
out.set(table_name.str, table_name.length, table_alias_charset);
if (out.append(vtmd_suffix, vtmd_suffix_len + 1))
{
my_message(ER_VERS_VTMD_ERROR, "Failed allocate VTMD name", MYF(0));
return true;
}
out.length(out.length() - 1);
return false;
}
/** /**
Reset markers that fields are being updated Reset markers that fields are being updated
*/ */

9
sql/table.h
View File

@ -765,7 +765,6 @@ struct TABLE_SHARE
*/ */
vers_sys_type_t versioned; vers_sys_type_t versioned;
bool vtmd;
uint16 row_start_field; uint16 row_start_field;
uint16 row_end_field; uint16 row_end_field;
@ -1527,12 +1526,6 @@ public:
return versioned(type) ? vers_write : false; return versioned(type) ? vers_write : false;
} }
bool vers_vtmd() const
{
DBUG_ASSERT(s);
return s->versioned && s->vtmd;
}
Field *vers_start_field() const Field *vers_start_field() const
{ {
DBUG_ASSERT(s && s->versioned); DBUG_ASSERT(s && s->versioned);
@ -2397,8 +2390,6 @@ struct TABLE_LIST
/* System Versioning */ /* System Versioning */
vers_select_conds_t vers_conditions; vers_select_conds_t vers_conditions;
bool vers_vtmd_name(String &out) const;
bool vers_force_alias;
/** /**
@brief @brief

12
sql/unireg.cc
View File

@ -287,11 +287,6 @@ LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING *table,
extra2_size+= 1 + 1 + 2 * sizeof(uint16); extra2_size+= 1 + 1 + 2 * sizeof(uint16);
} }
if (create_info->vtmd())
{
extra2_size+= 1 + 1 + 1;
}
bool has_extra2_field_flags_= has_extra2_field_flags(create_fields); bool has_extra2_field_flags_= has_extra2_field_flags(create_fields);
if (has_extra2_field_flags_) if (has_extra2_field_flags_)
{ {
@ -364,13 +359,6 @@ LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING *table,
pos+= sizeof(uint16); pos+= sizeof(uint16);
} }
if (create_info->vtmd())
{
*pos++= EXTRA2_VTMD;
*pos++= 1;
*pos++= 1;
}
if (has_extra2_field_flags_) if (has_extra2_field_flags_)
pos= extra2_write_field_properties(pos, create_fields); pos= extra2_write_field_properties(pos, create_fields);

4
sql/unireg.h
View File

@ -176,7 +176,6 @@ enum extra2_frm_value_type {
EXTRA2_DEFAULT_PART_ENGINE=1, EXTRA2_DEFAULT_PART_ENGINE=1,
EXTRA2_GIS=2, EXTRA2_GIS=2,
EXTRA2_PERIOD_FOR_SYSTEM_TIME=4, EXTRA2_PERIOD_FOR_SYSTEM_TIME=4,
EXTRA2_VTMD=8,
#define EXTRA2_ENGINE_IMPORTANT 128 #define EXTRA2_ENGINE_IMPORTANT 128
@ -185,8 +184,7 @@ enum extra2_frm_value_type {
}; };
enum extra2_field_flags { enum extra2_field_flags {
VERS_OPTIMIZED_UPDATE= 1 << INVISIBLE_MAX_BITS, VERS_OPTIMIZED_UPDATE= 1 << INVISIBLE_MAX_BITS
VERS_HIDDEN= 1 << (INVISIBLE_MAX_BITS + 1),
}; };
int rea_create_table(THD *thd, LEX_CUSTRING *frm, int rea_create_table(THD *thd, LEX_CUSTRING *frm,

34
sql/vers_utils.h
View File

@ -44,38 +44,4 @@ public:
bool acquire_error() const { return error; } bool acquire_error() const { return error; }
}; };
class Local_da : public Diagnostics_area
{
THD *thd;
uint sql_error;
Diagnostics_area *saved_da;
public:
Local_da(THD *_thd, uint _sql_error= 0) :
Diagnostics_area(_thd->query_id, false, true),
thd(_thd),
sql_error(_sql_error),
saved_da(_thd->get_stmt_da())
{
thd->set_stmt_da(this);
}
~Local_da()
{
if (saved_da)
finish();
}
void finish()
{
DBUG_ASSERT(saved_da && thd);
thd->set_stmt_da(saved_da);
if (is_error())
my_error(sql_error ? sql_error : sql_errno(), MYF(0), message());
if (warn_count() > error_count())
saved_da->copy_non_errors_from_wi(thd, get_warning_info());
saved_da= NULL;
}
};
#endif // VERS_UTILS_INCLUDED #endif // VERS_UTILS_INCLUDED

687
sql/vtmd.cc
View File

@ -1,687 +0,0 @@
#include "vtmd.h"
#include "sql_base.h"
#include "sql_class.h"
#include "sql_handler.h" // mysql_ha_rm_tables()
#include "sql_table.h"
#include "sql_select.h"
#include "table_cache.h" // tdc_remove_table()
#include "key.h"
#include "sql_show.h"
#include "sql_parse.h"
#include "sql_lex.h"
#include "sp_head.h"
#include "sp_rcontext.h"
LString VERS_VTMD_TEMPLATE(C_STRING_WITH_LEN("vtmd_template"));
bool
VTMD_table::create(THD *thd)
{
Table_specification_st create_info;
TABLE_LIST src_table, table;
create_info.init(DDL_options_st::OPT_LIKE);
create_info.options|= HA_VTMD;
create_info.alias.str= vtmd_name.ptr();
create_info.alias.length= vtmd_name.length();
table.init_one_table(&about.db, &create_info.alias, NULL, TL_READ);
src_table.init_one_table(&MYSQL_SCHEMA_NAME, &VERS_VTMD_TEMPLATE,
&VERS_VTMD_TEMPLATE, TL_READ);
Query_tables_backup backup(thd);
thd->lex->add_to_query_tables(&src_table);
MDL_auto_lock mdl_lock(thd, table);
if (mdl_lock.acquire_error())
return true;
Reprepare_observer *reprepare_observer= thd->m_reprepare_observer;
thd->m_reprepare_observer= NULL;
#ifdef WITH_PARTITION_STORAGE_ENGINE
partition_info *work_part_info= thd->work_part_info;
thd->work_part_info= NULL;
#endif
bool rc= mysql_create_like_table(thd, &table, &src_table, &create_info);
thd->m_reprepare_observer= reprepare_observer;
#ifdef WITH_PARTITION_STORAGE_ENGINE
thd->work_part_info= work_part_info;
#endif
return rc;
}
bool
VTMD_table::find_record(ulonglong row_end, bool &found)
{
int error;
key_buf_t key;
found= false;
DBUG_ASSERT(vtmd.table);
if (key.allocate(vtmd.table->s->max_unique_length))
return true;
DBUG_ASSERT(row_end);
vtmd.table->vers_end_field()->set_notnull();
vtmd.table->vers_end_field()->store(row_end, true);
key_copy(key, vtmd.table->record[0], vtmd.table->key_info + IDX_TRX_END, 0);
error= vtmd.table->file->ha_index_read_idx_map(vtmd.table->record[1], IDX_TRX_END,
key,
HA_WHOLE_KEY,
HA_READ_KEY_EXACT);
if (error)
{
if (error == HA_ERR_RECORD_DELETED || error == HA_ERR_KEY_NOT_FOUND)
return false;
vtmd.table->file->print_error(error, MYF(0));
return true;
}
restore_record(vtmd.table, record[1]);
found= true;
return false;
}
bool
VTMD_table::open(THD *thd, Local_da &local_da, bool *created)
{
if (created)
*created= false;
if (0 == vtmd_name.length() && about.vers_vtmd_name(vtmd_name))
return true;
while (true) // max 2 iterations
{
LEX_CSTRING table_name= { vtmd_name.ptr(), vtmd_name.length() };
vtmd.init_one_table(&about.db, &table_name, NULL,
TL_WRITE_CONCURRENT_INSERT);
TABLE *res= open_log_table(thd, &vtmd, &open_tables_backup);
if (res)
return false;
if (created && !*created && local_da.is_error() &&
local_da.sql_errno() == ER_NO_SUCH_TABLE)
{
local_da.reset_diagnostics_area();
if (create(thd))
break;
*created= true;
}
else
break;
}
return true;
}
bool
VTMD_table::update(THD *thd, const char* archive_name)
{
bool result= true;
bool found= false;
bool created;
int error;
size_t an_len= 0;
ulonglong save_thd_options;
{
Local_da local_da(thd, ER_VERS_VTMD_ERROR);
save_thd_options= thd->variables.option_bits;
thd->variables.option_bits&= ~OPTION_BIN_LOG;
if (open(thd, local_da, &created))
goto open_error;
if (!vtmd.table->versioned())
{
my_message(ER_VERS_VTMD_ERROR, "VTMD is not versioned", MYF(0));
goto quit;
}
if (!created && find_record(ULONGLONG_MAX, found))
goto quit;
if ((error= vtmd.table->file->extra(HA_EXTRA_MARK_AS_LOG_TABLE)))
{
vtmd.table->file->print_error(error, MYF(0));
goto quit;
}
/* Honor next number columns if present */
vtmd.table->next_number_field= vtmd.table->found_next_number_field;
if (vtmd.table->s->fields != FIELD_COUNT)
{
my_printf_error(ER_VERS_VTMD_ERROR, "`%s.%s` unexpected fields count: %d", MYF(0),
vtmd.table->s->db.str, vtmd.table->s->table_name.str, vtmd.table->s->fields);
goto quit;
}
if (archive_name)
{
an_len= strlen(archive_name);
vtmd.table->field[FLD_ARCHIVE_NAME]->store(archive_name, an_len, table_alias_charset);
vtmd.table->field[FLD_ARCHIVE_NAME]->set_notnull();
}
else
{
vtmd.table->field[FLD_ARCHIVE_NAME]->set_null();
}
vtmd.table->field[FLD_COL_RENAMES]->set_null();
if (found)
{
if (thd->lex->sql_command == SQLCOM_CREATE_TABLE)
{
my_printf_error(ER_VERS_VTMD_ERROR, "`%s.%s` exists and not empty!", MYF(0),
vtmd.table->s->db.str, vtmd.table->s->table_name.str);
goto quit;
}
vtmd.table->mark_columns_needed_for_update(); // not needed?
if (archive_name)
{
vtmd.table->vers_write= false;
error= vtmd.table->file->ha_update_row(vtmd.table->record[1], vtmd.table->record[0]);
vtmd.table->vers_write= true;
if (!error)
{
if (thd->lex->sql_command == SQLCOM_DROP_TABLE)
{
error= vtmd.table->file->ha_delete_row(vtmd.table->record[0]);
}
else
{
DBUG_ASSERT(thd->lex->sql_command == SQLCOM_ALTER_TABLE);
ulonglong row_end= (ulonglong) vtmd.table->vers_start_field()->val_int();
store_record(vtmd.table, record[1]);
vtmd.table->field[FLD_NAME]->store(about.table_name.str, about.table_name.length, system_charset_info);
vtmd.table->field[FLD_NAME]->set_notnull();
vtmd.table->field[FLD_ARCHIVE_NAME]->set_null();
error= vtmd.table->file->ha_update_row(vtmd.table->record[1], vtmd.table->record[0]);
if (error)
goto err;
DBUG_ASSERT(an_len);
while (true)
{ // fill archive_name of last sequential renames
bool found;
if (find_record(row_end, found))
goto quit;
if (!found || !vtmd.table->field[FLD_ARCHIVE_NAME]->is_null())
break;
store_record(vtmd.table, record[1]);
vtmd.table->field[FLD_ARCHIVE_NAME]->store(archive_name, an_len, table_alias_charset);
vtmd.table->field[FLD_ARCHIVE_NAME]->set_notnull();
vtmd.table->vers_write= false;
error= vtmd.table->file->ha_update_row(vtmd.table->record[1], vtmd.table->record[0]);
vtmd.table->vers_write= true;
if (error)
goto err;
row_end= (ulonglong) vtmd.table->vers_start_field()->val_int();
} // while (true)
} // else (thd->lex->sql_command != SQLCOM_DROP_TABLE)
} // if (!error)
} // if (archive_name)
else
{
vtmd.table->field[FLD_NAME]->store(about.table_name.str,
about.table_name.length,
system_charset_info);
vtmd.table->field[FLD_NAME]->set_notnull();
error= vtmd.table->file->ha_update_row(vtmd.table->record[1],
vtmd.table->record[0]);
}
} // if (found)
else
{
vtmd.table->field[FLD_NAME]->store(about.table_name.str,
about.table_name.length,
system_charset_info);
vtmd.table->field[FLD_NAME]->set_notnull();
vtmd.table->mark_columns_needed_for_insert(); // not needed?
error= vtmd.table->file->ha_write_row(vtmd.table->record[0]);
}
if (error)
{
err:
vtmd.table->file->print_error(error, MYF(0));
}
else
result= local_da.is_error();
}
quit:
if (!result && vtmd.table->file->ht->prepare_commit_versioned)
{
DBUG_ASSERT(TR_table::use_transaction_registry); // FIXME: disable survival mode while TRT is disabled
TR_table trt(thd, true);
ulonglong trx_start_id= 0;
ulonglong trx_end_id= vtmd.table->file->ht->prepare_commit_versioned(thd, &trx_start_id);
result= trx_end_id && trt.update(trx_start_id, trx_end_id);
}
close_log_table(thd, &open_tables_backup);
open_error:
thd->variables.option_bits= save_thd_options;
return result;
}
bool
VTMD_rename::move_archives(THD *thd, LString &new_db)
{
int error;
bool rc= false;
SString_fs archive;
bool end_keyread= false;
bool index_end= false;
Open_tables_backup open_tables_backup;
key_buf_t key;
LEX_CSTRING table_name= { vtmd_name.ptr(), vtmd_name.length() };
vtmd.init_one_table(&about.db, &table_name, NULL, TL_READ);
TABLE *res= open_log_table(thd, &vtmd, &open_tables_backup);
if (!res)
return true;
if (key.allocate(vtmd.table->key_info[IDX_ARCHIVE_NAME].key_length))
{
close_log_table(thd, &open_tables_backup);
return true;
}
if ((error= vtmd.table->file->ha_start_keyread(IDX_ARCHIVE_NAME)))
goto err;
end_keyread= true;
if ((error= vtmd.table->file->ha_index_init(IDX_ARCHIVE_NAME, true)))
goto err;
index_end= true;
error= vtmd.table->file->ha_index_first(vtmd.table->record[0]);
while (!error)
{
if (!vtmd.table->field[FLD_ARCHIVE_NAME]->is_null())
{
vtmd.table->field[FLD_ARCHIVE_NAME]->val_str(&archive);
key_copy(key,
vtmd.table->record[0],
&vtmd.table->key_info[IDX_ARCHIVE_NAME],
vtmd.table->key_info[IDX_ARCHIVE_NAME].key_length,
false);
error= vtmd.table->file->ha_index_read_map(
vtmd.table->record[0],
key,
vtmd.table->key_info[IDX_ARCHIVE_NAME].ext_key_part_map,
HA_READ_PREFIX_LAST);
if (!error)
{
if ((rc= move_table(thd, archive, new_db)))
break;
error= vtmd.table->file->ha_index_next(vtmd.table->record[0]);
}
}
else
{
archive.length(0);
error= vtmd.table->file->ha_index_next(vtmd.table->record[0]);
}
}
if (error && error != HA_ERR_END_OF_FILE)
{
err:
vtmd.table->file->print_error(error, MYF(0));
rc= true;
}
if (index_end)
vtmd.table->file->ha_index_end();
if (end_keyread)
vtmd.table->file->ha_end_keyread();
close_log_table(thd, &open_tables_backup);
return rc;
}
bool
VTMD_rename::move_table(THD *thd, SString_fs &table_name, LString &new_db)
{
handlerton *table_hton= NULL;
LEX_CSTRING tbl_name= { table_name.ptr(), table_name.length() };
LEX_CSTRING db_name= { new_db.ptr(), new_db.length() };
if (!ha_table_exists(thd, &about.db, &tbl_name, &table_hton) || !table_hton)
{
push_warning_printf( thd, Sql_condition::WARN_LEVEL_WARN,
ER_VERS_VTMD_ERROR,
"`%s.%s` archive doesn't exist",
about.db.str, tbl_name.str);
return false;
}
if (ha_table_exists(thd, &db_name, &tbl_name))
{
my_printf_error(ER_VERS_VTMD_ERROR, "`%s.%s` archive already exists!",
MYF(0),
db_name.str, tbl_name.str);
return true;
}
TABLE_LIST tl;
tl.init_one_table(&about.db, &tbl_name, NULL, TL_WRITE_ONLY);
tl.mdl_request.set_type(MDL_EXCLUSIVE);
mysql_ha_rm_tables(thd, &tl);
if (lock_table_names(thd, &tl, 0, thd->variables.lock_wait_timeout, 0))
return true;
tdc_remove_table(thd, TDC_RT_REMOVE_ALL, about.db.str, table_name, false);
bool rc= mysql_rename_table(table_hton,
&about.db, &tbl_name, &db_name, &tbl_name,
NO_FK_CHECKS);
if (!rc)
query_cache_invalidate3(thd, &tl, 0);
return rc;
}
bool
VTMD_rename::try_rename(THD *thd, LString new_db, LString new_alias, const char *archive_name)
{
Local_da local_da(thd, ER_VERS_VTMD_ERROR);
TABLE_LIST new_table;
if (check_exists(thd))
return true;
LEX_CSTRING new_db_name= { XSTRING_WITH_LEN(new_db) };
LEX_CSTRING new_tbl_name= { XSTRING_WITH_LEN(new_alias) };
new_table.init_one_table(&new_db_name, &new_tbl_name, NULL, TL_READ);
if (new_table.vers_vtmd_name(vtmd_new_name))
return true;
LEX_CSTRING new_name= { vtmd_new_name.ptr(), vtmd_new_name.length() };
if (ha_table_exists(thd, &new_db_name, &new_name))
{
if (exists)
{
my_printf_error(ER_VERS_VTMD_ERROR, "`%s.%s` table already exists!",
MYF(0),
new_db_name.str, new_name.str);
return true;
}
push_warning_printf( thd, Sql_condition::WARN_LEVEL_WARN,
ER_VERS_VTMD_ERROR,
"`%s.%s` table already exists!",
new_db_name.str, new_name.str);
return false;
}
if (!exists)
return false;
bool same_db= true;
if (LString_fs(DB_WITH_LEN(about)) != LString_fs(new_db))
{
// Move archives before VTMD so if the operation is interrupted, it could be continued.
if (move_archives(thd, new_db))
return true;
same_db= false;
}
TABLE_LIST vtmd_tl;
LEX_CSTRING table_name= { vtmd_name.ptr(), vtmd_name.length() };
vtmd_tl.init_one_table(&about.db, &table_name, NULL, TL_WRITE_ONLY);
vtmd_tl.mdl_request.set_type(MDL_EXCLUSIVE);
mysql_ha_rm_tables(thd, &vtmd_tl);
if (lock_table_names(thd, &vtmd_tl, 0, thd->variables.lock_wait_timeout, 0))
return true;
tdc_remove_table(thd, TDC_RT_REMOVE_ALL, about.db.str, vtmd_name, false);
if (local_da.is_error()) // just safety check
return true;
bool rc= mysql_rename_table(hton, &about.db, &table_name,
&new_db_name, &new_name,
NO_FK_CHECKS);
if (!rc)
{
query_cache_invalidate3(thd, &vtmd_tl, 0);
if (same_db || archive_name ||
new_alias != LString(TABLE_NAME_WITH_LEN(about)))
{
local_da.finish();
VTMD_table new_vtmd(new_table);
rc= new_vtmd.update(thd, archive_name);
}
}
return rc;
}
bool
VTMD_rename::revert_rename(THD *thd, LString new_db)
{
DBUG_ASSERT(hton);
Local_da local_da(thd, ER_VERS_VTMD_ERROR);
TABLE_LIST vtmd_tl;
LEX_CSTRING new_name= { XSTRING_WITH_LEN(vtmd_new_name) };
LEX_CSTRING v_name= { XSTRING_WITH_LEN(vtmd_name) };
LEX_CSTRING new_db_name= { XSTRING_WITH_LEN(new_db) };
vtmd_tl.init_one_table(&about.db, &new_name, NULL, TL_WRITE_ONLY);
vtmd_tl.mdl_request.set_type(MDL_EXCLUSIVE);
mysql_ha_rm_tables(thd, &vtmd_tl);
if (lock_table_names(thd, &vtmd_tl, 0, thd->variables.lock_wait_timeout, 0))
return true;
tdc_remove_table(thd, TDC_RT_REMOVE_ALL, new_db, vtmd_new_name, false);
bool rc= mysql_rename_table(hton, &new_db_name, &new_name,
&new_db_name, &v_name,
NO_FK_CHECKS);
if (!rc)
query_cache_invalidate3(thd, &vtmd_tl, 0);
return rc;
}
void
VTMD_table::archive_name(
THD* thd,
const char* table_name,
char* new_name,
size_t new_name_size)
{
const MYSQL_TIME now= thd->query_start_TIME();
my_snprintf(new_name, new_name_size, "%s_%04d%02d%02d_%02d%02d%02d_%06lu",
table_name, now.year, now.month, now.day, now.hour, now.minute,
now.second, (ulong) now.second_part);
}
bool
VTMD_table::find_archive_name(THD *thd, String &out)
{
READ_RECORD info;
int error;
SQL_SELECT *select= NULL;
COND *conds= NULL;
List<TABLE_LIST> dummy;
SELECT_LEX &select_lex= thd->lex->select_lex;
Local_da local_da(thd, ER_VERS_VTMD_ERROR);
if (open(thd, local_da))
return true;
Name_resolution_context &ctx= thd->lex->select_lex.context;
TABLE_LIST *table_list= ctx.table_list;
TABLE_LIST *first_name_resolution_table= ctx.first_name_resolution_table;
table_map map = vtmd.table->map;
ctx.table_list= &vtmd;
ctx.first_name_resolution_table= &vtmd;
vtmd.table->map= 1;
vtmd.vers_conditions= about.vers_conditions;
if ((error= select_lex.vers_setup_conds(thd, &vtmd, &conds)) ||
(error= setup_conds(thd, &vtmd, dummy, &conds)))
goto err;
select= make_select(vtmd.table, 0, 0, conds, NULL, 0, &error);
if (error)
goto loc_err;
error= init_read_record(&info, thd, vtmd.table, select, NULL,
1 /* use_record_cache */, true /* print_error */,
false /* disable_rr_cache */);
if (error)
goto loc_err;
while (!(error= info.read_record()) && !thd->killed && !thd->is_error())
{
if (!select || select->skip_record(thd) > 0)
{
vtmd.table->field[FLD_ARCHIVE_NAME]->val_str(&out);
break;
}
}
if (error < 0)
my_error(ER_NO_SUCH_TABLE, MYF(0), about.db.str, about.alias.str);
loc_err:
end_read_record(&info);
err:
delete select;
ctx.table_list= table_list;
ctx.first_name_resolution_table= first_name_resolution_table;
vtmd.table->map= map;
close_log_table(thd, &open_tables_backup);
DBUG_ASSERT(!error || local_da.is_error());
return error;
}
static
bool
get_vtmd_tables(THD *thd, const char *db,
size_t db_length, Dynamic_array<LEX_CSTRING *> &table_names)
{
LOOKUP_FIELD_VALUES lookup_field_values= {
{db, db_length}, {C_STRING_WITH_LEN("%_vtmd")}, false, true};
int res= make_table_name_list(thd, &table_names, thd->lex, &lookup_field_values,
&lookup_field_values.db_value);
return res;
}
bool
VTMD_table::get_archive_tables(THD *thd, const char *db, size_t db_length,
Dynamic_array<String> &result)
{
Dynamic_array<LEX_CSTRING *> vtmd_tables;
if (get_vtmd_tables(thd, db, db_length, vtmd_tables))
return true;
Local_da local_da(thd, ER_VERS_VTMD_ERROR);
for (uint i= 0; i < vtmd_tables.elements(); i++)
{
LEX_CSTRING table_name= *vtmd_tables.at(i);
Open_tables_backup open_tables_backup;
TABLE_LIST table_list;
LEX_CSTRING db_name= {db, db_length};
table_list.init_one_table(&db_name, &table_name, NULL, TL_READ);
TABLE *table= open_log_table(thd, &table_list, &open_tables_backup);
if (!table || !table->vers_vtmd())
{
if (table)
close_log_table(thd, &open_tables_backup);
else
{
if (local_da.is_error() && local_da.sql_errno() == ER_NOT_LOG_TABLE)
local_da.reset_diagnostics_area();
else
return true;
}
push_warning_printf(
thd, Sql_condition::WARN_LEVEL_WARN,
ER_VERS_VTMD_ERROR,
"Table `%s.%s` is not a VTMD table",
db, table_name.str);
continue;
}
READ_RECORD read_record;
int error= 0;
SQL_SELECT *sql_select= make_select(table, 0, 0, NULL, NULL, 0, &error);
if (error)
{
close_log_table(thd, &open_tables_backup);
return true;
}
error= init_read_record(&read_record, thd, table, sql_select, NULL, 1, 1, false);
if (error)
{
delete sql_select;
close_log_table(thd, &open_tables_backup);
return true;
}
while (!(error= read_record.read_record()))
{
Field *field= table->field[FLD_ARCHIVE_NAME];
if (field->is_null())
continue;
String archive_name;
field->val_str(&archive_name);
archive_name.set_ascii(strmake_root(thd->mem_root, archive_name.c_ptr(),
archive_name.length()),
archive_name.length());
result.push(archive_name);
}
// check for EOF
if (!thd->is_error())
error= 0;
end_read_record(&read_record);
delete sql_select;
close_log_table(thd, &open_tables_backup);
}
return false;
}
bool VTMD_table::setup_select(THD* thd)
{
SString archive_name;
if (find_archive_name(thd, archive_name))
return true;
if (archive_name.length() == 0)
return false;
thd->make_lex_string(&about.table_name, archive_name.ptr(),
archive_name.length());
DBUG_ASSERT(!about.mdl_request.ticket);
about.mdl_request.init(MDL_key::TABLE, about.db.str, about.table_name.str,
about.mdl_request.type, about.mdl_request.duration);
about.vers_force_alias= true;
// Since we modified SELECT_LEX::table_list, we need to invalidate current SP
if (thd->spcont)
{
DBUG_ASSERT(thd->spcont->m_sp);
thd->spcont->m_sp->set_sp_cache_version(0);
}
return false;
}

190
sql/vtmd.h
View File

@ -1,190 +0,0 @@
#ifndef VTMD_INCLUDED
#define VTMD_INCLUDED
#include <mysqld_error.h>
#include "mariadb.h"
#include "sql_priv.h"
#include "my_sys.h"
#include "table.h"
#include "unireg.h"
#include "vers_utils.h"
class key_buf_t
{
uchar* buf;
key_buf_t(const key_buf_t&); // disabled
key_buf_t& operator= (const key_buf_t&); // disabled
public:
key_buf_t() : buf(NULL)
{}
~key_buf_t()
{
if (buf)
my_free(buf);
}
bool allocate(size_t alloc_size)
{
DBUG_ASSERT(!buf);
buf= static_cast<uchar *>(my_malloc(alloc_size, MYF(0)));
if (!buf)
{
my_message(ER_VERS_VTMD_ERROR, "failed to allocate key buffer", MYF(0));
return true;
}
return false;
}
operator uchar* ()
{
DBUG_ASSERT(buf);
return reinterpret_cast<uchar *>(buf);
}
};
class THD;
class VTMD_table
{
Open_tables_backup open_tables_backup;
protected:
TABLE_LIST vtmd;
TABLE_LIST &about;
SString_t vtmd_name;
private:
VTMD_table(const VTMD_table&); // prohibit copying references
public:
enum {
FLD_START= 0,
FLD_END,
FLD_NAME,
FLD_ARCHIVE_NAME,
FLD_COL_RENAMES,
FIELD_COUNT
};
enum {
IDX_TRX_END= 0,
IDX_ARCHIVE_NAME
};
VTMD_table(TABLE_LIST &_about) :
about(_about)
{
vtmd.table= NULL;
}
bool create(THD *thd);
bool find_record(ulonglong row_end, bool &found);
bool open(THD *thd, Local_da &local_da, bool *created= NULL);
bool update(THD *thd, const char* archive_name= NULL);
bool setup_select(THD *thd);
static void archive_name(THD *thd, const char *table_name, char *new_name, size_t new_name_size);
void archive_name(THD *thd, char *new_name, size_t new_name_size)
{
archive_name(thd, about.table_name.str, new_name, new_name_size);
}
bool find_archive_name(THD *thd, String &out);
static bool get_archive_tables(THD *thd, const char *db, size_t db_length,
Dynamic_array<String> &result);
};
class VTMD_exists : public VTMD_table
{
protected:
handlerton *hton;
public:
bool exists;
public:
VTMD_exists(TABLE_LIST &_about) :
VTMD_table(_about),
hton(NULL),
exists(false)
{}
bool check_exists(THD *thd); // returns error status
};
class VTMD_rename : public VTMD_exists
{
SString_t vtmd_new_name;
public:
VTMD_rename(TABLE_LIST &_about) :
VTMD_exists(_about)
{}
bool try_rename(THD *thd, LString new_db, LString new_alias, const char* archive_name= NULL);
bool revert_rename(THD *thd, LString new_db);
private:
bool move_archives(THD *thd, LString &new_db);
bool move_table(THD *thd, SString_fs &table_name, LString &new_db);
};
class VTMD_drop : public VTMD_exists
{
char archive_name_[NAME_CHAR_LEN];
public:
VTMD_drop(TABLE_LIST &_about) :
VTMD_exists(_about)
{
*archive_name_= 0;
}
const char* archive_name(THD *thd)
{
VTMD_table::archive_name(thd, archive_name_, sizeof(archive_name_));
return archive_name_;
}
const char* archive_name() const
{
DBUG_ASSERT(*archive_name_);
return archive_name_;
}
bool update(THD *thd)
{
DBUG_ASSERT(*archive_name_);
return VTMD_exists::update(thd, archive_name_);
}
};
inline
bool
VTMD_exists::check_exists(THD *thd)
{
LEX_CSTRING name;
if (about.vers_vtmd_name(vtmd_name))
return true;
name.str= vtmd_name.ptr();
name.length= vtmd_name.length();
exists= ha_table_exists(thd, &about.db, &name, &hton);
if (exists && !hton)
{
my_printf_error(ER_VERS_VTMD_ERROR, "`%s.%s` handlerton empty!", MYF(0),
about.db.str, vtmd_name.ptr());
return true;
}
return false;
}
#endif // VTMD_INCLUDED

3
storage/innobase/handler/ha_innodb.cc
View File

@ -8823,8 +8823,7 @@ ha_innobase::update_row(
const bool vers_set_fields = m_prebuilt->versioned_write const bool vers_set_fields = m_prebuilt->versioned_write
&& m_prebuilt->upd_node->update->affects_versioned(); && m_prebuilt->upd_node->update->affects_versioned();
const bool vers_ins_row = vers_set_fields const bool vers_ins_row = vers_set_fields
&& (table->s->vtmd && thd_sql_command(m_user_thd) != SQLCOM_ALTER_TABLE;
|| thd_sql_command(m_user_thd) != SQLCOM_ALTER_TABLE);
/* This is not a delete */ /* This is not a delete */
m_prebuilt->upd_node->is_delete = m_prebuilt->upd_node->is_delete =