^^&&^^

Edit File: innodb_16k.test

#Want to skip this test from daily Valgrind execution
--source include/no_valgrind_without_big.inc
# Tests for setting innodb-page-size=16k; default value

--source include/have_innodb.inc
--source include/have_innodb_16k.inc
SET default_storage_engine=InnoDB;

--disable_query_log
let $MYSQLD_DATADIR= `select @@datadir`;

# These values can change during the test
let $innodb_file_format_orig = `SELECT @@innodb_file_format`;
let $innodb_file_format_max_orig = `SELECT @@innodb_file_format_max`;
let $innodb_file_per_table_orig = `SELECT @@innodb_file_per_table`;
let $innodb_large_prefix_orig = `SELECT @@innodb_large_prefix`;
let $innodb_strict_mode_orig = `SELECT @@session.innodb_strict_mode`;
--enable_query_log

SET GLOBAL innodb_file_format = `Barracuda`;
SET GLOBAL innodb_file_per_table = ON;

--echo # Test 1) Show the page size from Information Schema
SELECT variable_value FROM information_schema.global_status
       WHERE LOWER(variable_name) = 'innodb_page_size';

--echo # Test 2) The number of buffer pool pages is dependent upon the page size.
--replace_result 511 {511_or_512} 512 {511_or_512}
SELECT variable_value FROM information_schema.global_status
       WHERE LOWER(variable_name) = 'innodb_buffer_pool_pages_total';

--echo # Test 3) Query some information_shema tables that are dependent upon
--echo #         the page size.
# Pulled from innodb-system-table-view.test
# The IDs of mysql.innodb_table_stats and mysql.innodb_index_stats are
# unpredictable, probably they on whether mtr has created the database for
# this test from scratch or is using a previously created database where
# those tables have been dropped and recreated. If we can force mtr to
# use a freshly created database for this test then the following
# complications can be removed and the test be reverted to the version
# it was before the patch that adds this comment.
--disable_query_log
--let table_stats_id = `SELECT table_id FROM information_schema.innodb_sys_tables WHERE name = 'mysql/innodb_table_stats'`
--let index_stats_id = `SELECT table_id FROM information_schema.innodb_sys_tables WHERE name = 'mysql/innodb_index_stats'`
--let $rep_table_1 = `SELECT table_id FROM information_schema.innodb_sys_tables WHERE name = 'mysql/slave_master_info'`
--let $rep_table_2 = `SELECT table_id FROM information_schema.innodb_sys_tables WHERE name = 'mysql/slave_relay_log_info'`
--let $rep_table_3 = `SELECT table_id FROM information_schema.innodb_sys_tables WHERE name = 'mysql/slave_worker_info'`
--eval SELECT * FROM INFORMATION_SCHEMA.INNODB_SYS_INDEXES WHERE table_id NOT IN ($table_stats_id, $index_stats_id, $rep_table_1, $rep_table_2, $rep_table_3)
--enable_query_log
CREATE TABLE t1 (a INT KEY, b TEXT) ROW_FORMAT=REDUNDANT ENGINE=innodb;
CREATE TABLE t2 (a INT KEY, b TEXT) ROW_FORMAT=COMPACT ENGINE=innodb;
CREATE TABLE t3 (a INT KEY, b TEXT) ROW_FORMAT=COMPRESSED ENGINE=innodb;
CREATE TABLE t4 (a INT KEY, b TEXT) ROW_FORMAT=DYNAMIC ENGINE=innodb;
--replace_column 1 {id} 5 {id}
SELECT * FROM INFORMATION_SCHEMA.INNODB_SYS_TABLES
       WHERE name LIKE 'test%' ORDER BY table_id;
--replace_column 1 {id}
SELECT * FROM INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES
       WHERE name LIKE 'test%' ORDER BY space;
--replace_column 1 {id}
--replace_result  ./ MYSQLD_DATADIR/  $MYSQLD_DATADIR MYSQLD_DATADIR
SELECT * FROM INFORMATION_SCHEMA.INNODB_SYS_DATAFILES
       WHERE path LIKE '%test%' ORDER BY space;
DROP TABLE t1, t2, t3, t4;

--echo # Test 4) The maximum row size is dependent upon the page size.
--echo #         Redundant: 8123, Compact: 8126.
--echo #         Compressed: 8126, Dynamic: 8126.
--echo #         Each row format has its own amount of overhead that
--echo #         varies depending on number of fields and other overhead.

SET SESSION innodb_strict_mode = ON;

# Redundant table; 8011 bytes with 40 char fields
CREATE TABLE t1 (
c01 char(200), c02 char(200), c03 char(200), c04 char(200), c05 char(200),
c06 char(200), c07 char(200), c08 char(200), c09 char(200), c10 char(200),
c11 char(200), c12 char(200), c13 char(200), c14 char(200), c15 char(200),
c16 char(200), c17 char(200), c18 char(200), c19 char(200), c20 char(200),
c21 char(200), c22 char(200), c23 char(200), c24 char(200), c25 char(200),
c26 char(200), c27 char(200), c28 char(200), c29 char(200), c30 char(200),
c31 char(200), c32 char(200), c33 char(200), c34 char(200), c35 char(200),
c36 char(200), c37 char(200), c38 char(200), c39 char(200), c40 char(211)
) ROW_FORMAT=redundant;
DROP TABLE t1;
--error ER_TOO_BIG_ROWSIZE
CREATE TABLE t1 (
c01 char(200), c02 char(200), c03 char(200), c04 char(200), c05 char(200),
c06 char(200), c07 char(200), c08 char(200), c09 char(200), c10 char(200),
c11 char(200), c12 char(200), c13 char(200), c14 char(200), c15 char(200),
c16 char(200), c17 char(200), c18 char(200), c19 char(200), c20 char(200),
c21 char(200), c22 char(200), c23 char(200), c24 char(200), c25 char(200),
c26 char(200), c27 char(200), c28 char(200), c29 char(200), c30 char(200),
c31 char(200), c32 char(200), c33 char(200), c34 char(200), c35 char(200),
c36 char(200), c37 char(200), c38 char(200), c39 char(200), c40 char(212)
) ROW_FORMAT=redundant;

# Compact table; 8096 bytes with 40 CHAR fields
CREATE TABLE t1 (
c01 char(200), c02 char(200), c03 char(200), c04 char(200), c05 char(200),
c06 char(200), c07 char(200), c08 char(200), c09 char(200), c10 char(200),
c11 char(200), c12 char(200), c13 char(200), c14 char(200), c15 char(200),
c16 char(200), c17 char(200), c18 char(200), c19 char(200), c20 char(200),
c21 char(200), c22 char(200), c23 char(200), c24 char(200), c25 char(200),
c26 char(200), c27 char(200), c28 char(200), c29 char(200), c30 char(200),
c31 char(200), c32 char(200), c33 char(200), c34 char(200), c35 char(200),
c36 char(200), c37 char(200), c38 char(200), c39 char(250), c40 char(246)
) ROW_FORMAT=compact;
DROP TABLE t1;
--error ER_TOO_BIG_ROWSIZE
CREATE TABLE t1 (
c01 char(200), c02 char(200), c03 char(200), c04 char(200), c05 char(200),
c06 char(200), c07 char(200), c08 char(200), c09 char(200), c10 char(200),
c11 char(200), c12 char(200), c13 char(200), c14 char(200), c15 char(200),
c16 char(200), c17 char(200), c18 char(200), c19 char(200), c20 char(200),
c21 char(200), c22 char(200), c23 char(200), c24 char(200), c25 char(200),
c26 char(200), c27 char(200), c28 char(200), c29 char(200), c30 char(200),
c31 char(200), c32 char(200), c33 char(200), c34 char(200), c35 char(200),
c36 char(200), c37 char(200), c38 char(200), c39 char(250), c40 char(247)
) ROW_FORMAT=compact;

# Compressed table; 7959 bytes with 40 CHAR fields
# Bug#13391353 Limit is 7957 on 32-Linux only
CREATE TABLE t1 (
c01 char(200), c02 char(200), c03 char(200), c04 char(200), c05 char(200),
c06 char(200), c07 char(200), c08 char(200), c09 char(200), c10 char(200),
c11 char(200), c12 char(200), c13 char(200), c14 char(200), c15 char(200),
c16 char(200), c17 char(200), c18 char(200), c19 char(200), c20 char(200),
c21 char(200), c22 char(200), c23 char(200), c24 char(200), c25 char(200),
c26 char(200), c27 char(200), c28 char(200), c29 char(200), c30 char(200),
c31 char(200), c32 char(200), c33 char(200), c34 char(200), c35 char(200),
c36 char(200), c37 char(200), c38 char(200), c39 char(200), c40 char(157)
) ROW_FORMAT=compressed;
DROP TABLE t1;
--error ER_TOO_BIG_ROWSIZE
CREATE TABLE t1 (
c01 char(200), c02 char(200), c03 char(200), c04 char(200), c05 char(200),
c06 char(200), c07 char(200), c08 char(200), c09 char(200), c10 char(200),
c11 char(200), c12 char(200), c13 char(200), c14 char(200), c15 char(200),
c16 char(200), c17 char(200), c18 char(200), c19 char(200), c20 char(200),
c21 char(200), c22 char(200), c23 char(200), c24 char(200), c25 char(200),
c26 char(200), c27 char(200), c28 char(200), c29 char(200), c30 char(200),
c31 char(200), c32 char(200), c33 char(200), c34 char(200), c35 char(200),
c36 char(200), c37 char(200), c38 char(200), c39 char(200), c40 char(160)
) ROW_FORMAT=compressed;

# Dynamic table; 8096 bytes with 40 CHAR fields
CREATE TABLE t1 (
c01 char(200), c02 char(200), c03 char(200), c04 char(200), c05 char(200),
c06 char(200), c07 char(200), c08 char(200), c09 char(200), c10 char(200),
c11 char(200), c12 char(200), c13 char(200), c14 char(200), c15 char(200),
c16 char(200), c17 char(200), c18 char(200), c19 char(200), c20 char(200),
c21 char(200), c22 char(200), c23 char(200), c24 char(200), c25 char(200),
c26 char(200), c27 char(200), c28 char(200), c29 char(200), c30 char(200),
c31 char(200), c32 char(200), c33 char(200), c34 char(200), c35 char(200),
c36 char(200), c37 char(200), c38 char(200), c39 char(250), c40 char(246)
) ROW_FORMAT=dynamic;
DROP TABLE t1;
--error ER_TOO_BIG_ROWSIZE
CREATE TABLE t1 (
c01 char(200), c02 char(200), c03 char(200), c04 char(200), c05 char(200),
c06 char(200), c07 char(200), c08 char(200), c09 char(200), c10 char(200),
c11 char(200), c12 char(200), c13 char(200), c14 char(200), c15 char(200),
c16 char(200), c17 char(200), c18 char(200), c19 char(200), c20 char(200),
c21 char(200), c22 char(200), c23 char(200), c24 char(200), c25 char(200),
c26 char(200), c27 char(200), c28 char(200), c29 char(200), c30 char(200),
c31 char(200), c32 char(200), c33 char(200), c34 char(200), c35 char(200),
c36 char(200), c37 char(200), c38 char(200), c39 char(250), c40 char(247)
) ROW_FORMAT=dynamic;

#
# Test the maximum key length
# Moved from innodb-index.test since each page size has its own max key length.
# Max Key Length is 3072 for 16k pages.
# Max key Part length is 767
# InnoDB assumes 3 bytes for each UTF8 character.
#
CREATE TABLE t1 (a varchar(255) character set utf8,
                 b varchar(255) character set utf8,
                 c varchar(255) character set utf8,
                 d varchar(255) character set utf8,
                 e varchar(4) character set utf8,
                 PRIMARY KEY (a,b,c,d,e))
		 ENGINE=innodb;
DROP TABLE t1;
--error ER_TOO_LONG_KEY
CREATE TABLE t1 (a varchar(255) character set utf8,
                 b varchar(255) character set utf8,
                 c varchar(255) character set utf8,
                 d varchar(255) character set utf8,
                 e varchar(5) character set utf8,
                 PRIMARY KEY (a,b,c,d,e))
		 ENGINE=innodb;
CREATE TABLE t1 (a varchar(255) character set utf8,
                 b varchar(255) character set utf8,
                 c varchar(255) character set utf8,
                 d varchar(255) character set utf8,
                 e varchar(255) character set utf8,
                 f varchar(4)   character set utf8,
                 PRIMARY KEY (a), KEY (b,c,d,e,f))
		 ENGINE=innodb;
DROP TABLE t1;
--error ER_TOO_LONG_KEY
CREATE TABLE t1 (a varchar(255) character set utf8,
                 b varchar(255) character set utf8,
                 c varchar(255) character set utf8,
                 d varchar(255) character set utf8,
                 e varchar(255) character set utf8,
                 f varchar(5)   character set utf8,
                 PRIMARY KEY (a), KEY (b,c,d,e,f))
		 ENGINE=innodb;

--echo # Test 5) Make sure that KEY_BLOCK_SIZE=16, 8, 4, 2 & 1
--echo #         are all accepted.

SET SESSION innodb_strict_mode = ON;

CREATE TABLE t1 (i int) ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=16;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';

ALTER TABLE t1 KEY_BLOCK_SIZE=8;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';

ALTER TABLE t1 KEY_BLOCK_SIZE=4;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';

ALTER TABLE t1 KEY_BLOCK_SIZE=2;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';

ALTER TABLE t1 KEY_BLOCK_SIZE=1;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';

ALTER TABLE t1 KEY_BLOCK_SIZE=0;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';
DROP TABLE t1;

SET SESSION innodb_strict_mode = OFF;

CREATE TABLE t1 (i int) ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=16;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';

ALTER TABLE t1 KEY_BLOCK_SIZE=8;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';

ALTER TABLE t1 KEY_BLOCK_SIZE=4;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';

ALTER TABLE t1 KEY_BLOCK_SIZE=2;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';

ALTER TABLE t1 KEY_BLOCK_SIZE=1;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';

ALTER TABLE t1 KEY_BLOCK_SIZE=0;
SHOW WARNINGS;
SELECT table_name, row_format, create_options
   FROM information_schema.tables WHERE table_name = 't1';
DROP TABLE t1;

--echo # Test 6) Make sure that KEY_BLOCK_SIZE = 8 and 16
--echo # are rejected when innodb_file_per_table=OFF
# Moved from innodb-zip.test
SET SESSION innodb_strict_mode = ON;
SET GLOBAL innodb_file_per_table = OFF;
SHOW VARIABLES LIKE 'innodb_file_per_table';
--error ER_ILLEGAL_HA
CREATE TABLE t4 (id int PRIMARY KEY) ENGINE=innodb KEY_BLOCK_SIZE=8;
SHOW WARNINGS;
--error ER_ILLEGAL_HA
CREATE TABLE t5 (id int PRIMARY KEY) ENGINE=innodb KEY_BLOCK_SIZE=16;
SHOW WARNINGS;
SET GLOBAL innodb_file_per_table = ON;
SET GLOBAL innodb_file_format = `Antelope`;
SHOW VARIABLES LIKE 'innodb_file%';
--error ER_ILLEGAL_HA
CREATE TABLE t4 (id int PRIMARY KEY) ENGINE=innodb KEY_BLOCK_SIZE=8;
SHOW WARNINGS;
--error ER_ILLEGAL_HA
CREATE TABLE t5 (id int PRIMARY KEY) ENGINE=innodb KEY_BLOCK_SIZE=16;
SHOW WARNINGS;
SET GLOBAL innodb_file_format = `Barracuda`;

--echo # Test 7) This series of tests were moved from innodb-index to here
--echo # because the second alter table t1 assumes a 16k page size.
--echo # Moving the test allows the rest of innodb-index to be run on all
--echo # page sizes.  The previously disabled portions of this test were
--echo # moved as well.

CREATE TABLE t2(d varchar(17) PRIMARY KEY) ENGINE=innodb DEFAULT CHARSET=utf8;
CREATE TABLE t3(a int PRIMARY KEY) ENGINE=innodb;

INSERT INTO t3 VALUES (22),(44),(33),(55),(66);

INSERT INTO t2 VALUES ('jejdkrun87'),('adfd72nh9k'),
('adfdpplkeock'),('adfdijnmnb78k'),('adfdijn0loKNHJik');

CREATE TABLE t1(a int, b blob, c text, d text NOT NULL)
ENGINE=innodb DEFAULT CHARSET=utf8 STATS_PERSISTENT=0;

INSERT INTO t1
SELECT a,LEFT(REPEAT(d,100*a),65535),REPEAT(d,20*a),d FROM t2,t3 order by a, d;
DROP TABLE t2, t3;
SELECT COUNT(*) FROM t1 WHERE a=44;
SELECT a,
LENGTH(b),b=LEFT(REPEAT(d,100*a),65535),LENGTH(c),c=REPEAT(d,20*a),d FROM t1;
# in-place alter table should trigger ER_PRIMARY_CANT_HAVE_NULL
--error ER_DUP_ENTRY
ALTER TABLE t1 ADD PRIMARY KEY (a), ADD KEY (b(20));
DELETE FROM t1 WHERE d='null';
--error ER_DUP_ENTRY
ALTER TABLE t1 ADD PRIMARY KEY (a), ADD KEY (b(20));
DELETE FROM t1 WHERE a%2;
CHECK TABLE t1;
# NULL -> NOT NULL only allowed INPLACE if strict sql_mode is on.
# And adding a PRIMARY KEY will also add NOT NULL implicitly!
SET @old_sql_mode = @@sql_mode;
SET @@sql_mode = 'STRICT_TRANS_TABLES';
ALTER TABLE t1 ADD PRIMARY KEY (a,b(255),c(255)), ADD KEY (b(767));
SET @@sql_mode = @old_sql_mode;
SELECT COUNT(*) FROM t1 WHERE a=44;
SELECT a,
LENGTH(b), b=LEFT(REPEAT(d,100*a), 65535),LENGTH(c), c=REPEAT(d,20*a), d FROM t1;
SHOW CREATE TABLE t1;
CHECK TABLE t1;
EXPLAIN SELECT * FROM t1 WHERE b LIKE 'adfd%';

# The following tests are disabled because of the introduced timeouts for
# metadata locks at the MySQL level as part of the fix for
# Bug#45225 Locking: hang if drop table with no timeout
# The following commands now play with MySQL metadata locks instead of
# InnoDB locks
# start disabled45225_1
##
## Test locking
##
#
#CREATE TABLE t2(a int, b varchar(255), PRIMARY KEY(a,b)) ENGINE=innodb;
#INSERT INTO t2 SELECT a,LEFT(b,255) FROM t1;
#DROP TABLE t1;
#RENAME TABLE t2 to t1;
#
#connect (a,localhost,root,,);
#connect (b,localhost,root,,);
#connection a;
#SET innodb_lock_wait_timeout=1;
#begin;
## Obtain an IX lock on the table
#SELECT a FROM t1 limit 1 FOR UPDATE;
#connection b;
#SET innodb_lock_wait_timeout=1;
## This would require an S lock on the table, conflicting with the IX lock.
#--error ER_LOCK_WAIT_TIMEOUT
#CREATE INDEX t1ba ON t1 (b,a);
#connection a;
#commit;
#begin;
## Obtain an IS lock on the table
#SELECT a FROM t1 limit 1 lock in share mode;
#connection b;
## This will require an S lock on the table.  No conflict with the IS lock.
#CREATE INDEX t1ba ON t1 (b,a);
## This would require an X lock on the table, conflicting with the IS lock.
#--error ER_LOCK_WAIT_TIMEOUT
#DROP INDEX t1ba ON t1;
#connection a;
#commit;
#EXPLAIN SELECT a FROM t1 ORDER BY b;
#--send
#SELECT a,sleep(2+a/100) FROM t1 ORDER BY b limit 3;
#
## The following DROP INDEX will succeed, altough the SELECT above has
## opened a read view.  However, during the execution of the SELECT,
## MySQL should hold a table lock that should block the execution
## of the DROP INDEX below.
#
#connection b;
#SELECT sleep(1);
#DROP INDEX t1ba ON t1;
#
## After the index was dropped, subsequent SELECTs will use the same
## read view, but they should not be accessing the dropped index any more.
#
#connection a;
#reap;
#EXPLAIN SELECT a FROM t1 ORDER BY b;
#SELECT a FROM t1 ORDER BY b limit 3;
#commit;
#
#connection default;
#disconnect a;
#disconnect b;
#
# end disabled45225_1
DROP TABLE t1;

--echo # Test 8) Test creating a table that could lead to undo log overflow.
CREATE TABLE t1(a blob,b blob,c blob,d blob,e blob,f blob,g blob,
                h blob,i blob,j blob,k blob,l blob,m blob,n blob,
		o blob,p blob,q blob,r blob,s blob,t blob,u blob)
		ENGINE=InnoDB ROW_FORMAT=dynamic;
SET @a = repeat('a', 767);
SET @b = repeat('b', 767);
SET @c = repeat('c', 767);
SET @d = repeat('d', 767);
SET @e = repeat('e', 767);

# With no indexes defined, we can update all columns to max key part length.
INSERT INTO t1 VALUES (@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a,@a);
UPDATE t1 SET a=@b,b=@b,c=@b,d=@b,e=@b,f=@b,g=@b,h=@b,i=@b,j=@b,
              k=@b,l=@b,m=@b,n=@b,o=@b,p=@b,q=@b,r=@b,s=@b,t=@b,u=@b;

# With this many indexes defined, we can still update all fields.
CREATE INDEX t1a ON t1 (a(767));
CREATE INDEX t1b ON t1 (b(767));
CREATE INDEX t1c ON t1 (c(767));
CREATE INDEX t1d ON t1 (d(767));
CREATE INDEX t1e ON t1 (e(767));
UPDATE t1 SET a=@c,b=@c,c=@c,d=@c,e=@c,f=@c,g=@c,h=@c,i=@c,j=@c,
              k=@c,l=@c,m=@c,n=@c,o=@c,p=@c,q=@c,r=@c,s=@c,t=@c,u=@c;

# Add one more index and the UNDO record becomes too big to update all columns.
# But a single transaction can update the columns in separate statements.
# because the UNDO records will be smaller.
CREATE INDEX t1f ON t1 (f(767));
--error ER_UNDO_RECORD_TOO_BIG
UPDATE t1 SET a=@d,b=@d,c=@d,d=@d,e=@d,f=@d,g=@d,h=@d,i=@d,j=@d,
              k=@d,l=@d,m=@d,n=@d,o=@d,p=@d,q=@d,r=@d,s=@d,t=@d,u=@d;
BEGIN;
UPDATE t1 SET a=@d,b=@d,c=@d,d=@d,e=@d;
UPDATE t1 SET f=@d,g=@d,h=@d,i=@d,j=@d,k=@d,l=@d,m=@d,
              n=@d,o=@d,p=@d,q=@d,r=@d,s=@d,t=@d,u=@d;
COMMIT;

# More indexes can still be added and a single field can still be updated
CREATE INDEX t1g ON t1 (g(767));
UPDATE t1 SET g=@e;
CREATE INDEX t1h ON t1 (h(767));
UPDATE t1 SET h=@e;
CREATE INDEX t1i ON t1 (i(767));
UPDATE t1 SET i=@e;
CREATE INDEX t1j ON t1 (j(767));
UPDATE t1 SET j=@e;
CREATE INDEX t1k ON t1 (k(767));
UPDATE t1 SET k=@e;
CREATE INDEX t1l ON t1 (l(767));
UPDATE t1 SET l=@e;
CREATE INDEX t1m ON t1 (m(767));
UPDATE t1 SET m=@e;
CREATE INDEX t1n ON t1 (n(767));
UPDATE t1 SET n=@e;
CREATE INDEX t1o ON t1 (o(767));
UPDATE t1 SET o=@e;
CREATE INDEX t1p ON t1 (p(767));
UPDATE t1 SET p=@e;
CREATE INDEX t1q ON t1 (q(767));
UPDATE t1 SET q=@e;
CREATE INDEX t1r ON t1 (r(767));
UPDATE t1 SET r=@e;
CREATE INDEX t1s ON t1 (s(767));
UPDATE t1 SET s=@e;

# Add one more index and we cannot update a column to its defined index length.
# This is a problem.  It means that the DDL is allowed to create a table
# that CANNOT be updated.  See bug#12953735.
CREATE INDEX t1t ON t1 (t(767));
--error ER_UNDO_RECORD_TOO_BIG
UPDATE t1 SET t=@e;

# The function dict_index_too_big_for_undo() prevents us from adding
# one more index.  But it is too late.  The record is already too big.
# See bug#12953735
--error ER_TOO_BIG_ROWSIZE
CREATE INDEX t1u ON t1 (u(767));
--error ER_TOO_BIG_ROWSIZE
CREATE INDEX t1ut ON t1 (u(767), t(767));
CREATE INDEX t1st ON t1 (s(767), t(767));

SHOW CREATE TABLE t1;
DROP TABLE t1;

SET GLOBAL innodb_file_format = `Barracuda`;
SET GLOBAL innodb_file_per_table = ON;

--echo # Bug #12429576 - Test an assertion failure on purge.
# This test is not in innodb_8k or innodb_4k since the bug is not about
# page size.  It just tests the condition that caused the assertion.
CREATE TABLE t1_purge (
A int,
B blob, C blob, D blob, E blob,
F blob, G blob, H blob,
PRIMARY KEY (B(767), C(767), D(767), E(767), A),
INDEX (A)
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC;

INSERT INTO t1_purge VALUES (1,
REPEAT('b', 766), REPEAT('c', 766), REPEAT('d', 766), REPEAT('e', 766),
REPEAT('f', 766), REPEAT('g', 766), REPEAT('h', 766));

CREATE TABLE t2_purge (
A int PRIMARY KEY,
B blob, C blob, D blob, E blob,
F blob, G blob, H blob, I blob,
J blob, K blob, L blob,
INDEX (B(767))) ENGINE=InnoDB ROW_FORMAT=DYNAMIC;

INSERT INTO t2_purge VALUES (1,
REPEAT('b', 766), REPEAT('c', 766), REPEAT('d', 766), REPEAT('e', 766),
REPEAT('f', 766), REPEAT('g', 766), REPEAT('h', 766), REPEAT('i', 766),
REPEAT('j', 766), REPEAT('k', 766), REPEAT('l', 766));

CREATE TABLE t3_purge (
A int,
B varchar(800), C varchar(800), D varchar(800), E varchar(800),
F varchar(800), G varchar(800), H varchar(800),
PRIMARY KEY (B(767), C(767), D(767), E(767), A),
INDEX (A)
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC;

INSERT INTO t3_purge SELECT * FROM t1_purge;

CREATE TABLE t4_purge (
A int PRIMARY KEY,
B varchar(800), C varchar(800), D varchar(800), E varchar(800),
F varchar(800), G varchar(800), H varchar(800), I varchar(800),
J varchar(800), K varchar(800), L varchar(800),
INDEX (B(767))) ENGINE=InnoDB ROW_FORMAT=DYNAMIC;

INSERT INTO t4_purge SELECT * FROM t2_purge;

# This would trigger the failure (Bug #12429576)
# if purge gets a chance to run before DROP TABLE t1_purge, ....
DELETE FROM t1_purge;
DELETE FROM t2_purge;
DELETE FROM t3_purge;
DELETE FROM t4_purge;
# We need to activate the purge thread.
# Instead of doing a --sleep 10 now,  do it once at the end.

# Bug#12637786 - Assertion hit; ut_ad(dict_index_is_clust(index));
# A secondary index tuple is found to be too long to fit into a page.
# This test is not in innodb_8k or innodb_4k since the bug is not about
# page size.  It just tests the condition that caused the assertion.
SET GLOBAL innodb_file_per_table=on;
SET GLOBAL innodb_file_format='Barracuda';
SET @r=REPEAT('a',500);
CREATE TABLE t12637786(a int,
 v1 varchar(500), v2 varchar(500), v3 varchar(500),
 v4 varchar(500), v5 varchar(500), v6 varchar(500),
 v7 varchar(500), v8 varchar(500), v9 varchar(500),
 v10 varchar(500), v11 varchar(500), v12 varchar(500),
 v13 varchar(500), v14 varchar(500), v15 varchar(500),
 v16 varchar(500), v17 varchar(500), v18 varchar(500)
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC;
CREATE INDEX idx1 ON t12637786(a,v1);
INSERT INTO t12637786 VALUES(9,@r,@r,@r,@r,@r,@r,@r,@r,@r,@r,@r,@r,@r,@r,@r,@r,@r,@r);
UPDATE t12637786 SET a=1000;
DELETE FROM t12637786;
# We need to activate the purge thread to make sure it does not assert and
# is able to clean up the old versions of secondary index entries.
# Instead of doing a --sleep 10 now for each test,  do it once at the end.

--echo # Bug#12963823 - Test that the purge thread does not crash when
# the number of indexes has changed since the UNDO record was logged.
# This test is not in innodb_8k or innodb_4k since the bug is not about
# page size.  It just tests the condition that caused the crash.
CREATE TABLE t12963823(a blob,b blob,c blob,d blob,e blob,f blob,g blob,h blob,
		       i blob,j blob,k blob,l blob,m blob,n blob,o blob,p blob)
	ENGINE=innodb ROW_FORMAT=dynamic;
SET @r = REPEAT('a', 767);
INSERT INTO t12963823 VALUES (@r,@r,@r,@r, @r,@r,@r,@r, @r,@r,@r,@r, @r,@r,@r,@r);
CREATE INDEX ndx_a ON t12963823 (a(500));
CREATE INDEX ndx_b ON t12963823 (b(500));
CREATE INDEX ndx_c ON t12963823 (c(500));
CREATE INDEX ndx_d ON t12963823 (d(500));
CREATE INDEX ndx_e ON t12963823 (e(500));
CREATE INDEX ndx_f ON t12963823 (f(500));
CREATE INDEX ndx_k ON t12963823 (k(500));
CREATE INDEX ndx_l ON t12963823 (l(500));

SET @r = REPEAT('b', 500);
UPDATE t12963823 set a=@r,b=@r,c=@r,d=@r;
UPDATE t12963823 set e=@r,f=@r,g=@r,h=@r;
UPDATE t12963823 set i=@r,j=@r,k=@r,l=@r;
UPDATE t12963823 set m=@r,n=@r,o=@r,p=@r;
ALTER TABLE t12963823 DROP INDEX ndx_a;
ALTER TABLE t12963823 DROP INDEX ndx_b;
CREATE INDEX ndx_g ON t12963823 (g(500));
CREATE INDEX ndx_h ON t12963823 (h(500));
CREATE INDEX ndx_i ON t12963823 (i(500));
CREATE INDEX ndx_j ON t12963823 (j(500));
CREATE INDEX ndx_m ON t12963823 (m(500));
CREATE INDEX ndx_n ON t12963823 (n(500));
CREATE INDEX ndx_o ON t12963823 (o(500));
CREATE INDEX ndx_p ON t12963823 (p(500));
SHOW CREATE TABLE t12963823;
# We need to activate the purge thread at this point to see if it crashes.
# Instead of doing a --sleep 10 now for each test,  do it once at the end.

--echo # Bug#12547647 UPDATE LOGGING COULD EXCEED LOG PAGE SIZE
# InnoDB cannot know that this undo record would be too big for the undo
# page. Too much of text field is stored in the clustered record in this
# DYNAMIC row formatted record.
# This test is not in innodb_8k or innodb_4k since the bug is not about
# page size.  It just tests the condition that caused the hang.

SET SESSION innodb_strict_mode = ON;
CREATE TABLE bug12547647(
a int NOT NULL, b blob NOT NULL, c text,
PRIMARY KEY (b(10), a), INDEX (c(767)), INDEX(b(767))
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC;
INSERT INTO bug12547647 VALUES (5,REPEAT('khdfo5AlOq',1900),REPEAT('g',7751));
COMMIT;
# The following used to cause a hang while doing infinite undo log allocation.
--error ER_UNDO_RECORD_TOO_BIG
UPDATE bug12547647 SET c = REPEAT('b',16928);
SHOW WARNINGS;
DROP TABLE bug12547647;

# The following should fail in non-strict mode too.
# (The fix of Bug #50945 only affects REDUNDANT and COMPACT tables.)
SET SESSION innodb_strict_mode = off;
--error ER_TOO_BIG_ROWSIZE
CREATE TABLE t1(
	c text NOT NULL, d text NOT NULL,
	PRIMARY KEY (c(767),d(767)))
ENGINE=InnoDB ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=1 CHARSET=ASCII;
--error ER_TOO_BIG_ROWSIZE
CREATE TABLE t1(
	c text NOT NULL, d text NOT NULL,
	PRIMARY KEY (c(767),d(767)))
ENGINE=InnoDB ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=2 CHARSET=ASCII;
CREATE TABLE t1(
	c text NOT NULL, d text NOT NULL,
	PRIMARY KEY (c(767),d(767)))
ENGINE=InnoDB ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=4 CHARSET=ASCII;
drop table t1;
--error ER_TOO_BIG_ROWSIZE
CREATE TABLE t1(c text, PRIMARY KEY (c(440)))
ENGINE=InnoDB ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=1 CHARSET=ASCII;
CREATE TABLE t1(c text, PRIMARY KEY (c(438)))
ENGINE=InnoDB ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=1 CHARSET=ASCII;
INSERT INTO t1 VALUES(REPEAT('A',512)),(REPEAT('B',512));
DROP TABLE t1;

--echo #
--echo # Bug#56862 Execution of a query that uses index merge returns a wrong result
--echo #

# Moved to here from innodb_mysql.test.  Some PB3 systems sporadically
# had timeouts doing this with smaller page sizes.

CREATE TABLE t1 (
  pk int NOT NULL AUTO_INCREMENT PRIMARY KEY,
  a int,
  b int,
  INDEX idx(a))
ENGINE=INNODB;

INSERT INTO t1(a,b) VALUES
  (11, 1100), (2, 200), (1, 100), (14, 1400), (5, 500),
  (3, 300), (17, 1700), (4, 400), (12, 1200), (8, 800),
  (6, 600), (18, 1800), (9, 900), (10, 1000), (7, 700),
  (13, 1300), (15, 1500), (19, 1900), (16, 1600), (20, 2000);
INSERT INTO t1(a,b) SELECT a+20, b+2000 FROM t1;
INSERT INTO t1(a,b) SELECT a+40, b+4000 FROM t1;
INSERT INTO t1(a,b) SELECT a+80, b+8000 FROM t1;
INSERT INTO t1(a,b) SELECT a,b FROM t1;
INSERT INTO t1(a,b) SELECT a,b FROM t1;
INSERT INTO t1(a,b) SELECT a,b FROM t1;
INSERT INTO t1(a,b) SELECT a,b FROM t1;
INSERT INTO t1(a,b) SELECT a,b FROM t1;
INSERT INTO t1(a,b) SELECT a,b FROM t1;
INSERT INTO t1(a,b) SELECT a,b FROM t1;
INSERT INTO t1(a,b) SELECT a,b FROM t1;
INSERT INTO t1 VALUES (1000000, 0, 0);

SET SESSION sort_buffer_size = 1024*36;

EXPLAIN
SELECT COUNT(*) FROM
  (SELECT * FROM t1 FORCE INDEX (idx,PRIMARY)
     WHERE a BETWEEN 2 AND 7 OR pk=1000000) AS t;

SELECT COUNT(*) FROM
  (SELECT * FROM t1 FORCE INDEX (idx,PRIMARY)
     WHERE a BETWEEN 2 AND 7 OR pk=1000000) AS t;

SET SESSION sort_buffer_size = DEFAULT;

DROP TABLE t1;

# The tests that uses these tables required the purge thread to run.
# Just in case it has not by now, provide a 10 second wait.
--sleep 10
DROP TABLE t1_purge, t2_purge, t3_purge, t4_purge;
DROP TABLE t12637786;
DROP TABLE t12963823;

#
# restore environment to the state it was before this test execution
#

--disable_query_log
EVAL SET GLOBAL innodb_file_format = $innodb_file_format_orig;
EVAL SET GLOBAL innodb_file_format_max = $innodb_file_format_max_orig;
EVAL SET GLOBAL innodb_file_per_table = $innodb_file_per_table_orig;
EVAL SET GLOBAL innodb_large_prefix = $innodb_large_prefix_orig;
EVAL SET SESSION innodb_strict_mode = $innodb_strict_mode_orig;
--enable_query_log