database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-12-24 11:21:21 +03:00
Code Activity

5.5 merge

Browse Source
This commit is contained in:
Sergei Golubchik
2014-11-03 17:47:37 +01:00
parent d1ca1c1fae 50556e7e9a
commit 2160646c1d
79 changed files with 302659 additions and 2805 deletions
Download Patch File Download Diff File Expand all files Collapse all files

324
storage/tokudb/mysql-test/tokudb/r/bf_create_select.result
View File

@@ -1,72 +1,56 @@
set default_storage_engine='tokudb';
drop table if exists t,t1,t2;
CREATE TABLE `t` (
drop table if exists t1,t2;
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
count(*)
8388608
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
1048576
set tokudb_bulk_fetch=ON;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
set tokudb_bulk_fetch=OFF;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
@@ -88,155 +72,127 @@ DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
1
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
set tokudb_bulk_fetch=ON;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
set tokudb_bulk_fetch=OFF;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
1
drop table t,t1;
drop table t1;

512
storage/tokudb/mysql-test/tokudb/r/bf_create_select_hash_part.result
View File

@@ -1,328 +1,198 @@
set default_storage_engine='tokudb';
drop table if exists t,t1,t2,t3;
CREATE TABLE `t` (
drop table if exists t1,t2;
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
) PARTITION BY HASH (num) PARTITIONS 8;
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
count(*)
8388608
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
CREATE TABLE `t2` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) PARTITION BY HASH (num)
PARTITIONS 8 as select * from t;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
1048576
set tokudb_bulk_fetch=ON;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
set tokudb_bulk_fetch=OFF;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
1
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
set tokudb_bulk_fetch=ON;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
set tokudb_bulk_fetch=OFF;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
1
drop table t,t1,t2;
drop table t1;

525
storage/tokudb/mysql-test/tokudb/r/bf_create_select_range_part.result
View File

@@ -1,335 +1,206 @@
set default_storage_engine='tokudb';
drop table if exists t,t1,t2;
CREATE TABLE `t` (
drop table if exists t1,t2;
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
count(*)
8388608
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
CREATE TABLE `t2` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) PARTITION BY RANGE (num)
(PARTITION p0 VALUES LESS THAN (1000000),
PARTITION p1 VALUES LESS THAN (2000000),
PARTITION p2 VALUES LESS THAN (3000000),
PARTITION p3 VALUES LESS THAN (4000000),
PARTITION p4 VALUES LESS THAN (5000000),
PARTITION p5 VALUES LESS THAN (6000000),
PARTITION p6 VALUES LESS THAN (7000000),
PARTITION p7 VALUES LESS THAN MAXVALUE) as select * from t;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
(PARTITION p0 VALUES LESS THAN (100000),
PARTITION p1 VALUES LESS THAN (200000),
PARTITION p2 VALUES LESS THAN (300000),
PARTITION p3 VALUES LESS THAN (400000),
PARTITION p4 VALUES LESS THAN (500000),
PARTITION p5 VALUES LESS THAN (600000),
PARTITION p6 VALUES LESS THAN (700000),
PARTITION p7 VALUES LESS THAN MAXVALUE);
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
count(*)
8388608
DROP TABLE t3;
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
1048576
set tokudb_bulk_fetch=ON;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
set tokudb_bulk_fetch=OFF;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
1
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
DROP TABLE t3;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
set tokudb_bulk_fetch=ON;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
set tokudb_bulk_fetch=OFF;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
1
drop table t,t1,t2;
drop table t1;

404
storage/tokudb/mysql-test/tokudb/r/bf_create_temp_select.result
View File

@@ -1,242 +1,198 @@
set default_storage_engine='tokudb';
drop table if exists t,t1,t2;
CREATE TABLE `t` (
drop table if exists t1,t2;
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
count(*)
8388608
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
1048576
set tokudb_bulk_fetch=ON;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
set tokudb_bulk_fetch=OFF;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
1
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
set tokudb_bulk_fetch=ON;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
set tokudb_bulk_fetch=OFF;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
1
drop table t,t1;
drop table t1;

286
storage/tokudb/mysql-test/tokudb/r/bf_insert_select.result
View File

@@ -1,75 +1,69 @@
set default_storage_engine='tokudb';
drop table if exists t,t1,t2;
CREATE TABLE `t` (
drop table if exists t1,t2;
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
count(*)
8388608
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
CREATE TABLE `t2` (
`count` bigint(20) NOT NULL
) ENGINE=TokuDB DEFAULT CHARSET=latin1;
SELECT count(*) from t1;
);
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
1048576
set tokudb_bulk_fetch=ON;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
set tokudb_bulk_fetch=OFF;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
@@ -81,125 +75,47 @@ INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
INSERT into t2 SELECT count(*) from t1;
1
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
set tokudb_bulk_fetch=ON;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
set tokudb_bulk_fetch=OFF;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
INSERT into t2 SELECT count(*) from t1 where num > 700000;
1
drop table t,t1,t2;
drop table t1,t2;

286
storage/tokudb/mysql-test/tokudb/r/bf_insert_select_dup_key.result
View File

@@ -1,77 +1,71 @@
set default_storage_engine='tokudb';
drop table if exists t,t1,t2;
CREATE TABLE `t` (
drop table if exists t1,t2;
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
count(*)
8388608
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
1048576
CREATE TABLE `t2` (
`num` int(10) unsigned auto_increment NOT NULL,
`count` bigint(20) NOT NULL,
UNIQUE (num)
) ENGINE=TokuDB DEFAULT CHARSET=latin1;
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
);
set tokudb_bulk_fetch=ON;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
set tokudb_bulk_fetch=OFF;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
@@ -83,125 +77,47 @@ INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
1
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
set tokudb_bulk_fetch=ON;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
set tokudb_bulk_fetch=OFF;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
1
drop table t,t1,t2;
drop table t1,t2;

448
storage/tokudb/mysql-test/tokudb/r/bf_replace_select.result
View File

@@ -1,75 +1,69 @@
set default_storage_engine='tokudb';
drop table if exists t,t1,t2;
CREATE TABLE `t` (
drop table if exists t1,t2;
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
count(*)
8388608
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
CREATE TABLE `t2` (
`count` bigint(20) NOT NULL
) ENGINE=TokuDB DEFAULT CHARSET=latin1;
SELECT count(*) from t1;
);
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
1048576
set tokudb_bulk_fetch=ON;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
set tokudb_bulk_fetch=OFF;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
@@ -81,287 +75,47 @@ REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
1
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
SELECT count(*) from t1;
count(*)
8388608
INSERT IGNORE into t2 SELECT count(*) from t1;
INSERT IGNORE into t2 SELECT count(*) from t1;
INSERT IGNORE into t2 SELECT count(*) from t1;
INSERT IGNORE into t2 SELECT count(*) from t1;
INSERT IGNORE into t2 SELECT count(*) from t1;
INSERT IGNORE into t2 SELECT count(*) from t1;
INSERT IGNORE into t2 SELECT count(*) from t1;
INSERT IGNORE into t2 SELECT count(*) from t1;
INSERT IGNORE into t2 SELECT count(*) from t1;
INSERT IGNORE into t2 SELECT count(*) from t1;
set tokudb_bulk_fetch=ON;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
set tokudb_bulk_fetch=OFF;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
1
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
1
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
SELECT count(*) from t1 where num > 7000000;
count(*)
1847274
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
1
drop table t,t1,t2;
drop table t1,t2;

120
storage/tokudb/mysql-test/tokudb/r/bf_select_range_part.result
View File

@@ -98,6 +98,36 @@ count(*)
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
set tokudb_bulk_fetch=OFF;
SELECT count(*) from t;
count(*)
@@ -159,6 +189,36 @@ count(*)
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
SELECT count(*) from t;
count(*)
1048576
1
set tokudb_bulk_fetch=ON;
SELECT count(*) from t where num > 700000;
@@ -221,6 +281,36 @@ count(*)
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
set tokudb_bulk_fetch=OFF;
SELECT count(*) from t where num > 700000;
count(*)
@@ -282,5 +372,35 @@ count(*)
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
SELECT count(*) from t where num > 700000;
count(*)
348576
1
drop table t;

129
storage/tokudb/mysql-test/tokudb/t/bf_create_select.test
View File

@@ -6,64 +6,56 @@ source include/have_tokudb.inc;
source include/big_test.inc;
set default_storage_engine='tokudb';
disable_warnings;
drop table if exists t,t1,t2;
drop table if exists t1,t2;
enable_warnings;
let $maxq = 10;
let $debug = 0;
CREATE TABLE `t` (
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
# put 8M rows into t
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
# put 1M rows into t1
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
# Create first table from source table t
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
let $s = `select to_seconds(now())`;
let $maxq = 10;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
SELECT count(*) from t1;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
CREATE TABLE t2 AS SELECT count(*) from t1;
@@ -71,48 +63,41 @@ while ($i < $maxq) {
inc $i;
}
let $time_elapsed_create_select = `select to_seconds(now()) - $s`;
let $time_elapsed_off = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_create_select seconds.;
# This check evaluates whether the time elapsed during the create select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_create_select - $time_elapsed_select) <= $time_elapsed_select`;
# Check that the time with bulk fetch off is at least twice that whith bulk fetch on
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo index $verdict $time_elapsed_on $time_elapsed_off; }
if (!$verdict) { echo index $time_elapsed_on $time_elapsed_off; }
let $maxrq = 30;
let $maxq = 30;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
SELECT count(*) from t1 where num > 7000000;
while ($i < $maxq) {
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
while ($i < $maxq) {
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_create_select = `select to_seconds(now()) - $s`;
let $time_elapsed_off = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_create_select seconds.;
# This check evaluates whether the time elapsed during the create select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_create_select - $time_elapsed_select) <= $time_elapsed_select`;
# Check that the time with bulk fetch off is at least twice that whith bulk fetch on
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo range $verdict $time_elapsed_on $time_elapsed_off; }
if (!$verdict) { echo range $time_elapsed_on $time_elapsed_off; }
drop table t,t1;
drop table t1;

163
storage/tokudb/mysql-test/tokudb/t/bf_create_select_hash_part.test
View File

@@ -7,137 +7,96 @@ source include/have_partition.inc;
source include/big_test.inc;
set default_storage_engine='tokudb';
disable_warnings;
drop table if exists t,t1,t2,t3;
drop table if exists t1,t2;
enable_warnings;
let $maxq = 10;
let $debug = 0;
CREATE TABLE `t` (
# Create source hash partitioned table from source table t
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
) PARTITION BY HASH (num) PARTITIONS 8;
# put 8M rows into t
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
# put 1M rows into t1
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
# Create base table (control table) from source table t
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
let $maxq = 20;
# Create source hash partitioned table from source table t
CREATE TABLE `t2` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) PARTITION BY HASH (num)
PARTITIONS 8 as select * from t;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
DROP TABLE t3;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
CREATE TABLE t3 AS SELECT count(*) from t2;
DROP TABLE t3;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_off = `select unix_timestamp() - $s`;
let $time_elapsed_create_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_create_select seconds.;
# This check evaluates whether the time elapsed during the create select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
# Additionally, it is important to note that 1.5 is the multiplier applied to the time_elapsed_select
# value because it appears that MySQL 5.5.39 uses a sorted index scan during the create select statement
# while Percona Server 5.6 uses an unsorted index scan.
# The issue has been resolved in MySQL 5.6 but still persists in Maria 10.0.12
# in the defect found at https://mariadb.atlassian.net/browse/MDEV-6547.
let $verdict = `select abs($time_elapsed_create_select - $time_elapsed_select) <= 1.5 * $time_elapsed_select`;
# check that bulk fetch on is at least 1.5 times faster than bulk fetch off
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 1.5 * $time_elapsed_on`;
echo $verdict;
if (!$verdict) { echo index scan t2 $time_elapsed_create_select $time_elapsed_select; }
if ($debug) { echo index $verdict $time_elapsed_off $time_elapsed_on; }
if (!$verdict) { echo index $time_elapsed_off $time_elapsed_on; }
let $maxrq = 30;
let $maxq = 20;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
DROP TABLE t3;
while ($i < $maxq) {
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
CREATE TABLE t3 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t3;
while ($i < $maxq) {
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_off = `select unix_timestamp() - $s`;
let $time_elapsed_create_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_create_select seconds.;
# This check evaluates whether the time elapsed during the create select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
# Additionally, it is important to note that 1.5 is the multiplier applied to the time_elapsed_select
# value because it appears that MySQL 5.5.39 uses a sorted index scan during the create select statement
# while Percona Server 5.6 uses an unsorted index scan.
# The issue has been resolved in MySQL 5.6 but still persists in Maria 10.0.12
# in the defect found at https://mariadb.atlassian.net/browse/MDEV-6547.
let $verdict = `select abs($time_elapsed_create_select - $time_elapsed_select) <= 1.5 * $time_elapsed_select`;
# check that bulk fetch on is at least 1.5 times faster than bulk fetch off
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 1.5 * $time_elapsed_on`;
echo $verdict;
if (!$verdict) { echo range scan t2 $time_elapsed_create_select $time_elapsed_select; }
if ($debug) { echo range $verdict $time_elapsed_off $time_elapsed_on; }
if (!$verdict) { echo range $time_elapsed_off $time_elapsed_on; }
drop table t,t1,t2;
drop table t1;

167
storage/tokudb/mysql-test/tokudb/t/bf_create_select_range_part.test
View File

@@ -7,132 +7,103 @@ source include/have_partition.inc;
source include/big_test.inc;
set default_storage_engine='tokudb';
disable_warnings;
drop table if exists t,t1,t2;
drop table if exists t1,t2;
enable_warnings;
let $maxq = 10;
let $debug = 0;
CREATE TABLE `t` (
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
# put 8M rows into t
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
# Create base table (control table) from source table t
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
# Create source range partitioned table from source table t
CREATE TABLE `t2` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) PARTITION BY RANGE (num)
(PARTITION p0 VALUES LESS THAN (1000000),
PARTITION p1 VALUES LESS THAN (2000000),
PARTITION p2 VALUES LESS THAN (3000000),
PARTITION p3 VALUES LESS THAN (4000000),
PARTITION p4 VALUES LESS THAN (5000000),
PARTITION p5 VALUES LESS THAN (6000000),
PARTITION p6 VALUES LESS THAN (7000000),
PARTITION p7 VALUES LESS THAN MAXVALUE) as select * from t;
(PARTITION p0 VALUES LESS THAN (100000),
PARTITION p1 VALUES LESS THAN (200000),
PARTITION p2 VALUES LESS THAN (300000),
PARTITION p3 VALUES LESS THAN (400000),
PARTITION p4 VALUES LESS THAN (500000),
PARTITION p5 VALUES LESS THAN (600000),
PARTITION p6 VALUES LESS THAN (700000),
PARTITION p7 VALUES LESS THAN MAXVALUE);
let $s = `select to_seconds(now())`;
# put 1M rows into t1
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
let $maxq = 20;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1;
DROP TABLE t3;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
CREATE TABLE t4 AS SELECT count(*) from t2;
DROP TABLE t4;
CREATE TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_off = `select unix_timestamp() - $s`;
let $time_elapsed_create_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_create_select seconds.;
# This check evaluates whether the time elapsed during the create select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_create_select - $time_elapsed_select) <= $time_elapsed_select`;
# check that bulk fetch on is at least 2 times faster than bulk fetch off
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo index $verdict $time_elapsed_off $time_elapsed_on; }
if (!$verdict) { echo index $time_elapsed_off $time_elapsed_on; }
let $maxrq = 30;
let $maxq = 20;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
CREATE TABLE `t3` (`x` bigint);
SELECT count(*) from t1 where num > 7000000;
DROP TABLE t3;
while ($i < $maxq) {
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
CREATE TABLE t4 AS SELECT count(*) from t2 where num > 7000000;
DROP TABLE t4;
while ($i < $maxq) {
CREATE TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_off = `select unix_timestamp() - $s`;
let $time_elapsed_create_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_create_select seconds.;
# This check evaluates whether the time elapsed during the create select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_create_select - $time_elapsed_select) <= $time_elapsed_select`;
# check that bulk fetch on is at least 2 times faster than bulk fetch off
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo range $verdict $time_elapsed_off $time_elapsed_on; }
if (!$verdict) { echo range $time_elapsed_off $time_elapsed_on; }
drop table t,t1,t2;
drop table t1;

161
storage/tokudb/mysql-test/tokudb/t/bf_create_temp_select.test
View File

@@ -1,118 +1,103 @@
# Verify that index and range scans are not slow
# on temporary tables during create select statements
# on tables during create select statements
# due to tokudb bulk fetch not being used
source include/have_tokudb.inc;
source include/big_test.inc;
set default_storage_engine='tokudb';
disable_warnings;
drop table if exists t,t1,t2;
drop table if exists t1,t2;
enable_warnings;
let $maxq = 10;
let $debug = 0;
CREATE TABLE `t` (
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
# put 8M rows into t
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
# put 1M rows into t1
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
# Create first table from source table t
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
let $s = `select to_seconds(now())`;
let $i = 0;
while ($i < $maxq) {
SELECT count(*) from t1;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
let $maxq = 10;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TEMPORARY TABLE t2;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_on = `select unix_timestamp() - $s`;
let $time_elapsed_create_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_create_select seconds.;
# This check evaluates whether the time elapsed during the create select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_create_select - $time_elapsed_select) <= $time_elapsed_select`;
echo $verdict;
let $maxrq = 30;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
SELECT count(*) from t1 where num > 7000000;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Range scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
let $i = 0;
while ($i < $maxrq) {
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 7000000;
DROP TEMPORARY TABLE t2;
while ($i < $maxq) {
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_create_select = `select to_seconds(now()) - $s`;
let $time_elapsed_off = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Range scans took $time_elapsed_create_select seconds.;
# This check evaluates whether the time elapsed during the create select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_create_select - $time_elapsed_select) <= $time_elapsed_select`;
# Check that the time with bulk fetch off is at least twice that whith bulk fetch on
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo index $verdict $time_elapsed_on $time_elapsed_off; }
if (!$verdict) { echo index $time_elapsed_on $time_elapsed_off; }
drop table t,t1;
let $maxq = 30;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_on = `select unix_timestamp() - $s`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
CREATE TEMPORARY TABLE t2 AS SELECT count(*) from t1 where num > 700000;
DROP TABLE t2;
inc $i;
}
let $time_elapsed_off = `select unix_timestamp() - $s`;
# Check that the time with bulk fetch off is at least twice that whith bulk fetch on
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo range $verdict $time_elapsed_on $time_elapsed_off; }
if (!$verdict) { echo range $time_elapsed_on $time_elapsed_off; }
drop table t1;

15
storage/tokudb/mysql-test/tokudb/t/bf_delete.test
View File

@@ -8,6 +8,8 @@ disable_warnings;
drop table if exists t;
enable_warnings;
let $debug = 0;
CREATE TABLE `t` (id bigint not null auto_increment primary key, val bigint not null default 0);
# put 8M rows into t
@@ -42,27 +44,28 @@ let $maxq = 10;
# measure the time to do $maxq deletes from t that affect no rows with bulk fetch ON
set tokudb_bulk_fetch = ON;
let $s = `select to_seconds(now())`;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
delete from t where val > 0;
inc $i;
}
let $time_elapsed_bf_on = `select to_seconds(now()) - $s`;
let $time_elapsed_bf_on = `select unix_timestamp() - $s`;
# measure the time to do $maxq deletes from t that affect no rows with bulk fetch OFF
set tokudb_bulk_fetch = OFF;
let $s = `select to_seconds(now())`;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
delete from t where val > 0;
inc $i;
}
let $time_elapsed_bf_off = `select to_seconds(now()) - $s`;
let $time_elapsed_bf_off = `select unix_timestamp() - $s`;
# verify that a delete scan with bulk fetch ON is at least 2 times faster than with bulk fetch OFF
let $verdict = `select $time_elapsed_bf_off > $time_elapsed_bf_on && ($time_elapsed_bf_off - $time_elapsed_bf_on) / $time_elapsed_bf_on >= 2`;
let $verdict = `select $time_elapsed_bf_on > 0 && $time_elapsed_bf_off >= 2 * $time_elapsed_bf_on`;
echo $verdict;
if (!$verdict) { echo $time_elapsed_bf_on $time_elapsed_bf_off; }
if ($debug) { echo range $verdict $time_elapsed_bf_on $time_elapsed_bf_off; }
if (!$verdict) { echo range $time_elapsed_bf_on $time_elapsed_bf_off; }
drop table t;

140
storage/tokudb/mysql-test/tokudb/t/bf_insert_select.test
View File

@@ -6,117 +6,95 @@ source include/have_tokudb.inc;
source include/big_test.inc;
set default_storage_engine='tokudb';
disable_warnings;
drop table if exists t,t1,t2;
drop table if exists t1,t2;
enable_warnings;
let $maxq = 10;
let $debug = 0;
CREATE TABLE `t` (
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
# put 8M rows into t
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
# Create first table from source table t
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
# Create second table t2 that will serve as the target for the insert select statment
CREATE TABLE `t2` (
`count` bigint(20) NOT NULL
) ENGINE=TokuDB DEFAULT CHARSET=latin1;
);
# put 1M rows into t1
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
let $s = `select to_seconds(now())`;
let $i = 0;
while ($i < $maxq) {
SELECT count(*) from t1;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $maxq = 20;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
INSERT into t2 SELECT count(*) from t1;
inc $i;
}
let $time_elapsed_insert_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_insert_select seconds.;
# This check evaluates whether the time elapsed during the insert select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_insert_select - $time_elapsed_select) <= $time_elapsed_select`;
echo $verdict;
let $maxrq = 30;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
SELECT count(*) from t1 where num > 7000000;
while ($i < $maxq) {
INSERT into t2 SELECT count(*) from t1;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $time_elapsed_off = `select unix_timestamp() - $s`;
# This check evaluates whether the time elapsed during the insert select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
#echo Range scans took $time_elapsed_select seconds.;
# check that bulk fetch on is at least 2 times faster than bulk fetch off
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo index $verdict $time_elapsed_off $time_elapsed_on; }
if (!$verdict) { echo index $time_elapsed_off $time_elapsed_on; }
let $maxq = 20;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
INSERT into t2 SELECT count(*) from t1 where num > 7000000;
while ($i < $maxq) {
INSERT into t2 SELECT count(*) from t1 where num > 700000;
inc $i;
}
let $time_elapsed_insert_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# This check evaluates whether the time elapsed during the insert select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
#echo Range scans took $time_elapsed_insert_select seconds.;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
INSERT into t2 SELECT count(*) from t1 where num > 700000;
inc $i;
}
let $time_elapsed_off = `select unix_timestamp() - $s`;
# This check evaluates whether the time elapsed during the insert select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_insert_select - $time_elapsed_select) <= $time_elapsed_select`;
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo range $verdict $time_elapsed_off $time_elapsed_on; }
if (!$verdict) { echo range $time_elapsed_off $time_elapsed_on; }
drop table t,t1,t2;
drop table t1,t2;

142
storage/tokudb/mysql-test/tokudb/t/bf_insert_select_dup_key.test
View File

@@ -8,120 +8,98 @@ source include/have_tokudb.inc;
source include/big_test.inc;
set default_storage_engine='tokudb';
disable_warnings;
drop table if exists t,t1,t2;
drop table if exists t1,t2;
enable_warnings;
let $maxq = 10;
let $debug = 0;
CREATE TABLE `t` (
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
# put 8M rows into t
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
# Create first table from source table t
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
# put 1M rows into t1
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
# Create second table t2 that will serve as the target for the insert select statment
CREATE TABLE `t2` (
`num` int(10) unsigned auto_increment NOT NULL,
`count` bigint(20) NOT NULL,
UNIQUE (num)
) ENGINE=TokuDB DEFAULT CHARSET=latin1;
);
let $maxq = 20;
let $s = `select to_seconds(now())`;
let $i = 0;
while ($i < $maxq) {
SELECT count(*) from t1;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
inc $i;
}
let $time_elapsed_insert_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_insert_select seconds.;
# This check evaluates whether the time elapsed during the insert select on duplicate key statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_insert_select - $time_elapsed_select) <= $time_elapsed_select`;
echo $verdict;
let $maxrq = 30;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
SELECT count(*) from t1 where num > 7000000;
while ($i < $maxq) {
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 on DUPLICATE KEY UPDATE count=count+1;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $time_elapsed_off = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Range scans took $time_elapsed_select seconds.;
# check that bulk fetch on is at least 2 times faster than bulk fetch off
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo index $verdict $time_elapsed_off $time_elapsed_on; }
if (!$verdict) { echo index $time_elapsed_off $time_elapsed_on; }
let $maxq = 20;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxrq) {
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 7000000 on DUPLICATE KEY UPDATE count=count+1;
while ($i < $maxq) {
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
inc $i;
}
let $time_elapsed_insert_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Range scans took $time_elapsed_insert_select seconds.;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
INSERT into t2 (num,count) SELECT NULL,count(*) from t1 where num > 700000 on DUPLICATE KEY UPDATE count=count+1;
inc $i;
}
let $time_elapsed_off = `select unix_timestamp() - $s`;
# This check evaluates whether the time elapsed during the insert select on duplicate key statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_insert_select - $time_elapsed_select) <= $time_elapsed_select`;
# check that bulk fetch on is at least 2 times faster than bulk fetch off
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo range $verdict $time_elapsed_off $time_elapsed_on; }
if (!$verdict) { echo range $time_elapsed_off $time_elapsed_on; }
enable_warnings;
drop table t,t1,t2;
drop table t1,t2;

208
storage/tokudb/mysql-test/tokudb/t/bf_replace_select.test
View File

@@ -1,190 +1,100 @@
# Verify that index and range scans are not slow
# on tables during replace select and insert ignore statements
# on tables during replace select statements
# due to tokudb bulk fetch not being used
source include/have_tokudb.inc;
source include/big_test.inc;
set default_storage_engine='tokudb';
disable_warnings;
drop table if exists t,t1,t2;
drop table if exists t1,t2;
enable_warnings;
let $maxq = 10;
let $debug = 0;
CREATE TABLE `t` (
CREATE TABLE `t1` (
`num` int(10) unsigned auto_increment NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
);
# put 8M rows into t
INSERT INTO t values (null,null);
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
# Create first table from source table t
CREATE TABLE `t1` (
`num` int(10) unsigned NOT NULL,
`val` varchar(32) DEFAULT NULL,
PRIMARY KEY (`num`)
) as select * from t;
# Create second table t2 that will serve as the target for the replace select statment
# Create second table t2 that will serve as the target for the insert select statment
CREATE TABLE `t2` (
`count` bigint(20) NOT NULL
) ENGINE=TokuDB DEFAULT CHARSET=latin1;
);
# put 1M rows into t1
INSERT INTO t1 values (null,null);
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
INSERT INTO t1 SELECT null,val FROM t1;
SELECT count(*) FROM t1;
let $s = `select to_seconds(now())`;
let $i = 0;
while ($i < $maxq) {
SELECT count(*) from t1;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $maxq = 20;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
REPLACE into t2 SELECT count(*) from t1;
inc $i;
}
let $time_elapsed_replace_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_replace_select seconds.;
# This check evaluates whether the time elapsed during the replace select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_replace_select - $time_elapsed_select) <= $time_elapsed_select`;
echo $verdict;
##############################################################
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
let $time_elapsed_off = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_select seconds.;
# check that bulk fetch on is at least 2 times faster than bulk fetch off
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo index $verdict $time_elapsed_off $time_elapsed_on; }
if (!$verdict) { echo index $time_elapsed_off $time_elapsed_on; }
let $maxq = 20;
let $s = `select to_seconds(now())`;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
INSERT IGNORE into t2 SELECT count(*) from t1;
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
inc $i;
}
let $time_elapsed_insert_ignore_select = `select to_seconds(now()) - $s`;
let $time_elapsed_on = `select unix_timestamp() - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Index scans took $time_elapsed_insert_ignore_select seconds.;
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
while ($i < $maxq) {
REPLACE into t2 SELECT count(*) from t1 where num > 700000;
inc $i;
}
let $time_elapsed_off = `select unix_timestamp() - $s`;
# This check evaluates whether the time elapsed during the insert ignore select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_insert_ignore_select - $time_elapsed_select) <= $time_elapsed_select`;
let $verdict = `select $time_elapsed_on > 0 && $time_elapsed_off >= 2 * $time_elapsed_on`;
echo $verdict;
if ($debug) { echo range $verdict $time_elapsed_off $time_elapsed_on; }
if (!$verdict) { echo range $time_elapsed_off $time_elapsed_on; }
##################################################################
let $maxrq = 30;
let $s = `select to_seconds(now())`;
let $i = 0;
while ($i < $maxrq) {
SELECT count(*) from t1 where num > 7000000;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Range scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
let $i = 0;
while ($i < $maxrq) {
REPLACE into t2 SELECT count(*) from t1 where num > 7000000;
inc $i;
}
let $time_elapsed_replace_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Range scans took $time_elapsed_replace_select seconds.;
# This check evaluates whether the time elapsed during the replace select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_replace_select - $time_elapsed_select) <= $time_elapsed_select`;
echo $verdict;
####################################################################
let $s = `select to_seconds(now())`;
let $i = 0;
while ($i < $maxrq) {
SELECT count(*) from t1 where num > 7000000;
inc $i;
}
let $time_elapsed_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Range scans took $time_elapsed_select seconds.;
let $s = `select to_seconds(now())`;
let $i = 0;
while ($i < $maxrq) {
INSERT IGNORE into t2 SELECT count(*) from t1 where num > 7000000;
inc $i;
}
let $time_elapsed_insert_ignore_select = `select to_seconds(now()) - $s`;
# The following line can be used to display the time elapsed data
# which could be useful for debugging.
#echo Range scans took $time_elapsed_insert_ignore_select seconds.;
# This check evaluates whether the time elapsed during the insert ignore select statement is on par
# with the select statement, which will confirm that bulk fetch is in fact being used.
let $verdict = `select abs($time_elapsed_insert_ignore_select - $time_elapsed_select) <= $time_elapsed_select`;
echo $verdict;
#########################################################################
drop table t,t1,t2;
drop table t1,t2;

10
storage/tokudb/mysql-test/tokudb/t/bf_select_hash_part.test
View File

@@ -66,9 +66,10 @@ let $time_bf_off = `select unix_timestamp() - $s`;
if ($debug) { echo index scans took $time_bf_off.; }
# check that the scan time with bulk fetch off is at least 1.5 times as long as with bulk fetch on
let $verdict = `select $time_bf_off > $time_bf_on && $time_bf_off >= 1.5 * $time_bf_on`;
let $verdict = `select $time_bf_on > 0 && $time_bf_off >= 1.5 * $time_bf_on`;
echo $verdict;
if (!$verdict) { echo index scan $time_bf_on $time_bf_off; }
if ($debug) { echo index $verdict $time_bf_on $time_bf_off; }
if (!$verdict) { echo index $time_bf_on $time_bf_off; }
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
@@ -93,8 +94,9 @@ let $time_bf_off = `select unix_timestamp() - $s`;
if ($debug) { echo range scans took $time_bf_off.; }
# check that the scan time with bulk fetch off is at least 1.5 times as long as with bulk fetch on
let $verdict = `select $time_bf_off > $time_bf_on && $time_bf_off >= 1.5 * $time_bf_on`;
let $verdict = `select $time_bf_on > 0 && $time_bf_off >= 1.5 * $time_bf_on`;
echo $verdict;
if (!$verdict) { echo range scan $time_bf_on $time_bf_off; }
if ($debug) { echo range $verdict $time_bf_on $time_bf_off; }
if (!$verdict) { echo range $time_bf_on $time_bf_off; }
drop table t;

19
storage/tokudb/mysql-test/tokudb/t/bf_select_range_part.test
View File

@@ -9,7 +9,6 @@ disable_warnings;
drop table if exists t;
enable_warnings;
let $maxq = 20;
let $debug = 0;
# create the range partition table
@@ -51,6 +50,8 @@ INSERT INTO t SELECT null,val FROM t;
INSERT INTO t SELECT null,val FROM t;
SELECT count(*) FROM t;
let $maxq = 30;
set tokudb_bulk_fetch=ON;
let $s = `select unix_timestamp()`;
let $i = 0;
@@ -60,8 +61,6 @@ while ($i < $maxq) {
}
let $time_bf_on = `select unix_timestamp() - $s`;
if ($debug) { echo index scans took $time_bf_on; }
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
@@ -71,11 +70,10 @@ while ($i < $maxq) {
}
let $time_bf_off = `select unix_timestamp() - $s`;
if ($debug) { echo index scans took $time_bf_off.; }
# check that the scan time with bulk fetch off is at least 1.5 times as long as with bulk fetch on
let $verdict = `select $time_bf_off > $time_bf_on && $time_bf_off >= 1.5 * $time_bf_on`;
let $verdict = `select $time_bf_on > 0 && $time_bf_off >= 1.5 * $time_bf_on`;
echo $verdict;
if ($debug) { echo index $verdict $time_bf_on $time_bf_off; }
if (!$verdict) { echo index scan $time_bf_on $time_bf_off; }
set tokudb_bulk_fetch=ON;
@@ -87,8 +85,6 @@ while ($i < $maxq) {
}
let $time_bf_on = `select unix_timestamp() - $s`;
if ($debug) { echo range scans took $time_bf_on; }
set tokudb_bulk_fetch=OFF;
let $s = `select unix_timestamp()`;
let $i = 0;
@@ -98,11 +94,10 @@ while ($i < $maxq) {
}
let $time_bf_off = `select unix_timestamp() - $s`;
if ($debug) { echo range scans took $time_bf_off.; }
# check that the scan time with bulk fetch off is at least 1.5 times as long as with bulk fetch on
let $verdict = `select $time_bf_off > $time_bf_on && $time_bf_off >= 1.5 * $time_bf_on`;
let $verdict = `select $time_bf_on > 0 && $time_bf_off >= 1.5 * $time_bf_on`;
echo $verdict;
if (!$verdict) { echo range scan $time_bf_on $time_bf_off; }
if ($debug) { echo range $verdict $time_bf_on $time_bf_off; }
if (!$verdict) { echo range $time_bf_on $time_bf_off; }
drop table t;

57
storage/tokudb/mysql-test/tokudb_bugs/r/db397_delete_trigger.result Normal file
View File

@@ -0,0 +1,57 @@
set default_storage_engine='tokudb';
drop table if exists t1;
drop table if exists t1_audit;
create table t1 (
col1 int not null,
col2 int not null,
primary key (col1));
create table t1_audit (
col1 int not null,
action varchar(10) not null,
ts timestamp not null default now());
insert into t1 (col1,col2) values (0,0);
insert into t1_audit (col1,action) values (0,'DUMMY');
set local tokudb_prelock_empty=0;
create trigger t1_trigger before delete on t1
for each row
insert into t1_audit (col1, action) values (old.col1, 'BEFORE DELETE');
insert into t1 (col1,col2) values (1,1);
start transaction;
delete from t1 where col1 = 1;
select col1,col2 from t1;
col1 col2
0 0
select col1,action from t1_audit;
col1 action
0 DUMMY
1 BEFORE DEL
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
locks_dname locks_key_left locks_key_right
./test/t1_audit-main 0200000000000000 0200000000000000
./test/t1-main ff01000000 0101000000
./test/t1-main 0001000000 0001000000
commit;
drop trigger t1_trigger;
create trigger t1_trigger after delete on t1
for each row
insert into t1_audit (col1, action) values (old.col1, 'AFTER DELETE');
insert into t1 (col1,col2) values (2,2);
start transaction;
delete from t1 where col1 = 2;
select col1,col2 from t1;
col1 col2
0 0
select col1,action from t1_audit;
col1 action
0 DUMMY
1 BEFORE DEL
2 AFTER DELE
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
locks_dname locks_key_left locks_key_right
./test/t1_audit-main 0300000000000000 0300000000000000
./test/t1-main ff02000000 0102000000
./test/t1-main 0002000000 0002000000
commit;
drop trigger t1_trigger;
drop table t1;
drop table t1_audit;

56
storage/tokudb/mysql-test/tokudb_bugs/r/db397_insert_trigger.result Normal file
View File

@@ -0,0 +1,56 @@
set default_storage_engine='tokudb';
drop table if exists t1;
drop table if exists t1_audit;
create table t1 (
col1 int not null,
col2 int not null,
primary key (col1));
create table t1_audit (
col1 int not null,
action varchar(32) not null,
ts timestamp not null default now());
insert into t1 (col1,col2) values (0,0);
insert into t1_audit (col1,action) values (0,'DUMMY');
set local tokudb_prelock_empty=0;
create trigger t1_trigger before insert on t1
for each row
insert into t1_audit (col1, action) values (new.col1, 'BEFORE INSERT');
start transaction;
insert into t1 (col1, col2) values (1,1);
select col1,col2 from t1;
col1 col2
0 0
1 1
select col1,action from t1_audit;
col1 action
0 DUMMY
1 BEFORE INSERT
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
locks_dname locks_key_left locks_key_right
./test/t1_audit-main 0200000000000000 0200000000000000
./test/t1-main 0001000000 0001000000
commit;
drop trigger t1_trigger;
create trigger t1_trigger after insert on t1
for each row
insert into t1_audit (col1, action) values (new.col1, 'AFTER INSERT');
start transaction;
insert into t1 (col1, col2) values (2,2);
select col1,col2 from t1;
col1 col2
0 0
1 1
2 2
select col1,action from t1_audit;
col1 action
0 DUMMY
1 BEFORE INSERT
2 AFTER INSERT
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
locks_dname locks_key_left locks_key_right
./test/t1_audit-main 0300000000000000 0300000000000000
./test/t1-main 0002000000 0002000000
commit;
drop trigger t1_trigger;
drop table t1;
drop table t1_audit;

58
storage/tokudb/mysql-test/tokudb_bugs/r/db397_update_trigger.result Normal file
View File

@@ -0,0 +1,58 @@
set default_storage_engine='tokudb';
drop table if exists t1, t1_audit;
create table t1 (
col1 int not null,
col2 int not null,
primary key (col1));
create table t1_audit (
col1 int not null,
action varchar(32) not null,
ts timestamp not null default now());
insert into t1 (col1,col2) values (0,0);
insert into t1_audit (col1,action) values (0,'DUMMY');
set local tokudb_prelock_empty=0;
create trigger t1_trigger before update on t1
for each row
insert into t1_audit (col1, action) values (old.col1, 'BEFORE UPDATE');
insert into t1 (col1,col2) values (1,1);
start transaction;
update t1 set col2=1000 where col1 = 1;
select col1,col2 from t1;
col1 col2
0 0
1 1000
select col1,action from t1_audit;
col1 action
0 DUMMY
1 BEFORE UPDATE
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
locks_dname locks_key_left locks_key_right
./test/t1_audit-main 0200000000000000 0200000000000000
./test/t1-main ff01000000 0101000000
./test/t1-main 0001000000 0001000000
commit;
drop trigger t1_trigger;
create trigger t1_trigger after update on t1
for each row
insert into t1_audit (col1, action) values (old.col1, 'AFTER UPDATE');
insert into t1 (col1,col2) values (2,2);
start transaction;
update t1 set col2=1001 where col1 = 2;
select col1,col2 from t1;
col1 col2
0 0
1 1000
2 1001
select col1,action from t1_audit;
col1 action
0 DUMMY
1 BEFORE UPDATE
2 AFTER UPDATE
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
locks_dname locks_key_left locks_key_right
./test/t1_audit-main 0300000000000000 0300000000000000
./test/t1-main ff02000000 0102000000
./test/t1-main 0002000000 0002000000
commit;
drop trigger t1_trigger;
drop table t1, t1_audit;

100013
storage/tokudb/mysql-test/tokudb_bugs/r/db739_insert.result Normal file
View File

File diff suppressed because it is too large Load Diff

100014
storage/tokudb/mysql-test/tokudb_bugs/r/db739_replace.result Normal file
View File

File diff suppressed because it is too large Load Diff

100013
storage/tokudb/mysql-test/tokudb_bugs/r/db739_upsert.result Normal file
View File

File diff suppressed because it is too large Load Diff

13
storage/tokudb/mysql-test/tokudb_bugs/r/db743.result Normal file
View File

@@ -0,0 +1,13 @@
drop table if exists t1,t2;
CREATE TABLE t1(`a` INT) ENGINE=TokuDB;
CREATE TABLE t2(`a` INT) ENGINE=InnoDB;
begin;
insert into t1 values (0);
insert into t2 values (0);
commit;
begin;
insert into t1 values (1);
insert into t2 values (1);
commit;
include/diff_tables.inc [test.t1, test.t2]
drop table t1,t2;

2
storage/tokudb/mysql-test/tokudb_bugs/r/tokudb718.result
View File

@@ -4,6 +4,6 @@ create table t (id int primary key);
begin;
insert into t values (1),(2);
select * from information_schema.tokudb_fractal_tree_info;
ERROR HY000: Unknown error -30994
ERROR HY000: Got error -30994 "Internal error < 0 (Not system error)" from storage engine TokuDB
commit;
drop table t;

50
storage/tokudb/mysql-test/tokudb_bugs/t/db397_delete_trigger.test Normal file
View File

@@ -0,0 +1,50 @@
# check for any locking weirdness on DELETE triggers
source include/have_tokudb.inc;
set default_storage_engine='tokudb';
disable_warnings;
drop table if exists t1;
drop table if exists t1_audit;
enable_warnings;
create table t1 (
col1 int not null,
col2 int not null,
primary key (col1));
create table t1_audit (
col1 int not null,
action varchar(10) not null,
ts timestamp not null default now());
insert into t1 (col1,col2) values (0,0);
insert into t1_audit (col1,action) values (0,'DUMMY');
set local tokudb_prelock_empty=0;
create trigger t1_trigger before delete on t1
for each row
insert into t1_audit (col1, action) values (old.col1, 'BEFORE DELETE');
insert into t1 (col1,col2) values (1,1);
start transaction;
delete from t1 where col1 = 1;
select col1,col2 from t1;
select col1,action from t1_audit;
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
# note the locks on t1 and t1_audit
commit;
drop trigger t1_trigger;
create trigger t1_trigger after delete on t1
for each row
insert into t1_audit (col1, action) values (old.col1, 'AFTER DELETE');
insert into t1 (col1,col2) values (2,2);
start transaction;
delete from t1 where col1 = 2;
select col1,col2 from t1;
select col1,action from t1_audit;
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
# note the locks on t1 and t1_audit
commit;
drop trigger t1_trigger;
drop table t1;
drop table t1_audit;

48
storage/tokudb/mysql-test/tokudb_bugs/t/db397_insert_trigger.test Normal file
View File

@@ -0,0 +1,48 @@
# check for any locking weirdness on INSERT triggers
source include/have_tokudb.inc;
set default_storage_engine='tokudb';
disable_warnings;
drop table if exists t1;
drop table if exists t1_audit;
enable_warnings;
create table t1 (
col1 int not null,
col2 int not null,
primary key (col1));
create table t1_audit (
col1 int not null,
action varchar(32) not null,
ts timestamp not null default now());
insert into t1 (col1,col2) values (0,0);
insert into t1_audit (col1,action) values (0,'DUMMY');
set local tokudb_prelock_empty=0;
create trigger t1_trigger before insert on t1
for each row
insert into t1_audit (col1, action) values (new.col1, 'BEFORE INSERT');
start transaction;
insert into t1 (col1, col2) values (1,1);
select col1,col2 from t1;
select col1,action from t1_audit;
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
# note the locks on t1 and t1_audit
commit;
drop trigger t1_trigger;
create trigger t1_trigger after insert on t1
for each row
insert into t1_audit (col1, action) values (new.col1, 'AFTER INSERT');
start transaction;
insert into t1 (col1, col2) values (2,2);
select col1,col2 from t1;
select col1,action from t1_audit;
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
# note the locks on t1 and t1_audit
commit;
drop trigger t1_trigger;
drop table t1;
drop table t1_audit;

52
storage/tokudb/mysql-test/tokudb_bugs/t/db397_update_trigger.test Normal file
View File

@@ -0,0 +1,52 @@
# check for any locking weirdness on UPDATE triggers
source include/have_tokudb.inc;
set default_storage_engine='tokudb';
disable_warnings;
drop table if exists t1, t1_audit;
enable_warnings;
create table t1 (
col1 int not null,
col2 int not null,
primary key (col1));
create table t1_audit (
col1 int not null,
action varchar(32) not null,
ts timestamp not null default now());
insert into t1 (col1,col2) values (0,0);
insert into t1_audit (col1,action) values (0,'DUMMY');
set local tokudb_prelock_empty=0;
# test before update trigger
create trigger t1_trigger before update on t1
for each row
insert into t1_audit (col1, action) values (old.col1, 'BEFORE UPDATE');
insert into t1 (col1,col2) values (1,1);
start transaction;
update t1 set col2=1000 where col1 = 1;
select col1,col2 from t1;
select col1,action from t1_audit;
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
# check locks on t1 and t1_audit
commit;
drop trigger t1_trigger;
# test after update trigger
create trigger t1_trigger after update on t1
for each row
insert into t1_audit (col1, action) values (old.col1, 'AFTER UPDATE');
insert into t1 (col1,col2) values (2,2);
start transaction;
update t1 set col2=1001 where col1 = 2;
select col1,col2 from t1;
select col1,action from t1_audit;
select locks_dname,locks_key_left,locks_key_right from information_schema.tokudb_locks;
# check locks on t1 and t1_audit
commit;
drop trigger t1_trigger;
# cleanup
drop table t1, t1_audit;

28
storage/tokudb/mysql-test/tokudb_bugs/t/db739_insert.test Normal file
View File

@@ -0,0 +1,28 @@
source include/have_tokudb.inc;
set default_storage_engine=tokudb;
disable_warnings;
drop table if exists t;
enable_warnings;
create table t (
id bigint not null,
a bigint not null default 0,
b bigint not null default 0,
c bigint not null default 0,
primary key(id, a)
);
set tokudb_commit_sync=0;
let $id=0;
while ($id < 1000) {
let $a=0;
while ($a < 100) {
eval insert into t (id,a) values ($id,$a);
inc $a;
}
inc $id;
}
delete from t where id=404;
insert into t values (404,0,0,0);
drop table t;

29
storage/tokudb/mysql-test/tokudb_bugs/t/db739_replace.test Normal file
View File

@@ -0,0 +1,29 @@
source include/have_tokudb.inc;
set default_storage_engine=tokudb;
disable_warnings;
drop table if exists t;
enable_warnings;
create table t (
id bigint not null,
a bigint not null default 0,
b bigint not null default 0,
c bigint not null default 0,
primary key(id, a)
);
set tokudb_commit_sync=0;
let $id=0;
while ($id < 1000) {
let $a=0;
while ($a < 100) {
eval insert into t (id,a) values ($id,$a);
inc $a;
}
inc $id;
}
delete from t where id=404;
set tokudb_pk_insert_mode=2;
replace into t values (404,0,0,0);
drop table t;

28
storage/tokudb/mysql-test/tokudb_bugs/t/db739_upsert.test Normal file
View File

@@ -0,0 +1,28 @@
source include/have_tokudb.inc;
set default_storage_engine=tokudb;
disable_warnings;
drop table if exists t;
enable_warnings;
create table t (
id bigint not null,
a bigint not null default 0,
b bigint not null default 0,
c bigint not null default 0,
primary key(id, a)
);
set tokudb_commit_sync=0;
let $id=0;
while ($id < 1000) {
let $a=0;
while ($a < 100) {
eval insert into t (id,a) values ($id,$a);
inc $a;
}
inc $id;
}
delete from t where id=404;
insert into t values (404,0,0,0) on duplicate key update b=b+1;
drop table t;

23
storage/tokudb/mysql-test/tokudb_bugs/t/db743.test Normal file
View File

@@ -0,0 +1,23 @@
source include/have_tokudb.inc;
source include/have_innodb.inc;
disable_warnings;
drop table if exists t1,t2;
enable_warnings;
CREATE TABLE t1(`a` INT) ENGINE=TokuDB;
CREATE TABLE t2(`a` INT) ENGINE=InnoDB;
let $n=0;
while ($n < 2) {
begin;
eval insert into t1 values ($n);
eval insert into t2 values ($n);
commit;
inc $n;
}
let $diff_tables= test.t1, test.t2;
source include/diff_tables.inc;
drop table t1,t2;

2
storage/tokudb/mysql-test/tokudb_bugs/t/tokudb718.test
View File

@@ -7,7 +7,7 @@ enable_warnings;
create table t (id int primary key);
begin;
insert into t values (1),(2);
--error 34542
--error 1030
select * from information_schema.tokudb_fractal_tree_info;
commit;
drop table t;