Merge 10.2 into bb-10.2-ext; also, fix MDEV-13015 After restart, InnoDB wrongly thinks that a SEQUENCE is a TABLE

sql_sequence.read_only: Show that the sequence can be read in
both read-only and read-write mode, and that the sequence remains
accessible after a server restart.
This commit is contained in:
Marko Mäkelä 2017-06-15 18:02:57 +03:00
commit 43eec57fab
44 changed files with 1270 additions and 567 deletions

View File

@ -12,7 +12,8 @@ enum enum_server_command
COM_UNIMPLEMENTED,
COM_RESET_CONNECTION,
COM_MDB_GAP_BEG,
COM_MDB_GAP_END=250,
COM_MDB_GAP_END=249,
COM_STMT_BULK_EXECUTE=250,
COM_SLAVE_WORKER=251,
COM_SLAVE_IO=252,
COM_SLAVE_SQL=253,

View File

@ -115,7 +115,8 @@ enum enum_server_command
COM_RESET_CONNECTION,
/* don't forget to update const char *command_name[] in sql_parse.cc */
COM_MDB_GAP_BEG,
COM_MDB_GAP_END=250,
COM_MDB_GAP_END=249,
COM_STMT_BULK_EXECUTE=250,
COM_SLAVE_WORKER=251,
COM_SLAVE_IO=252,
COM_SLAVE_SQL=253,
@ -136,6 +137,13 @@ enum enum_indicator_type
STMT_INDICATOR_IGNORE
};
/*
bulk PS flags
*/
#define STMT_BULK_FLAG_CLIENT_SEND_TYPES 128
#define STMT_BULK_FLAG_INSERT_ID_REQUEST 64
/* sql type stored in .frm files for virtual fields */
#define MYSQL_TYPE_VIRTUAL 245
/*
@ -311,7 +319,8 @@ enum enum_indicator_type
CLIENT_SESSION_TRACK |\
CLIENT_DEPRECATE_EOF |\
CLIENT_CONNECT_ATTRS |\
MARIADB_CLIENT_COM_MULTI)
MARIADB_CLIENT_COM_MULTI |\
MARIADB_CLIENT_STMT_BULK_OPERATIONS)
/*
To be added later:

@ -1 +1 @@
Subproject commit 467a193b399dfda41d87368a898e9550d754fa14
Subproject commit ff4bfdf1caf2e0a47382fdbe6d796d0e63ec1062

View File

@ -1396,7 +1396,7 @@ performance-schema-max-rwlock-instances -1
performance-schema-max-socket-classes 10
performance-schema-max-socket-instances -1
performance-schema-max-stage-classes 150
performance-schema-max-statement-classes 190
performance-schema-max-statement-classes 191
performance-schema-max-table-handles -1
performance-schema-max-table-instances -1
performance-schema-max-thread-classes 50

View File

@ -10,13 +10,13 @@ create database innodb_encrypted_1;
use innodb_encrypted_1;
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 1
Innodb_pages0_read 3
set autocommit=0;
set autocommit=1;
commit work;
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 1
Innodb_pages0_read 3
# should be 100
SELECT COUNT(*) FROM INFORMATION_SCHEMA.INNODB_TABLESPACES_ENCRYPTION WHERE NAME LIKE 'innodb_encrypted%';
COUNT(*)
@ -86,47 +86,47 @@ Innodb_pages0_read 3
# Restart Success!
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 1
Innodb_pages0_read 303
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 1
Innodb_pages0_read 303
use test;
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 1
Innodb_pages0_read 303
use innodb_encrypted_1;
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 1
Innodb_pages0_read 303
use innodb_encrypted_2;
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 1
Innodb_pages0_read 303
use innodb_encrypted_3;
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 1
Innodb_pages0_read 303
use innodb_encrypted_1;
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 1
Innodb_pages0_read 303
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 101
Innodb_pages0_read 303
use innodb_encrypted_2;
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 101
Innodb_pages0_read 303
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 201
Innodb_pages0_read 303
use innodb_encrypted_3;
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 201
Innodb_pages0_read 303
show status like 'innodb_pages0_read%';
Variable_name Value
Innodb_pages0_read 301
Innodb_pages0_read 303
SELECT COUNT(*) FROM INFORMATION_SCHEMA.INNODB_TABLESPACES_ENCRYPTION WHERE MIN_KEY_VERSION = 0 AND NAME LIKE 'innodb_encrypted%';
COUNT(*)
100

View File

@ -72,7 +72,7 @@ DROP TABLE t1;
Warnings:
Warning 1932 Table 'test.t1' doesn't exist in engine
DROP TABLE t2,t3;
FOUND 49 /\[ERROR\] InnoDB: Table `test`\.`t1` in InnoDB data dictionary contains invalid flags\. SYS_TABLES.MIX_LEN=255\b/ in mysqld.1.err
FOUND 49 /\[ERROR\] InnoDB: Table `test`\.`t1` in InnoDB data dictionary contains invalid flags\. SYS_TABLES\.TYPE=1 SYS_TABLES\.MIX_LEN=255\b/ in mysqld.1.err
ib_buffer_pool
ib_logfile0
ib_logfile1

View File

@ -0,0 +1,105 @@
--- suite/innodb/r/table_flags.result
+++ suite/innodb/r/table_flags,32k.reject
@@ -5,6 +5,8 @@
SET innodb_strict_mode=OFF;
CREATE TABLE tz(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=COMPRESSED
KEY_BLOCK_SIZE=1;
+Warnings:
+Warning 1478 InnoDB: Cannot create a COMPRESSED table when innodb_page_size > 16k. Assuming ROW_FORMAT=DYNAMIC.
SET innodb_strict_mode=ON;
CREATE TABLE tp(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=DYNAMIC
PAGE_COMPRESSED=1 PAGE_COMPRESSION_LEVEL=9;
@@ -13,7 +15,7 @@
header=0x01000003016e (NAME=0x696e66696d756d00)
header=0x00002815008d (NAME='SYS_DATAFILES',
DB_TRX_ID=0x000000000302,
- DB_ROLL_PTR=0x81000001320194,
+ DB_ROLL_PTR=0x81000001310194,
ID=0x000000000000000e,
N_COLS=0x00000002,
TYPE=0x00000001,
@@ -23,7 +25,7 @@
SPACE=0x00000000)
header=0x0000101500d5 (NAME='SYS_FOREIGN',
DB_TRX_ID=0x000000000300,
- DB_ROLL_PTR=0x800000012d0110,
+ DB_ROLL_PTR=0x800000012c0110,
ID=0x000000000000000b,
N_COLS=0x00000004,
TYPE=0x00000001,
@@ -33,7 +35,7 @@
SPACE=0x00000000)
header=0x000018150122 (NAME='SYS_FOREIGN_COLS',
DB_TRX_ID=0x000000000300,
- DB_ROLL_PTR=0x800000012d0201,
+ DB_ROLL_PTR=0x800000012c0201,
ID=0x000000000000000c,
N_COLS=0x00000004,
TYPE=0x00000001,
@@ -43,7 +45,7 @@
SPACE=0x00000000)
header=0x0400201501b8 (NAME='SYS_TABLESPACES',
DB_TRX_ID=0x000000000302,
- DB_ROLL_PTR=0x81000001320110,
+ DB_ROLL_PTR=0x81000001310110,
ID=0x000000000000000d,
N_COLS=0x00000003,
TYPE=0x00000001,
@@ -53,7 +55,7 @@
SPACE=0x00000000)
header=0x000030150244 (NAME='SYS_VIRTUAL',
DB_TRX_ID=0x000000000304,
- DB_ROLL_PTR=0x82000001350110,
+ DB_ROLL_PTR=0x82000001340110,
ID=0x000000000000000f,
N_COLS=0x00000003,
TYPE=0x00000001,
@@ -63,7 +65,7 @@
SPACE=0x00000000)
header=0x000040150288 (NAME='test/tc',
DB_TRX_ID=0x000000000308,
- DB_ROLL_PTR=0x84000001380110,
+ DB_ROLL_PTR=0x84000001370110,
ID=0x0000000000000011,
N_COLS=0x80000001,
TYPE=0x00000001,
@@ -73,7 +75,7 @@
SPACE=0x00000002)
header=0x000048150310 (NAME='test/td',
DB_TRX_ID=0x00000000030a,
- DB_ROLL_PTR=0x85000001390110,
+ DB_ROLL_PTR=0x85000001380110,
ID=0x0000000000000012,
N_COLS=0x80000001,
TYPE=0x00000021,
@@ -83,7 +85,7 @@
SPACE=0x00000003)
header=0x000058150200 (NAME='test/tp',
DB_TRX_ID=0x00000000030e,
- DB_ROLL_PTR=0x870000013b0110,
+ DB_ROLL_PTR=0x870000013a0110,
ID=0x0000000000000014,
N_COLS=0x80000001,
TYPE=0x000009a1,
@@ -93,7 +95,7 @@
SPACE=0x00000005)
header=0x0000381502cc (NAME='test/tr',
DB_TRX_ID=0x000000000306,
- DB_ROLL_PTR=0x83000001370110,
+ DB_ROLL_PTR=0x83000001360110,
ID=0x0000000000000010,
N_COLS=0x00000001,
TYPE=0x00000001,
@@ -103,10 +105,10 @@
SPACE=0x00000001)
header=0x000050150074 (NAME='test/tz',
DB_TRX_ID=0x00000000030c,
- DB_ROLL_PTR=0x860000013a0110,
+ DB_ROLL_PTR=0x86000001390110,
ID=0x0000000000000013,
N_COLS=0x80000001,
- TYPE=0x00000023,
+ TYPE=0x00000021,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000050,
CLUSTER_NAME=NULL(0 bytes),

View File

@ -0,0 +1,92 @@
--- suite/innodb/r/table_flags.result
+++ suite/innodb/r/table_flags,4k.reject
@@ -13,7 +13,7 @@
header=0x01000003016e (NAME=0x696e66696d756d00)
header=0x00002815008d (NAME='SYS_DATAFILES',
DB_TRX_ID=0x000000000302,
- DB_ROLL_PTR=0x81000001320194,
+ DB_ROLL_PTR=0x81000003260194,
ID=0x000000000000000e,
N_COLS=0x00000002,
TYPE=0x00000001,
@@ -23,7 +23,7 @@
SPACE=0x00000000)
header=0x0000101500d5 (NAME='SYS_FOREIGN',
DB_TRX_ID=0x000000000300,
- DB_ROLL_PTR=0x800000012d0110,
+ DB_ROLL_PTR=0x80000003200110,
ID=0x000000000000000b,
N_COLS=0x00000004,
TYPE=0x00000001,
@@ -33,7 +33,7 @@
SPACE=0x00000000)
header=0x000018150122 (NAME='SYS_FOREIGN_COLS',
DB_TRX_ID=0x000000000300,
- DB_ROLL_PTR=0x800000012d0201,
+ DB_ROLL_PTR=0x80000003200201,
ID=0x000000000000000c,
N_COLS=0x00000004,
TYPE=0x00000001,
@@ -43,7 +43,7 @@
SPACE=0x00000000)
header=0x0400201501b8 (NAME='SYS_TABLESPACES',
DB_TRX_ID=0x000000000302,
- DB_ROLL_PTR=0x81000001320110,
+ DB_ROLL_PTR=0x81000003260110,
ID=0x000000000000000d,
N_COLS=0x00000003,
TYPE=0x00000001,
@@ -53,7 +53,7 @@
SPACE=0x00000000)
header=0x000030150244 (NAME='SYS_VIRTUAL',
DB_TRX_ID=0x000000000304,
- DB_ROLL_PTR=0x82000001350110,
+ DB_ROLL_PTR=0x820000032a0110,
ID=0x000000000000000f,
N_COLS=0x00000003,
TYPE=0x00000001,
@@ -63,7 +63,7 @@
SPACE=0x00000000)
header=0x000040150288 (NAME='test/tc',
DB_TRX_ID=0x000000000308,
- DB_ROLL_PTR=0x84000001380110,
+ DB_ROLL_PTR=0x840000032d0110,
ID=0x0000000000000011,
N_COLS=0x80000001,
TYPE=0x00000001,
@@ -73,7 +73,7 @@
SPACE=0x00000002)
header=0x000048150310 (NAME='test/td',
DB_TRX_ID=0x00000000030a,
- DB_ROLL_PTR=0x85000001390110,
+ DB_ROLL_PTR=0x850000032f0110,
ID=0x0000000000000012,
N_COLS=0x80000001,
TYPE=0x00000021,
@@ -83,7 +83,7 @@
SPACE=0x00000003)
header=0x000058150200 (NAME='test/tp',
DB_TRX_ID=0x00000000030e,
- DB_ROLL_PTR=0x870000013b0110,
+ DB_ROLL_PTR=0x87000003310110,
ID=0x0000000000000014,
N_COLS=0x80000001,
TYPE=0x000009a1,
@@ -93,7 +93,7 @@
SPACE=0x00000005)
header=0x0000381502cc (NAME='test/tr',
DB_TRX_ID=0x000000000306,
- DB_ROLL_PTR=0x83000001370110,
+ DB_ROLL_PTR=0x830000032c0110,
ID=0x0000000000000010,
N_COLS=0x00000001,
TYPE=0x00000001,
@@ -103,7 +103,7 @@
SPACE=0x00000001)
header=0x000050150074 (NAME='test/tz',
DB_TRX_ID=0x00000000030c,
- DB_ROLL_PTR=0x860000013a0110,
+ DB_ROLL_PTR=0x86000003300110,
ID=0x0000000000000013,
N_COLS=0x80000001,
TYPE=0x00000023,

View File

@ -0,0 +1,105 @@
--- suite/innodb/r/table_flags.result
+++ suite/innodb/r/table_flags,64k.reject
@@ -5,6 +5,8 @@
SET innodb_strict_mode=OFF;
CREATE TABLE tz(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=COMPRESSED
KEY_BLOCK_SIZE=1;
+Warnings:
+Warning 1478 InnoDB: Cannot create a COMPRESSED table when innodb_page_size > 16k. Assuming ROW_FORMAT=DYNAMIC.
SET innodb_strict_mode=ON;
CREATE TABLE tp(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=DYNAMIC
PAGE_COMPRESSED=1 PAGE_COMPRESSION_LEVEL=9;
@@ -13,7 +15,7 @@
header=0x01000003016e (NAME=0x696e66696d756d00)
header=0x00002815008d (NAME='SYS_DATAFILES',
DB_TRX_ID=0x000000000302,
- DB_ROLL_PTR=0x81000001320194,
+ DB_ROLL_PTR=0x81000001310194,
ID=0x000000000000000e,
N_COLS=0x00000002,
TYPE=0x00000001,
@@ -23,7 +25,7 @@
SPACE=0x00000000)
header=0x0000101500d5 (NAME='SYS_FOREIGN',
DB_TRX_ID=0x000000000300,
- DB_ROLL_PTR=0x800000012d0110,
+ DB_ROLL_PTR=0x800000012c0110,
ID=0x000000000000000b,
N_COLS=0x00000004,
TYPE=0x00000001,
@@ -33,7 +35,7 @@
SPACE=0x00000000)
header=0x000018150122 (NAME='SYS_FOREIGN_COLS',
DB_TRX_ID=0x000000000300,
- DB_ROLL_PTR=0x800000012d0201,
+ DB_ROLL_PTR=0x800000012c0201,
ID=0x000000000000000c,
N_COLS=0x00000004,
TYPE=0x00000001,
@@ -43,7 +45,7 @@
SPACE=0x00000000)
header=0x0400201501b8 (NAME='SYS_TABLESPACES',
DB_TRX_ID=0x000000000302,
- DB_ROLL_PTR=0x81000001320110,
+ DB_ROLL_PTR=0x81000001310110,
ID=0x000000000000000d,
N_COLS=0x00000003,
TYPE=0x00000001,
@@ -53,7 +55,7 @@
SPACE=0x00000000)
header=0x000030150244 (NAME='SYS_VIRTUAL',
DB_TRX_ID=0x000000000304,
- DB_ROLL_PTR=0x82000001350110,
+ DB_ROLL_PTR=0x82000001340110,
ID=0x000000000000000f,
N_COLS=0x00000003,
TYPE=0x00000001,
@@ -63,7 +65,7 @@
SPACE=0x00000000)
header=0x000040150288 (NAME='test/tc',
DB_TRX_ID=0x000000000308,
- DB_ROLL_PTR=0x84000001380110,
+ DB_ROLL_PTR=0x84000001370110,
ID=0x0000000000000011,
N_COLS=0x80000001,
TYPE=0x00000001,
@@ -73,7 +75,7 @@
SPACE=0x00000002)
header=0x000048150310 (NAME='test/td',
DB_TRX_ID=0x00000000030a,
- DB_ROLL_PTR=0x85000001390110,
+ DB_ROLL_PTR=0x85000001380110,
ID=0x0000000000000012,
N_COLS=0x80000001,
TYPE=0x00000021,
@@ -83,7 +85,7 @@
SPACE=0x00000003)
header=0x000058150200 (NAME='test/tp',
DB_TRX_ID=0x00000000030e,
- DB_ROLL_PTR=0x870000013b0110,
+ DB_ROLL_PTR=0x870000013a0110,
ID=0x0000000000000014,
N_COLS=0x80000001,
TYPE=0x000009a1,
@@ -93,7 +95,7 @@
SPACE=0x00000005)
header=0x0000381502cc (NAME='test/tr',
DB_TRX_ID=0x000000000306,
- DB_ROLL_PTR=0x83000001370110,
+ DB_ROLL_PTR=0x83000001360110,
ID=0x0000000000000010,
N_COLS=0x00000001,
TYPE=0x00000001,
@@ -103,10 +105,10 @@
SPACE=0x00000001)
header=0x000050150074 (NAME='test/tz',
DB_TRX_ID=0x00000000030c,
- DB_ROLL_PTR=0x860000013a0110,
+ DB_ROLL_PTR=0x86000001390110,
ID=0x0000000000000013,
N_COLS=0x80000001,
- TYPE=0x00000023,
+ TYPE=0x00000021,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000050,
CLUSTER_NAME=NULL(0 bytes),

View File

@ -0,0 +1,92 @@
--- suite/innodb/r/table_flags.result
+++ suite/innodb/r/table_flags,8k.reject
@@ -13,7 +13,7 @@
header=0x01000003016e (NAME=0x696e66696d756d00)
header=0x00002815008d (NAME='SYS_DATAFILES',
DB_TRX_ID=0x000000000302,
- DB_ROLL_PTR=0x81000001320194,
+ DB_ROLL_PTR=0x81000001d70194,
ID=0x000000000000000e,
N_COLS=0x00000002,
TYPE=0x00000001,
@@ -23,7 +23,7 @@
SPACE=0x00000000)
header=0x0000101500d5 (NAME='SYS_FOREIGN',
DB_TRX_ID=0x000000000300,
- DB_ROLL_PTR=0x800000012d0110,
+ DB_ROLL_PTR=0x80000001d10110,
ID=0x000000000000000b,
N_COLS=0x00000004,
TYPE=0x00000001,
@@ -33,7 +33,7 @@
SPACE=0x00000000)
header=0x000018150122 (NAME='SYS_FOREIGN_COLS',
DB_TRX_ID=0x000000000300,
- DB_ROLL_PTR=0x800000012d0201,
+ DB_ROLL_PTR=0x80000001d10201,
ID=0x000000000000000c,
N_COLS=0x00000004,
TYPE=0x00000001,
@@ -43,7 +43,7 @@
SPACE=0x00000000)
header=0x0400201501b8 (NAME='SYS_TABLESPACES',
DB_TRX_ID=0x000000000302,
- DB_ROLL_PTR=0x81000001320110,
+ DB_ROLL_PTR=0x81000001d70110,
ID=0x000000000000000d,
N_COLS=0x00000003,
TYPE=0x00000001,
@@ -53,7 +53,7 @@
SPACE=0x00000000)
header=0x000030150244 (NAME='SYS_VIRTUAL',
DB_TRX_ID=0x000000000304,
- DB_ROLL_PTR=0x82000001350110,
+ DB_ROLL_PTR=0x82000001da0110,
ID=0x000000000000000f,
N_COLS=0x00000003,
TYPE=0x00000001,
@@ -63,7 +63,7 @@
SPACE=0x00000000)
header=0x000040150288 (NAME='test/tc',
DB_TRX_ID=0x000000000308,
- DB_ROLL_PTR=0x84000001380110,
+ DB_ROLL_PTR=0x84000001dd0110,
ID=0x0000000000000011,
N_COLS=0x80000001,
TYPE=0x00000001,
@@ -73,7 +73,7 @@
SPACE=0x00000002)
header=0x000048150310 (NAME='test/td',
DB_TRX_ID=0x00000000030a,
- DB_ROLL_PTR=0x85000001390110,
+ DB_ROLL_PTR=0x85000001de0110,
ID=0x0000000000000012,
N_COLS=0x80000001,
TYPE=0x00000021,
@@ -83,7 +83,7 @@
SPACE=0x00000003)
header=0x000058150200 (NAME='test/tp',
DB_TRX_ID=0x00000000030e,
- DB_ROLL_PTR=0x870000013b0110,
+ DB_ROLL_PTR=0x87000001e00110,
ID=0x0000000000000014,
N_COLS=0x80000001,
TYPE=0x000009a1,
@@ -93,7 +93,7 @@
SPACE=0x00000005)
header=0x0000381502cc (NAME='test/tr',
DB_TRX_ID=0x000000000306,
- DB_ROLL_PTR=0x83000001370110,
+ DB_ROLL_PTR=0x83000001dc0110,
ID=0x0000000000000010,
N_COLS=0x00000001,
TYPE=0x00000001,
@@ -103,7 +103,7 @@
SPACE=0x00000001)
header=0x000050150074 (NAME='test/tz',
DB_TRX_ID=0x00000000030c,
- DB_ROLL_PTR=0x860000013a0110,
+ DB_ROLL_PTR=0x86000001df0110,
ID=0x0000000000000013,
N_COLS=0x80000001,
TYPE=0x00000023,

View File

@ -0,0 +1,188 @@
SET GLOBAL innodb_file_per_table=1;
CREATE TABLE tr(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=REDUNDANT;
CREATE TABLE tc(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=COMPACT;
CREATE TABLE td(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=DYNAMIC;
SET innodb_strict_mode=OFF;
CREATE TABLE tz(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=COMPRESSED
KEY_BLOCK_SIZE=1;
SET innodb_strict_mode=ON;
CREATE TABLE tp(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=DYNAMIC
PAGE_COMPRESSED=1 PAGE_COMPRESSION_LEVEL=9;
SYS_TABLES clustered index root page (8):
N_RECS=10; LEVEL=0; INDEX_ID=0x0000000000000001
header=0x01000003016e (NAME=0x696e66696d756d00)
header=0x00002815008d (NAME='SYS_DATAFILES',
DB_TRX_ID=0x000000000302,
DB_ROLL_PTR=0x81000001320194,
ID=0x000000000000000e,
N_COLS=0x00000002,
TYPE=0x00000001,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000040,
CLUSTER_NAME=NULL(0 bytes),
SPACE=0x00000000)
header=0x0000101500d5 (NAME='SYS_FOREIGN',
DB_TRX_ID=0x000000000300,
DB_ROLL_PTR=0x800000012d0110,
ID=0x000000000000000b,
N_COLS=0x00000004,
TYPE=0x00000001,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000040,
CLUSTER_NAME=NULL(0 bytes),
SPACE=0x00000000)
header=0x000018150122 (NAME='SYS_FOREIGN_COLS',
DB_TRX_ID=0x000000000300,
DB_ROLL_PTR=0x800000012d0201,
ID=0x000000000000000c,
N_COLS=0x00000004,
TYPE=0x00000001,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000040,
CLUSTER_NAME=NULL(0 bytes),
SPACE=0x00000000)
header=0x0400201501b8 (NAME='SYS_TABLESPACES',
DB_TRX_ID=0x000000000302,
DB_ROLL_PTR=0x81000001320110,
ID=0x000000000000000d,
N_COLS=0x00000003,
TYPE=0x00000001,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000040,
CLUSTER_NAME=NULL(0 bytes),
SPACE=0x00000000)
header=0x000030150244 (NAME='SYS_VIRTUAL',
DB_TRX_ID=0x000000000304,
DB_ROLL_PTR=0x82000001350110,
ID=0x000000000000000f,
N_COLS=0x00000003,
TYPE=0x00000001,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000040,
CLUSTER_NAME=NULL(0 bytes),
SPACE=0x00000000)
header=0x000040150288 (NAME='test/tc',
DB_TRX_ID=0x000000000308,
DB_ROLL_PTR=0x84000001380110,
ID=0x0000000000000011,
N_COLS=0x80000001,
TYPE=0x00000001,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000050,
CLUSTER_NAME=NULL(0 bytes),
SPACE=0x00000002)
header=0x000048150310 (NAME='test/td',
DB_TRX_ID=0x00000000030a,
DB_ROLL_PTR=0x85000001390110,
ID=0x0000000000000012,
N_COLS=0x80000001,
TYPE=0x00000021,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000050,
CLUSTER_NAME=NULL(0 bytes),
SPACE=0x00000003)
header=0x000058150200 (NAME='test/tp',
DB_TRX_ID=0x00000000030e,
DB_ROLL_PTR=0x870000013b0110,
ID=0x0000000000000014,
N_COLS=0x80000001,
TYPE=0x000009a1,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000050,
CLUSTER_NAME=NULL(0 bytes),
SPACE=0x00000005)
header=0x0000381502cc (NAME='test/tr',
DB_TRX_ID=0x000000000306,
DB_ROLL_PTR=0x83000001370110,
ID=0x0000000000000010,
N_COLS=0x00000001,
TYPE=0x00000001,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000050,
CLUSTER_NAME=NULL(0 bytes),
SPACE=0x00000001)
header=0x000050150074 (NAME='test/tz',
DB_TRX_ID=0x00000000030c,
DB_ROLL_PTR=0x860000013a0110,
ID=0x0000000000000013,
N_COLS=0x80000001,
TYPE=0x00000023,
MIX_ID=0x0000000000000000,
MIX_LEN=0x00000050,
CLUSTER_NAME=NULL(0 bytes),
SPACE=0x00000004)
header=0x070008030000 (NAME=0x73757072656d756d00)
SHOW CREATE TABLE tr;
ERROR 42S02: Table 'test.tr' doesn't exist in engine
SHOW CREATE TABLE tc;
ERROR 42S02: Table 'test.tc' doesn't exist in engine
SHOW CREATE TABLE td;
ERROR 42S02: Table 'test.td' doesn't exist in engine
SHOW CREATE TABLE tz;
Table Create Table
tz CREATE TABLE `tz` (
`a` int(11) NOT NULL,
PRIMARY KEY (`a`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=1
BEGIN;
INSERT INTO tz VALUES(42);
ROLLBACK;
SELECT * FROM tz;
a
42
SHOW CREATE TABLE tp;
ERROR 42S02: Table 'test.tp' doesn't exist in engine
FOUND 4 /InnoDB: Table `test`.`t[cp]` in InnoDB data dictionary contains invalid flags\. SYS_TABLES\.TYPE=(129|289|3873|1232[13]) SYS_TABLES\.N_COLS=2147483649/ in mysqld.1.err
FOUND 2 /InnoDB: Refusing to load '\..test.td\.ibd' \(id=3, flags=0x1?[2ae]1\); dictionary contains id=3, flags=0x10[01][2ae]1\b/ in mysqld.1.err
FOUND 2 /InnoDB: Table `test`\.`tr` in InnoDB data dictionary contains invalid flags\. SYS_TABLES\.TYPE=65 SYS_TABLES\.MIX_LEN=4294967295\b/ in mysqld.1.err
Restoring SYS_TABLES clustered index root page (8)
SHOW CREATE TABLE tr;
Table Create Table
tr CREATE TABLE `tr` (
`a` int(11) NOT NULL,
PRIMARY KEY (`a`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=REDUNDANT
SHOW CREATE TABLE tc;
Table Create Table
tc CREATE TABLE `tc` (
`a` int(11) NOT NULL,
PRIMARY KEY (`a`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=COMPACT
SHOW CREATE TABLE td;
Table Create Table
td CREATE TABLE `td` (
`a` int(11) NOT NULL,
PRIMARY KEY (`a`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC
SHOW CREATE TABLE tz;
Table Create Table
tz CREATE TABLE `tz` (
`a` int(11) NOT NULL,
PRIMARY KEY (`a`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=1
SHOW CREATE TABLE tp;
Table Create Table
tp CREATE TABLE `tp` (
`a` int(11) NOT NULL,
PRIMARY KEY (`a`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC `PAGE_COMPRESSED`=1 `PAGE_COMPRESSION_LEVEL`=9
BEGIN;
INSERT INTO tr VALUES(1);
INSERT INTO tc VALUES(1);
INSERT INTO td VALUES(1);
INSERT INTO tp VALUES(1);
ROLLBACK;
SELECT * FROM tr;
a
SELECT * FROM tc;
a
SELECT * FROM td;
a
SELECT * FROM tp;
a
DROP TABLE tr,tc,td,tz,tp;
ib_buffer_pool
ib_logfile0
ib_logfile1
ibdata1
sys_tables.bin

View File

@ -4,7 +4,7 @@
--disable_query_log
call mtr.add_suppression("InnoDB: Table `mysql`\\.`innodb_table_stats` not found");
call mtr.add_suppression("InnoDB: Table `test`.`t1` in InnoDB data dictionary contains invalid flags. SYS_TABLES.MIX_LEN=255");
call mtr.add_suppression("InnoDB: Table `test`.`t1` in InnoDB data dictionary contains invalid flags. SYS_TABLES\\.TYPE=1 SYS_TABLES\\.MIX_LEN=255\\r?$");
call mtr.add_suppression("InnoDB: Parent table of FTS auxiliary table test/FTS_.* not found");
call mtr.add_suppression("InnoDB: Cannot open table test/t1 from the internal data dictionary");
call mtr.add_suppression("InnoDB: Table `test`.`t1` does not exist in the InnoDB internal data dictionary though MariaDB is trying to (rename|drop)");
@ -141,7 +141,7 @@ RENAME TABLE t1 TO tee_one;
DROP TABLE t1;
DROP TABLE t2,t3;
--let SEARCH_PATTERN= \[ERROR\] InnoDB: Table `test`\.`t1` in InnoDB data dictionary contains invalid flags\. SYS_TABLES.MIX_LEN=255\b
--let SEARCH_PATTERN= \[ERROR\] InnoDB: Table `test`\.`t1` in InnoDB data dictionary contains invalid flags\. SYS_TABLES\.TYPE=1 SYS_TABLES\.MIX_LEN=255\b
--source include/search_pattern_in_file.inc
--let $restart_parameters=

View File

@ -0,0 +1,206 @@
--source include/innodb_page_size.inc
# Embedded server tests do not support restarting
--source include/not_embedded.inc
--disable_query_log
call mtr.add_suppression("InnoDB: Table `mysql`\\.`innodb_table_stats` not found");
call mtr.add_suppression("InnoDB: incorrect flags in SYS_TABLES");
call mtr.add_suppression("InnoDB: Table `test`.`t[cp]` in InnoDB data dictionary contains invalid flags\\. SYS_TABLES\\.TYPE=(129|289|3873|1232[31]) SYS_TABLES\\.N_COLS=2147483649\\r?$");
call mtr.add_suppression("InnoDB: Table `test`\\.`tr` in InnoDB data dictionary contains invalid flags\\. SYS_TABLES\\.TYPE=65 SYS_TABLES\\.MIX_LEN=4294967295\\r?$");
call mtr.add_suppression("InnoDB: Refusing to load '\\..test.td\\.ibd' \\(id=3, flags=0x([2e]1)\\); dictionary contains id=3, flags=0x100\\1\\r?$");
call mtr.add_suppression("InnoDB: Refusing to load '\\..test.td\\.ibd' \\(id=3, flags=0x(1[2ae]1)\\); dictionary contains id=3, flags=0x10\\1\\r?$");
call mtr.add_suppression("InnoDB: Ignoring tablespace for `test`.`td` because it could not be opened\\.");
# FIXME: Remove the following spam due to invalid flags for test.td
call mtr.add_suppression("InnoDB: Operating system error number .* in a file operation");
call mtr.add_suppression("InnoDB: The error means the system cannot find the path specified");
call mtr.add_suppression("InnoDB: If you are installing InnoDB, remember that you must create directories yourself");
FLUSH TABLES;
--enable_query_log
let INNODB_PAGE_SIZE=`select @@innodb_page_size`;
let MYSQLD_DATADIR=`select @@datadir`;
let bugdir= $MYSQLTEST_VARDIR/tmp/table_flags;
--mkdir $bugdir
--let SEARCH_FILE = $MYSQLTEST_VARDIR/log/mysqld.1.err
--let $d=--innodb-data-home-dir=$bugdir --innodb-log-group-home-dir=$bugdir
--let $d=$d --innodb-data-file-path=ibdata1:1M:autoextend
--let $d=$d --innodb-undo-tablespaces=0
--let $restart_parameters=$d --innodb-stats-persistent=0 --innodb-file-format=1
--source include/restart_mysqld.inc
SET GLOBAL innodb_file_per_table=1;
CREATE TABLE tr(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=REDUNDANT;
CREATE TABLE tc(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=COMPACT;
CREATE TABLE td(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=DYNAMIC;
SET innodb_strict_mode=OFF;
CREATE TABLE tz(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=COMPRESSED
KEY_BLOCK_SIZE=1;
SET innodb_strict_mode=ON;
# PAGE_COMPRESSED is supported starting with MariaDB 10.1.0
CREATE TABLE tp(a INT PRIMARY KEY)ENGINE=InnoDB ROW_FORMAT=DYNAMIC
PAGE_COMPRESSED=1 PAGE_COMPRESSION_LEVEL=9;
--source include/shutdown_mysqld.inc
--perl
use strict;
my $ps= $ENV{INNODB_PAGE_SIZE};
my $file= "$ENV{bugdir}/ibdata1";
open(FILE, "+<", $file) || die "Unable to open $file\n";
# Read DICT_HDR_TABLES, the root page number of CLUST_IND (SYS_TABLES.NAME).
sysseek(FILE, 7*$ps+38+32, 0) || die "Unable to seek $file";
die "Unable to read $file" unless sysread(FILE, $_, 4) == 4;
my $sys_tables_root = unpack("N", $_);
my $page;
print "SYS_TABLES clustered index root page ($sys_tables_root):\n";
sysseek(FILE, $sys_tables_root*$ps, 0) || die "Unable to seek $file";
die "Unable to read $file" unless sysread(FILE, $page, $ps) == $ps;
open(BACKUP, ">$ENV{bugdir}/sys_tables.bin") || die "Unable to open backup\n";
syswrite(BACKUP, $page, $ps)==$ps || die "Unable to write backup\n";
close(BACKUP) || die "Unable to close backup\n";
print "N_RECS=", unpack("n", substr($page,38+16,2));
print "; LEVEL=", unpack("n", substr($page,38+26,2));
print "; INDEX_ID=0x", unpack("H*", substr($page,38+28,8)), "\n";
my @fields=("NAME","DB_TRX_ID","DB_ROLL_PTR",
"ID","N_COLS","TYPE","MIX_ID","MIX_LEN","CLUSTER_NAME","SPACE");
for (my $offset= 0x65; $offset;
$offset= unpack("n", substr($page,$offset-2,2)))
{
print "header=0x", unpack("H*",substr($page,$offset-6,6)), " (";
my $n_fields= unpack("n", substr($page,$offset-4,2)) >> 1 & 0x3ff;
my $start= 0;
my $name;
for (my $i= 0; $i < $n_fields; $i++) {
my $end= unpack("C", substr($page, $offset-7-$i, 1));
print ",\n " if $i;
print "$fields[$i]=";
if ($end & 0x80) {
print "NULL(", ($end & 0x7f) - $start, " bytes)"
} elsif ($n_fields > 1 && $i == 0) {
$name= substr($page,$offset+$start,$end-$start);
print "'$name'"
} else {
print "0x", unpack("H*", substr($page,$offset+$start,$end-$start))
}
# Corrupt SYS_TABLES.TYPE
if ($i == 5)
{
my $flags= 0;
if ($name eq 'test/tr') {
$flags= 0x40 # DATA_DIR (largely ignored by 10.1+)
} elsif ($name eq 'test/tc') {
$flags= 0x80 # 10.1 PAGE_COMPRESSED
} elsif ($name eq 'test/td') {
$flags= 0xf00 # PAGE_COMPRESSION_LEVEL=15 (0..9 is valid)
# As part of the MDEV-12873 fix, because the
# PAGE_COMPRESSED=YES flag was not set, we will assume that
# this table was actually created with 10.2.2..10.2.6
# using PAGE_COMPRESSED=YES PAGE_COMPRESSION_LEVEL=7.
} elsif ($name eq 'test/tz') {
$flags= 0x3000 # 10.1 ATOMIC_WRITES=3 (0..2 is valid)
} elsif ($name eq 'test/tp') {
$flags= 0x880 # 10.1 PAGE_COMPRESSED, PAGE_COMPRESSION_LEVEL=8
# (in 10.2.2 through 10.2.6, this is interpreted as
# PAGE_COMPRESSION_LEVEL=4 without PAGE_COMPRESSED
# but with SHARED_SPACE, which should be invalid)
}
substr($page,$offset+$start,$end-$start)= pack(
"N", $flags ^
unpack("N", substr($page,$offset+$start,$end-$start)))
if $flags;
}
# Corrupt SYS_TABLES.MIX_LEN (ignored for ROW_FORMAT=REDUNDANT)
if ($i == 7 && $name eq 'test/tr')
{
substr($page,$offset+$start,$end-$start)= chr(255) x 4;
}
$start= $end & 0x7f;
}
print ")\n";
}
substr($page,0,4)=pack("N",0xdeadbeef);
substr($page,$ps-8,4)=pack("N",0xdeadbeef);
sysseek(FILE, $sys_tables_root*$ps, 0) || die "Unable to seek $file";
syswrite(FILE, $page, $ps)==$ps || die "Unable to write $file\n";
close(FILE) || die "Unable to close $file\n";
EOF
--source include/start_mysqld.inc
--error ER_NO_SUCH_TABLE_IN_ENGINE
SHOW CREATE TABLE tr;
--error ER_NO_SUCH_TABLE_IN_ENGINE
SHOW CREATE TABLE tc;
--error ER_NO_SUCH_TABLE_IN_ENGINE
SHOW CREATE TABLE td;
# This table was converted to NO_ROLLBACK due to the SYS_TABLES.TYPE change.
SHOW CREATE TABLE tz;
BEGIN;
INSERT INTO tz VALUES(42);
ROLLBACK;
SELECT * FROM tz;
--error ER_NO_SUCH_TABLE_IN_ENGINE
SHOW CREATE TABLE tp;
--source include/shutdown_mysqld.inc
let SEARCH_FILE= $MYSQLTEST_VARDIR/log/mysqld.1.err;
--let SEARCH_PATTERN= InnoDB: Table `test`.`t[cp]` in InnoDB data dictionary contains invalid flags\. SYS_TABLES\.TYPE=(129|289|3873|1232[13]) SYS_TABLES\.N_COLS=2147483649
--source include/search_pattern_in_file.inc
--let SEARCH_PATTERN= InnoDB: Refusing to load '\..test.td\.ibd' \(id=3, flags=0x1?[2ae]1\); dictionary contains id=3, flags=0x10[01][2ae]1\b
--source include/search_pattern_in_file.inc
--let SEARCH_PATTERN= InnoDB: Table `test`\.`tr` in InnoDB data dictionary contains invalid flags\. SYS_TABLES\.TYPE=65 SYS_TABLES\.MIX_LEN=4294967295\b
--source include/search_pattern_in_file.inc
# Restore the backup of the corrupted SYS_TABLES clustered index root page
--perl
use strict;
my $ps= $ENV{INNODB_PAGE_SIZE};
my $file= "$ENV{bugdir}/ibdata1";
open(FILE, "+<", $file) || die "Unable to open $file\n";
open(BACKUP, "<$ENV{bugdir}/sys_tables.bin") || die "Unable to open backup\n";
# Read DICT_HDR_TABLES, the root page number of CLUST_IND (SYS_TABLES.NAME).
sysseek(FILE, 7*$ps+38+32, 0) || die "Unable to seek $file";
die "Unable to read $file\n" unless sysread(FILE, $_, 4) == 4;
my $sys_tables_root = unpack("N", $_);
print "Restoring SYS_TABLES clustered index root page ($sys_tables_root)\n";
sysseek(FILE, $sys_tables_root*$ps, 0) || die "Unable to seek $file";
die "Unable to read backup\n" unless sysread(BACKUP, $_, $ps) == $ps;
die "Unable to restore backup\n" unless syswrite(FILE, $_, $ps) == $ps;
close(BACKUP);
close(FILE) || die "Unable to close $file\n";
EOF
--source include/start_mysqld.inc
SHOW CREATE TABLE tr;
SHOW CREATE TABLE tc;
SHOW CREATE TABLE td;
SHOW CREATE TABLE tz;
SHOW CREATE TABLE tp;
BEGIN;
INSERT INTO tr VALUES(1);
INSERT INTO tc VALUES(1);
INSERT INTO td VALUES(1);
# We cannot access tz, because due to our fiddling of the NO_ROLLBACK flag,
# it now has a record with DB_TRX_ID=0, which is invalid for
# transactional tables until MDEV-12288 is implemented.
# INSERT INTO tz VALUES(1);
INSERT INTO tp VALUES(1);
ROLLBACK;
SELECT * FROM tr;
SELECT * FROM tc;
SELECT * FROM td;
# SELECT * FROM tz;
SELECT * FROM tp;
DROP TABLE tr,tc,td,tz,tp;
--let $restart_parameters=
--source include/restart_mysqld.inc
--list_files $bugdir
--remove_files_wildcard $bugdir
--rmdir $bugdir

View File

@ -23,3 +23,16 @@ select next value for s1;
ERROR HY000: Table 's1' is read only
select next value for s1;
ERROR HY000: Table 's1' is read only
select * from s1;
next_not_cached_value minimum_value maximum_value start_value increment cache_size cycle_option cycle_count
1 1 9223372036854775806 1 1 2 0 0
select * from s1;
next_not_cached_value minimum_value maximum_value start_value increment cache_size cycle_option cycle_count
1 1 9223372036854775806 1 1 2 0 0
select next value for s1;
next value for s1
1
select * from s1;
next_not_cached_value minimum_value maximum_value start_value increment cache_size cycle_option cycle_count
3 1 9223372036854775806 1 1 2 0 0
drop sequence s1;

View File

@ -7,12 +7,8 @@
create sequence s1 cache 2 engine=innodb;
--exec echo "wait" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
--shutdown_server 10
--source include/wait_until_disconnected.inc
--enable_reconnect
--exec echo "restart":--innodb_read_only=1 > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
--source include/wait_until_connected_again.inc
--let $restart_parameters= --innodb-read-only
--source include/restart_mysqld.inc
connection default;
show global variables like 'innodb_read_only';
@ -38,3 +34,11 @@ select next value for s1;
select next value for s1;
--error ER_OPEN_AS_READONLY
select next value for s1;
select * from s1;
--let $restart_parameters=
--source include/restart_mysqld.inc
select * from s1;
select next value for s1;
select * from s1;
drop sequence s1;

View File

@ -2867,9 +2867,9 @@ READ_ONLY YES
COMMAND_LINE_ARGUMENT REQUIRED
VARIABLE_NAME PERFORMANCE_SCHEMA_MAX_STATEMENT_CLASSES
SESSION_VALUE NULL
GLOBAL_VALUE 190
GLOBAL_VALUE 191
GLOBAL_VALUE_ORIGIN COMPILE-TIME
DEFAULT_VALUE 190
DEFAULT_VALUE 191
VARIABLE_SCOPE GLOBAL
VARIABLE_TYPE BIGINT UNSIGNED
VARIABLE_COMMENT Maximum number of statement instruments.

View File

@ -3063,9 +3063,9 @@ READ_ONLY YES
COMMAND_LINE_ARGUMENT REQUIRED
VARIABLE_NAME PERFORMANCE_SCHEMA_MAX_STATEMENT_CLASSES
SESSION_VALUE NULL
GLOBAL_VALUE 190
GLOBAL_VALUE 191
GLOBAL_VALUE_ORIGIN COMPILE-TIME
DEFAULT_VALUE 190
DEFAULT_VALUE 191
VARIABLE_SCOPE GLOBAL
VARIABLE_TYPE BIGINT UNSIGNED
VARIABLE_COMMENT Maximum number of statement instruments.

View File

@ -3636,7 +3636,7 @@ Item_param::Item_param(THD *thd, const LEX_CSTRING *name_arg,
state(NO_VALUE),
/* Don't pretend to be a literal unless value for this item is set. */
item_type(PARAM_ITEM),
indicators(0), indicator(STMT_INDICATOR_NONE),
indicator(STMT_INDICATOR_NONE),
set_param_func(default_set_param_func),
m_out_param_info(NULL),
/*

View File

@ -3066,10 +3066,8 @@ public:
};
/*
Used for bulk protocol. Indicates if we should expect
indicators byte before value of the parameter
Used for bulk protocol only.
*/
my_bool indicators;
enum enum_indicator_type indicator;
/*

View File

@ -699,9 +699,9 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
bool using_bulk_insert= 0;
uint value_count;
ulong counter = 1;
ulong iteration= 0;
/* counter of iteration in bulk PS operation*/
ulonglong iteration= 0;
ulonglong id;
ulong bulk_iterations= bulk_parameters_iterations(thd);
COPY_INFO info;
TABLE *table= 0;
List_iterator_fast<List_item> its(values_list);
@ -769,7 +769,6 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
DBUG_RETURN(TRUE);
value_count= values->elements;
DBUG_ASSERT(bulk_iterations > 0);
if (mysql_prepare_insert(thd, table_list, table, fields, values,
update_fields, update_values, duplic, &unused_conds,
FALSE))
@ -941,6 +940,7 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
}
do
{
DBUG_PRINT("info", ("iteration %llu", iteration));
if (iteration && bulk_parameters_set(thd))
goto abort;
@ -1061,7 +1061,7 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
}
its.rewind();
iteration++;
} while (iteration < bulk_iterations);
} while (bulk_parameters_iterations(thd));
values_loop_end:
free_underlaid_joins(thd, &thd->lex->select_lex);
@ -1208,7 +1208,7 @@ values_loop_end:
retval= thd->lex->explain->send_explain(thd);
goto abort;
}
if ((bulk_iterations * values_list.elements) == 1 && (!(thd->variables.option_bits & OPTION_WARNINGS) ||
if ((iteration * values_list.elements) == 1 && (!(thd->variables.option_bits & OPTION_WARNINGS) ||
!thd->cuted_fields))
{
my_ok(thd, info.copied + info.deleted +

View File

@ -392,7 +392,7 @@ const LEX_STRING command_name[257]={
{ 0, 0 }, //247
{ 0, 0 }, //248
{ 0, 0 }, //249
{ 0, 0 }, //250
{ C_STRING_WITH_LEN("Bulk_execute") }, //250
{ C_STRING_WITH_LEN("Slave_worker") }, //251
{ C_STRING_WITH_LEN("Slave_IO") }, //252
{ C_STRING_WITH_LEN("Slave_SQL") }, //253
@ -1754,6 +1754,11 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
}
break;
}
case COM_STMT_BULK_EXECUTE:
{
mysqld_stmt_bulk_execute(thd, packet, packet_length);
break;
}
case COM_STMT_EXECUTE:
{
mysqld_stmt_execute(thd, packet, packet_length);

View File

@ -164,7 +164,6 @@ public:
Server_side_cursor *cursor;
uchar *packet;
uchar *packet_end;
ulong iterations;
uint param_count;
uint last_errno;
uint flags;
@ -183,7 +182,9 @@ public:
*/
uint select_number_after_prepare;
char last_error[MYSQL_ERRMSG_SIZE];
my_bool iterations;
my_bool start_param;
my_bool read_types;
#ifndef EMBEDDED_LIBRARY
bool (*set_params)(Prepared_statement *st, uchar *data, uchar *data_end,
uchar *read_pos, String *expanded_query);
@ -213,11 +214,10 @@ public:
uchar *packet_arg, uchar *packet_end_arg);
bool execute_bulk_loop(String *expanded_query,
bool open_cursor,
uchar *packet_arg, uchar *packet_end_arg,
ulong iterations);
uchar *packet_arg, uchar *packet_end_arg);
bool execute_server_runnable(Server_runnable *server_runnable);
my_bool set_bulk_parameters(bool reset);
ulong bulk_iterations();
bool bulk_iterations() { return iterations; };
/* Destroy this statement */
void deallocate();
bool execute_immediate(const char *query, uint query_length);
@ -923,6 +923,7 @@ static bool insert_params(Prepared_statement *stmt, uchar *null_array,
for (Item_param **it= begin; it < end; ++it)
{
Item_param *param= *it;
param->indicator= STMT_INDICATOR_NONE; // only for bulk parameters
if (!param->has_long_data_value())
{
if (is_param_null(null_array, (uint) (it - begin)))
@ -967,10 +968,7 @@ static bool insert_bulk_params(Prepared_statement *stmt,
param->reset();
if (!param->has_long_data_value())
{
if (param->indicators)
param->indicator= (enum_indicator_type) *((*read_pos)++);
else
param->indicator= STMT_INDICATOR_NONE;
param->indicator= (enum_indicator_type) *((*read_pos)++);
if ((*read_pos) > data_end)
DBUG_RETURN(1);
switch (param->indicator)
@ -981,6 +979,8 @@ static bool insert_bulk_params(Prepared_statement *stmt,
param->set_param_func(param, read_pos, (uint) (data_end - (*read_pos)));
if (param->has_no_value())
DBUG_RETURN(1);
if (param->convert_str_value(stmt->thd))
DBUG_RETURN(1); /* out of memory */
break;
case STMT_INDICATOR_NULL:
param->set_null();
@ -999,6 +999,36 @@ static bool insert_bulk_params(Prepared_statement *stmt,
DBUG_RETURN(0);
}
static bool set_conversion_functions(Prepared_statement *stmt,
uchar **data, uchar *data_end)
{
uchar *read_pos= *data;
const uint signed_bit= 1 << 15;
DBUG_ENTER("set_conversion_functions");
/*
First execute or types altered by the client, setup the
conversion routines for all parameters (one time)
*/
Item_param **it= stmt->param_array;
Item_param **end= it + stmt->param_count;
THD *thd= stmt->thd;
for (; it < end; ++it)
{
ushort typecode;
if (read_pos >= data_end)
DBUG_RETURN(1);
typecode= sint2korr(read_pos);
read_pos+= 2;
(**it).unsigned_flag= MY_TEST(typecode & signed_bit);
setup_one_conversion_function(thd, *it, (uchar) (typecode & 0xff));
}
*data= read_pos;
DBUG_RETURN(0);
}
static bool setup_conversion_functions(Prepared_statement *stmt,
uchar **data, uchar *data_end,
bool bulk_protocol= 0)
@ -1012,30 +1042,9 @@ static bool setup_conversion_functions(Prepared_statement *stmt,
if (*read_pos++) //types supplied / first execute
{
/*
First execute or types altered by the client, setup the
conversion routines for all parameters (one time)
*/
Item_param **it= stmt->param_array;
Item_param **end= it + stmt->param_count;
THD *thd= stmt->thd;
for (; it < end; ++it)
{
ushort typecode;
const uint signed_bit= 1 << 15;
const uint indicators_bit= 1 << 14;
if (read_pos >= data_end)
DBUG_RETURN(1);
typecode= sint2korr(read_pos);
read_pos+= 2;
(**it).unsigned_flag= MY_TEST(typecode & signed_bit);
if (bulk_protocol)
(**it).indicators= MY_TEST(typecode & indicators_bit);
setup_one_conversion_function(thd, *it,
(uchar) (typecode & 0xff));
}
*data= read_pos;
bool res= set_conversion_functions(stmt, data, data_end);
DBUG_RETURN(res);
}
*data= read_pos;
DBUG_RETURN(0);
@ -3022,6 +3031,14 @@ static void reset_stmt_params(Prepared_statement *stmt)
}
static void mysql_stmt_execute_common(THD *thd,
ulong stmt_id,
uchar *packet,
uchar *packet_end,
ulong cursor_flags,
bool iteration,
bool types);
/**
COM_STMT_EXECUTE handler: execute a previously prepared statement.
@ -3044,21 +3061,92 @@ void mysqld_stmt_execute(THD *thd, char *packet_arg, uint packet_length)
uchar *packet= (uchar*)packet_arg; // GCC 4.0.1 workaround
ulong stmt_id= uint4korr(packet);
ulong flags= (ulong) packet[4];
#ifndef EMBEDDED_LIBRARY
ulong iterations= uint4korr(packet + 5);
#else
ulong iterations= 0; // no support
#endif
/* Query text for binary, general or slow log, if any of them is open */
String expanded_query;
uchar *packet_end= packet + packet_length;
Prepared_statement *stmt;
Protocol *save_protocol= thd->protocol;
bool open_cursor;
DBUG_ENTER("mysqld_stmt_execute");
packet+= 9; /* stmt_id + 5 bytes of flags */
mysql_stmt_execute_common(thd, stmt_id, packet, packet_end, flags, FALSE,
FALSE);
DBUG_VOID_RETURN;
}
/**
COM_STMT_BULK_EXECUTE handler: execute a previously prepared statement.
If there are any parameters, then replace parameter markers with the
data supplied from the client, and then execute the statement.
This function uses binary protocol to send a possible result set
to the client.
@param thd current thread
@param packet_arg parameter types and data, if any
@param packet_length packet length, including the terminator character.
@return
none: in case of success OK packet or a result set is sent to the
client, otherwise an error message is set in THD.
*/
void mysqld_stmt_bulk_execute(THD *thd, char *packet_arg, uint packet_length)
{
uchar *packet= (uchar*)packet_arg; // GCC 4.0.1 workaround
ulong stmt_id= uint4korr(packet);
uint flags= (uint) uint2korr(packet + 4);
uchar *packet_end= packet + packet_length;
DBUG_ENTER("mysqld_stmt_execute_bulk");
if (!(thd->client_capabilities &
MARIADB_CLIENT_STMT_BULK_OPERATIONS))
{
DBUG_PRINT("error",
("An attempt to execute bulk operation without support"));
my_error(ER_UNSUPPORTED_PS, MYF(0));
}
/* Check for implemented parameters */
if (flags & (~STMT_BULK_FLAG_CLIENT_SEND_TYPES))
{
DBUG_PRINT("error", ("unsupported bulk execute flags %x", flags));
my_error(ER_UNSUPPORTED_PS, MYF(0));
}
/* stmt id and two bytes of flags */
packet+= 4 + 2;
mysql_stmt_execute_common(thd, stmt_id, packet, packet_end, 0, TRUE,
(flags & STMT_BULK_FLAG_CLIENT_SEND_TYPES));
DBUG_VOID_RETURN;
}
/**
Common part of prepared statement execution
@param thd THD handle
@param stmt_id id of the prepared statement
@param paket packet with parameters to bind
@param packet_end pointer to the byte after parameters end
@param cursor_flags cursor flags
@param bulk_op id it bulk operation
@param read_types flag say that types muast been read
*/
static void mysql_stmt_execute_common(THD *thd,
ulong stmt_id,
uchar *packet,
uchar *packet_end,
ulong cursor_flags,
bool bulk_op,
bool read_types)
{
/* Query text for binary, general or slow log, if any of them is open */
String expanded_query;
Prepared_statement *stmt;
Protocol *save_protocol= thd->protocol;
bool open_cursor;
DBUG_ENTER("mysqld_stmt_execute_common");
DBUG_ASSERT((!read_types) || (read_types && bulk_op));
/* First of all clear possible warnings from the previous command */
thd->reset_for_next_command();
@ -3069,21 +3157,21 @@ void mysqld_stmt_execute(THD *thd, char *packet_arg, uint packet_length)
llstr(stmt_id, llbuf), "mysqld_stmt_execute");
DBUG_VOID_RETURN;
}
stmt->read_types= read_types;
#if defined(ENABLED_PROFILING)
thd->profiling.set_query_source(stmt->query(), stmt->query_length());
#endif
DBUG_PRINT("exec_query", ("%s", stmt->query()));
DBUG_PRINT("info",("stmt: %p iterations: %lu", stmt, iterations));
DBUG_PRINT("info",("stmt: %p bulk_op %d", stmt, bulk_op));
open_cursor= MY_TEST(flags & (ulong) CURSOR_TYPE_READ_ONLY);
open_cursor= MY_TEST(cursor_flags & (ulong) CURSOR_TYPE_READ_ONLY);
thd->protocol= &thd->protocol_binary;
if (iterations <= 1)
if (!bulk_op)
stmt->execute_loop(&expanded_query, open_cursor, packet, packet_end);
else
stmt->execute_bulk_loop(&expanded_query, open_cursor, packet, packet_end,
iterations);
stmt->execute_bulk_loop(&expanded_query, open_cursor, packet, packet_end);
thd->protocol= save_protocol;
sp_cache_enforce_limit(thd->sp_proc_cache, stored_program_cache_size);
@ -3590,11 +3678,12 @@ Prepared_statement::Prepared_statement(THD *thd_arg)
cursor(0),
packet(0),
packet_end(0),
iterations(0),
param_count(0),
last_errno(0),
flags((uint) IS_IN_USE),
iterations(0),
start_param(0),
read_types(0),
m_sql_mode(thd->variables.sql_mode)
{
init_sql_alloc(&main_mem_root, thd_arg->variables.query_alloc_block_size,
@ -3631,7 +3720,7 @@ void Prepared_statement::setup_set_params()
set_params_from_actual_params= insert_params_from_actual_params_with_log;
#ifndef EMBEDDED_LIBRARY
set_params= insert_params_with_log;
set_bulk_params= insert_bulk_params; // TODO: add binlog support
set_bulk_params= insert_bulk_params; // RBR is on for bulk operation
#else
//TODO: add bulk support for bulk parameters
set_params_data= emb_insert_params_with_log;
@ -4013,7 +4102,7 @@ Prepared_statement::execute_loop(String *expanded_query,
Reprepare_observer reprepare_observer;
bool error;
int reprepare_attempt= 0;
iterations= 0;
iterations= FALSE;
/*
- In mysql_sql_stmt_execute() we hide all "external" Items
@ -4116,11 +4205,11 @@ my_bool bulk_parameters_set(THD *thd)
DBUG_RETURN(FALSE);
}
ulong bulk_parameters_iterations(THD *thd)
my_bool bulk_parameters_iterations(THD *thd)
{
Prepared_statement *stmt= (Prepared_statement *) thd->bulk_param;
if (!stmt)
return 1;
return FALSE;
return stmt->bulk_iterations();
}
@ -4128,7 +4217,8 @@ ulong bulk_parameters_iterations(THD *thd)
my_bool Prepared_statement::set_bulk_parameters(bool reset)
{
DBUG_ENTER("Prepared_statement::set_bulk_parameters");
DBUG_PRINT("info", ("iteration: %lu", iterations));
DBUG_PRINT("info", ("iteration: %d", iterations));
if (iterations)
{
#ifndef EMBEDDED_LIBRARY
@ -4142,31 +4232,24 @@ my_bool Prepared_statement::set_bulk_parameters(bool reset)
reset_stmt_params(this);
DBUG_RETURN(true);
}
iterations--;
if (packet >= packet_end)
iterations= FALSE;
}
start_param= 0;
DBUG_RETURN(false);
}
ulong Prepared_statement::bulk_iterations()
{
if (iterations)
return iterations;
return start_param ? 1 : 0;
}
bool
Prepared_statement::execute_bulk_loop(String *expanded_query,
bool open_cursor,
uchar *packet_arg,
uchar *packet_end_arg,
ulong iterations_arg)
uchar *packet_end_arg)
{
Reprepare_observer reprepare_observer;
bool error= 0;
packet= packet_arg;
packet_end= packet_end_arg;
iterations= iterations_arg;
iterations= TRUE;
start_param= true;
#ifndef DBUG_OFF
Item *free_list_state= thd->free_list;
@ -4180,16 +4263,26 @@ Prepared_statement::execute_bulk_loop(String *expanded_query,
thd->set_bulk_execution(0);
return TRUE;
}
/* Check for non zero parameter count*/
if (param_count == 0)
{
DBUG_PRINT("error", ("Statement with no parameters for bulk execution."));
my_error(ER_UNSUPPORTED_PS, MYF(0));
thd->set_bulk_execution(0);
return TRUE;
}
if (!(sql_command_flags[lex->sql_command] & CF_SP_BULK_SAFE))
{
DBUG_PRINT("error", ("Command is not supported in bulk execution."));
my_error(ER_UNSUPPORTED_PS, MYF(0));
thd->set_bulk_execution(0);
return TRUE;
}
#ifndef EMBEDDED_LIBRARY
if (setup_conversion_functions(this, &packet, packet_end, TRUE))
if (read_types &&
set_conversion_functions(this, &packet, packet_end))
#else
// bulk parameters are not supported for embedded, so it will an error
#endif
@ -4200,6 +4293,7 @@ Prepared_statement::execute_bulk_loop(String *expanded_query,
thd->set_bulk_execution(0);
return true;
}
read_types= FALSE;
#ifdef NOT_YET_FROM_MYSQL_5_6
if (unlikely(thd->security_ctx->password_expired &&

View File

@ -72,6 +72,7 @@ private:
void mysqld_stmt_prepare(THD *thd, const char *packet, uint packet_length);
void mysqld_stmt_execute(THD *thd, char *packet, uint packet_length);
void mysqld_stmt_execute_bulk(THD *thd, char *packet, uint packet_length);
void mysqld_stmt_bulk_execute(THD *thd, char *packet, uint packet_length);
void mysqld_stmt_close(THD *thd, char *packet);
void mysql_sql_stmt_prepare(THD *thd);
@ -83,7 +84,7 @@ void mysqld_stmt_reset(THD *thd, char *packet);
void mysql_stmt_get_longdata(THD *thd, char *pos, ulong packet_length);
void reinit_stmt_before_use(THD *thd, LEX *lex);
ulong bulk_parameters_iterations(THD *thd);
my_bool bulk_parameters_iterations(THD *thd);
my_bool bulk_parameters_set(THD *thd);
/**
Execute a fragment of server code in an isolated context, so that

View File

@ -171,7 +171,8 @@ btr_root_block_get(
if (index && index->table) {
index->table->file_unreadable = true;
ib_push_warning(index->table->thd, DB_DECRYPTION_FAILED,
ib_push_warning(
static_cast<THD*>(NULL), DB_DECRYPTION_FAILED,
"Table %s in tablespace %lu is encrypted but encryption service or"
" used key_id is not available. "
" Can't continue reading table.",

View File

@ -1129,6 +1129,67 @@ dict_sys_tablespaces_rec_read(
return(true);
}
/** Check if SYS_TABLES.TYPE is valid
@param[in] type SYS_TABLES.TYPE
@param[in] not_redundant whether ROW_FORMAT=REDUNDANT is not used
@return whether the SYS_TABLES.TYPE value is valid */
static
bool
dict_sys_tables_type_valid(ulint type, bool not_redundant)
{
/* The DATA_DIRECTORY flag can be assigned fully independently
of all other persistent table flags. */
type &= ~DICT_TF_MASK_DATA_DIR;
if (type == 1) {
return(true); /* ROW_FORMAT=REDUNDANT or ROW_FORMAT=COMPACT */
}
if (!(type & 1)) {
/* For ROW_FORMAT=REDUNDANT and ROW_FORMAT=COMPACT,
SYS_TABLES.TYPE=1. Else, it is the same as
dict_table_t::flags, and the least significant bit
would be set. So, the bit never can be 0. */
return(false);
}
if (!not_redundant) {
/* SYS_TABLES.TYPE must be 1 for ROW_FORMAT=REDUNDANT. */
return(false);
}
if (type >= 1U << DICT_TF_POS_UNUSED) {
/* Some unknown bits are set. */
return(false);
}
return(dict_tf_is_valid_not_redundant(type));
}
/** Convert SYS_TABLES.TYPE to dict_table_t::flags.
@param[in] type SYS_TABLES.TYPE
@param[in] not_redundant whether ROW_FORMAT=REDUNDANT is not used
@return table flags */
static
ulint
dict_sys_tables_type_to_tf(ulint type, bool not_redundant)
{
ut_ad(dict_sys_tables_type_valid(type, not_redundant));
ulint flags = not_redundant ? 1 : 0;
/* ZIP_SSIZE, ATOMIC_BLOBS, DATA_DIR, PAGE_COMPRESSION,
PAGE_COMPRESSION_LEVEL are the same. */
flags |= type & (DICT_TF_MASK_ZIP_SSIZE
| DICT_TF_MASK_ATOMIC_BLOBS
| DICT_TF_MASK_DATA_DIR
| DICT_TF_MASK_PAGE_COMPRESSION
| DICT_TF_MASK_PAGE_COMPRESSION_LEVEL
| DICT_TF_MASK_NO_ROLLBACK);
ut_ad(dict_tf_is_valid(flags));
return(flags);
}
/** Read and return 5 integer fields from a SYS_TABLES record.
@param[in] rec A record of SYS_TABLES
@param[in] name Table Name, the same as SYS_TABLES.NAME
@ -1170,6 +1231,79 @@ dict_sys_tables_rec_read(
ut_a(len == 4);
type = mach_read_from_4(field);
/* Handle MDEV-12873 InnoDB SYS_TABLES.TYPE incompatibility
for PAGE_COMPRESSED=YES in MariaDB 10.2.2 to 10.2.6.
MariaDB 10.2.2 introduced the SHARED_SPACE flag from MySQL 5.7,
shifting the flags PAGE_COMPRESSION, PAGE_COMPRESSION_LEVEL,
ATOMIC_WRITES (repurposed to NO_ROLLBACK in 10.3.1) by one bit.
The SHARED_SPACE flag would always
be written as 0 by MariaDB, because MariaDB does not support
CREATE TABLESPACE or CREATE TABLE...TABLESPACE for InnoDB.
So, instead of the bits AALLLLCxxxxxxx we would have
AALLLLC0xxxxxxx if the table was created with MariaDB 10.2.2
to 10.2.6. (AA=ATOMIC_WRITES, LLLL=PAGE_COMPRESSION_LEVEL,
C=PAGE_COMPRESSED, xxxxxxx=7 bits that were not moved.)
The case LLLLC=00000 is not a problem. The problem is the case
AALLLL10DB00001 where D is the (mostly ignored) DATA_DIRECTORY
flag and B is the ATOMIC_BLOBS flag (1 for ROW_FORMAT=DYNAMIC
and 0 for ROW_FORMAT=COMPACT in this case). Other low-order
bits must be so, because PAGE_COMPRESSED=YES is only allowed
for ROW_FORMAT=DYNAMIC and ROW_FORMAT=COMPACT, not for
ROW_FORMAT=REDUNDANT or ROW_FORMAT=COMPRESSED.
Starting with MariaDB 10.2.4, the flags would be
00LLLL10DB00001, because ATOMIC_WRITES is always written as 0.
We will concentrate on the PAGE_COMPRESSION_LEVEL and
PAGE_COMPRESSED=YES. PAGE_COMPRESSED=NO implies
PAGE_COMPRESSION_LEVEL=0, and in that case all the affected
bits will be 0. For PAGE_COMPRESSED=YES, the values 1..9 are
allowed for PAGE_COMPRESSION_LEVEL. That is, we must interpret
the bits AALLLL10DB00001 as AALLLL1DB00001.
If someone created a table in MariaDB 10.2.2 or 10.2.3 with
the attribute ATOMIC_WRITES=OFF (value 2) and without
PAGE_COMPRESSED=YES or PAGE_COMPRESSION_LEVEL, that should be
rejected. The value ATOMIC_WRITES=ON (1) would look like
ATOMIC_WRITES=OFF, but it would be ignored starting with
MariaDB 10.2.4. */
compile_time_assert(DICT_TF_POS_PAGE_COMPRESSION == 7);
compile_time_assert(DICT_TF_POS_UNUSED == 14);
if ((type & 0x19f) != 0x101) {
/* The table cannot have been created with MariaDB
10.2.2 to 10.2.6, because they would write the
low-order bits of SYS_TABLES.TYPE as 0b10xx00001 for
PAGE_COMPRESSED=YES. No adjustment is applicable. */
} else if (type >= 3 << 13) {
/* 10.2.2 and 10.2.3 write ATOMIC_WRITES less than 3,
and no other flags above that can be set for the
SYS_TABLES.TYPE to be in the 10.2.2..10.2.6 format.
This would in any case be invalid format for 10.2 and
earlier releases. */
ut_ad(!dict_sys_tables_type_valid(type, true));
} else {
/* SYS_TABLES.TYPE is of the form AALLLL10DB00001. We
must still validate that the LLLL bits are between 0
and 9 before we can discard the extraneous 0 bit. */
ut_ad(!DICT_TF_GET_PAGE_COMPRESSION(type));
if ((((type >> 9) & 0xf) - 1) < 9) {
ut_ad(DICT_TF_GET_PAGE_COMPRESSION_LEVEL(type) & 1);
type = (type & 0x7fU) | (type >> 1 & ~0x7fU);
ut_ad(DICT_TF_GET_PAGE_COMPRESSION(type));
ut_ad(DICT_TF_GET_PAGE_COMPRESSION_LEVEL(type) >= 1);
ut_ad(DICT_TF_GET_PAGE_COMPRESSION_LEVEL(type) <= 9);
} else {
ut_ad(!dict_sys_tables_type_valid(type, true));
}
}
/* The low order bit of SYS_TABLES.TYPE is always set to 1. But in
dict_table_t::flags the low order bit is used to determine if the
row format is Redundant (0) or Compact (1) when the format is Antelope.
@ -1181,11 +1315,9 @@ dict_sys_tables_rec_read(
ut_a(len == 4);
*n_cols = mach_read_from_4(field);
/* This validation function also combines the DICT_N_COLS_COMPACT
flag in n_cols into the type field to effectively make it a
dict_table_t::flags. */
const bool not_redundant = 0 != (*n_cols & DICT_N_COLS_COMPACT);
if (ULINT_UNDEFINED == dict_sys_tables_type_validate(type, *n_cols)) {
if (!dict_sys_tables_type_valid(type, not_redundant)) {
ib::error() << "Table " << table_name << " in InnoDB"
" data dictionary contains invalid flags."
" SYS_TABLES.TYPE=" << type <<
@ -1193,7 +1325,7 @@ dict_sys_tables_rec_read(
return(false);
}
*flags = dict_sys_tables_type_to_tf(type, *n_cols);
*flags = dict_sys_tables_type_to_tf(type, not_redundant);
/* For tables created before MySQL 4.1, there may be
garbage in SYS_TABLES.MIX_LEN where flags2 are found. Such tables
@ -1201,7 +1333,7 @@ dict_sys_tables_rec_read(
high bit set in n_cols, and flags would be zero.
MySQL 4.1 was the first version to support innodb_file_per_table,
that is, *space_id != 0. */
if (*flags != 0 || *space_id != 0 || *n_cols & DICT_N_COLS_COMPACT) {
if (not_redundant || *space_id != 0 || *n_cols & DICT_N_COLS_COMPACT) {
/* Get flags2 from SYS_TABLES.MIX_LEN */
field = rec_get_nth_field_old(
@ -1211,7 +1343,8 @@ dict_sys_tables_rec_read(
if (!dict_tf2_is_valid(*flags, *flags2)) {
ib::error() << "Table " << table_name << " in InnoDB"
" data dictionary contains invalid flags."
" SYS_TABLES.MIX_LEN=" << *flags2;
" SYS_TABLES.TYPE=" << type
<< " SYS_TABLES.MIX_LEN=" << *flags2;
return(false);
}
@ -1312,7 +1445,7 @@ dict_check_sys_tables(
look to see if it is already in the tablespace cache. */
if (fil_space_for_table_exists_in_mem(
space_id, table_name.m_name,
false, true, NULL, 0, NULL, flags)) {
false, true, NULL, 0, flags)) {
/* Recovery can open a datafile that does not
match SYS_DATAFILES. If they don't match, update
SYS_DATAFILES. */
@ -1344,8 +1477,7 @@ dict_check_sys_tables(
FIL_TYPE_TABLESPACE,
space_id, dict_tf_to_fsp_flags(flags),
table_name.m_name,
filepath,
NULL);
filepath);
if (err != DB_SUCCESS) {
ib::warn() << "Ignoring tablespace for "
@ -2541,8 +2673,7 @@ dict_load_table_low(table_name_t& name, const rec_t* rec, dict_table_t** table)
ulint flags2;
ulint n_v_col;
const char* error_text = dict_sys_tables_rec_check(rec);
if (error_text != NULL) {
if (const char* error_text = dict_sys_tables_rec_check(rec)) {
return(error_text);
}
@ -2723,7 +2854,7 @@ dict_load_tablespace(
/* The tablespace may already be open. */
if (fil_space_for_table_exists_in_mem(
table->space, space_name, false,
true, heap, table->id, table, table->flags)) {
true, heap, table->id, table->flags)) {
return;
}
@ -2755,7 +2886,7 @@ dict_load_tablespace(
dberr_t err = fil_ibd_open(
true, false, FIL_TYPE_TABLESPACE, table->space,
dict_tf_to_fsp_flags(table->flags),
space_name, filepath, table);
space_name, filepath);
if (err != DB_SUCCESS) {
/* We failed to find a sensible tablespace file */
@ -2802,7 +2933,6 @@ dict_load_table_one(
const rec_t* rec;
const byte* field;
ulint len;
const char* err_msg;
mtr_t mtr;
DBUG_ENTER("dict_load_table_one");
@ -2859,9 +2989,7 @@ err_exit:
goto err_exit;
}
err_msg = dict_load_table_low(name, rec, &table);
if (err_msg) {
if (const char* err_msg = dict_load_table_low(name, rec, &table)) {
if (err_msg != dict_load_table_flags) {
ib::error() << err_msg;
}
@ -2885,6 +3013,8 @@ err_exit:
mem_heap_empty(heap);
ut_ad(dict_tf2_is_valid(table->flags, table->flags2));
/* If there is no tablespace for the table then we only need to
load the index definitions. So that we can IMPORT the tablespace
later. When recovering table locks for resurrected incomplete
@ -2920,17 +3050,6 @@ err_exit:
}
}
if (!dict_tf2_is_valid(table->flags, table->flags2)) {
ib::error() << "Table " << table->name << " in InnoDB"
" data dictionary contains invalid flags."
" SYS_TABLES.MIX_LEN=" << table->flags2;
table->flags2 &= ~DICT_TF2_TEMPORARY;
dict_table_remove_from_cache(table);
table = NULL;
err = DB_FAIL;
goto func_exit;
}
/* Initialize table foreign_child value. Its value could be
changed when dict_load_foreigns() is called below */
table->fk_max_recusive_level = 0;

View File

@ -3819,18 +3819,12 @@ fil_ibd_create(
ib::error() << "Cannot create file '" << path << "'";
if (error == OS_FILE_ALREADY_EXISTS) {
ib::error() << "The file '" << path << "'"
ib::info() << "The file '" << path << "'"
" already exists though the"
" corresponding table did not exist"
" in the InnoDB data dictionary."
" Have you moved InnoDB .ibd files"
" around without using the SQL commands"
" DISCARD TABLESPACE and IMPORT TABLESPACE,"
" or did mysqld crash in the middle of"
" CREATE TABLE?"
" You can resolve the problem by removing"
" the file '" << path
<< "' under the 'datadir' of MySQL.";
" the file.";
return(DB_TABLESPACE_EXISTS);
}
@ -4071,8 +4065,7 @@ fil_ibd_open(
ulint id,
ulint flags,
const char* space_name,
const char* path_in,
dict_table_t* table)
const char* path_in)
{
dberr_t err = DB_SUCCESS;
bool dict_filepath_same_as_default = false;
@ -4117,10 +4110,6 @@ fil_ibd_open(
validate = true;
++tablespaces_found;
link_file_found = true;
if (table) {
table->crypt_data = df_remote.get_crypt_info();
table->page_0_read = true;
}
} else if (df_remote.filepath() != NULL) {
/* An ISL file was found but contained a bad filepath in it.
Better validate anything we do find. */
@ -4139,11 +4128,6 @@ fil_ibd_open(
if (df_dict.open_read_only(true) == DB_SUCCESS) {
ut_ad(df_dict.is_open());
++tablespaces_found;
if (table) {
table->crypt_data = df_dict.get_crypt_info();
table->page_0_read = true;
}
}
}
}
@ -4155,10 +4139,6 @@ fil_ibd_open(
if (df_default.open_read_only(strict) == DB_SUCCESS) {
ut_ad(df_default.is_open());
++tablespaces_found;
if (table) {
table->crypt_data = df_default.get_crypt_info();
table->page_0_read = true;
}
}
/* Check if multiple locations point to the same file. */
@ -4795,7 +4775,6 @@ error log if a matching tablespace is not found from memory.
@param[in] adjust_space Whether to adjust space id on mismatch
@param[in] heap Heap memory
@param[in] table_id table id
@param[in] table table
@param[in] table_flags table flags
@return true if a matching tablespace exists in the memory cache */
bool
@ -4806,7 +4785,6 @@ fil_space_for_table_exists_in_mem(
bool adjust_space,
mem_heap_t* heap,
table_id_t table_id,
dict_table_t* table,
ulint table_flags)
{
fil_space_t* fnamespace;
@ -4827,10 +4805,6 @@ fil_space_for_table_exists_in_mem(
bool valid = space && !((space->flags ^ expected_flags)
& ~FSP_FLAGS_MEM_MASK);
if (valid && table && !table->crypt_data) {
table->crypt_data = space->crypt_data;
}
if (!space) {
} else if (!valid || space == fnamespace) {
/* Found with the same file name, or got a flag mismatch. */

View File

@ -425,13 +425,10 @@ Datafile::validate_to_dd(ulint space_id, ulint flags)
/* else do not use this tablespace. */
m_is_valid = false;
ib::error() << "In file '" << m_filepath << "', tablespace id and"
" flags are " << m_space_id << " and " << ib::hex(m_flags)
<< ", but in the InnoDB data dictionary they are "
<< space_id << " and " << ib::hex(flags)
<< ". Have you moved InnoDB .ibd files around without"
" using the commands DISCARD TABLESPACE and IMPORT TABLESPACE?"
" " << TROUBLESHOOT_DATADICT_MSG;
ib::error() << "Refusing to load '" << m_filepath << "' (id="
<< m_space_id << ", flags=" << ib::hex(m_flags)
<< "); dictionary contains id="
<< space_id << ", flags=" << ib::hex(flags);
return(DB_ERROR);
}

View File

@ -6626,10 +6626,6 @@ ha_innobase::open(
norm_name);
}
ib::warn() << "Cannot open table " << norm_name << " from the"
" internal data dictionary of InnoDB though the .frm"
" file for the table exists. " << TROUBLESHOOTING_MSG;
free_share(m_share);
set_my_errno(ENOENT);
@ -6638,8 +6634,6 @@ ha_innobase::open(
innobase_copy_frm_flags_from_table_share(ib_table, table->s);
ib_table->thd = (void*)thd;
/* No point to init any statistics if tablespace is still encrypted. */
if (ib_table->is_readable()) {
dict_stats_init(ib_table);
@ -12926,7 +12920,7 @@ index_bad:
0);
if (m_form->s->table_type == TABLE_TYPE_SEQUENCE) {
m_flags |= 1U << DICT_TF_POS_NO_ROLLBACK;
m_flags |= DICT_TF_MASK_NO_ROLLBACK;
}
/* Set the flags2 when create table or alter tables */

View File

@ -638,6 +638,48 @@ dict_table_has_fts_index(
return(DICT_TF2_FLAG_IS_SET(table, DICT_TF2_FTS));
}
/** Validate the flags for tables that are not ROW_FORMAT=REDUNDANT.
@param[in] flags table flags
@return whether the flags are valid */
inline
bool
dict_tf_is_valid_not_redundant(ulint flags)
{
const bool atomic_blobs = DICT_TF_HAS_ATOMIC_BLOBS(flags);
ulint zip_ssize = DICT_TF_GET_ZIP_SSIZE(flags);
if (!zip_ssize) {
/* Not ROW_FORMAT=COMPRESSED */
} else if (!atomic_blobs) {
/* ROW_FORMAT=COMPRESSED implies ROW_FORMAT=DYNAMIC
for the uncompressed page format */
return(false);
} else if (zip_ssize > PAGE_ZIP_SSIZE_MAX
|| zip_ssize > UNIV_PAGE_SIZE_SHIFT
|| UNIV_PAGE_SIZE_SHIFT > UNIV_ZIP_SIZE_SHIFT_MAX) {
/* KEY_BLOCK_SIZE is out of bounds, or
ROW_FORMAT=COMPRESSED is not supported with this
innodb_page_size (only up to 16KiB) */
return(false);
}
switch (DICT_TF_GET_PAGE_COMPRESSION_LEVEL(flags)) {
case 0:
/* PAGE_COMPRESSION_LEVEL=0 should imply PAGE_COMPRESSED=NO */
return(!DICT_TF_GET_PAGE_COMPRESSION(flags));
case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9:
/* PAGE_COMPRESSION_LEVEL requires
ROW_FORMAT=COMPACT or ROW_FORMAT=DYNAMIC
(not ROW_FORMAT=COMPRESSED or ROW_FORMAT=REDUNDANT)
and PAGE_COMPRESSED=YES */
return(!zip_ssize && DICT_TF_GET_PAGE_COMPRESSION(flags));
default:
/* Invalid PAGE_COMPRESSION_LEVEL value */
return(false);
}
}
/** Validate the table flags.
@param[in] flags Table flags
@return true if valid. */
@ -646,75 +688,19 @@ bool
dict_tf_is_valid(
ulint flags)
{
bool compact = DICT_TF_GET_COMPACT(flags);
ulint zip_ssize = DICT_TF_GET_ZIP_SSIZE(flags);
bool atomic_blobs = DICT_TF_HAS_ATOMIC_BLOBS(flags);
bool data_dir = DICT_TF_HAS_DATA_DIR(flags);
ulint unused = DICT_TF_GET_UNUSED(flags);
bool page_compression = DICT_TF_GET_PAGE_COMPRESSION(flags);
ulint page_compression_level = DICT_TF_GET_PAGE_COMPRESSION_LEVEL(flags);
bool flags_corrupt = false;
/* Make sure there are no bits that we do not know about. */
if (unused != 0) {
flags_corrupt = true;
ut_ad(flags < 1U << DICT_TF_BITS);
/* The DATA_DIRECTORY flag can be assigned fully independently
of all other persistent table flags. */
flags &= ~DICT_TF_MASK_DATA_DIR;
if (!(flags & 1)) {
/* Only ROW_FORMAT=REDUNDANT has 0 in the least significant
bit. For ROW_FORMAT=REDUNDANT, only the DATA_DIR flag
(which we cleared above) can be set. If any other flags
are set, the flags are invalid. */
return(flags == 0);
}
if (atomic_blobs) {
/* Barracuda row formats COMPRESSED and DYNAMIC both use
atomic_blobs, which build on the page structure introduced
for the COMPACT row format by allowing keys in secondary
indexes to be made from data stored off-page in the
clustered index. */
if (!compact) {
flags_corrupt = true;
}
} else if (zip_ssize) {
/* Antelope does not support COMPRESSED row format. */
flags_corrupt = true;
}
if (zip_ssize) {
/* COMPRESSED row format must have compact and atomic_blobs
bits set and validate the number is within allowed range. */
if (!compact
|| !atomic_blobs
|| zip_ssize > PAGE_ZIP_SSIZE_MAX) {
flags_corrupt = true;
}
}
if (page_compression || page_compression_level) {
/* Page compression format must have compact and
atomic_blobs and page_compression_level requires
page_compression */
if (!compact
|| !page_compression
|| !atomic_blobs) {
flags_corrupt = true;
}
}
if (flags_corrupt) {
ib::error()
<< "InnoDB: Error: table unused flags are:" << flags
<< " in the data dictionary and are corrupted:"
<< " compact:" << compact
<< " atomic_blobs:" << atomic_blobs
<< " unused:" << unused
<< " data_dir:" << data_dir
<< " zip_ssize:" << zip_ssize
<< " page_compression:" << page_compression
<< " page_compression_level:" << page_compression_level;
return (false);
} else {
return(true);
}
return(dict_tf_is_valid_not_redundant(flags));
}
/** Validate both table flags and table flags2 and make sure they
@ -739,112 +725,6 @@ dict_tf2_is_valid(
return(true);
}
/********************************************************************//**
Validate a SYS_TABLES TYPE field and return it.
@return Same as input after validating it as a SYS_TABLES TYPE field.
If there is an error, return ULINT_UNDEFINED. */
UNIV_INLINE
ulint
dict_sys_tables_type_validate(
/*==========================*/
ulint type, /*!< in: SYS_TABLES.TYPE */
ulint n_cols) /*!< in: SYS_TABLES.N_COLS */
{
ulint low_order_bit = DICT_TF_GET_COMPACT(type);
ulint redundant = !(n_cols & DICT_N_COLS_COMPACT);
ulint zip_ssize = DICT_TF_GET_ZIP_SSIZE(type);
ulint atomic_blobs = DICT_TF_HAS_ATOMIC_BLOBS(type);
ulint unused = DICT_TF_GET_UNUSED(type);
bool page_compression = DICT_TF_GET_PAGE_COMPRESSION(type);
ulint page_compression_level = DICT_TF_GET_PAGE_COMPRESSION_LEVEL(type);
/* The low order bit of SYS_TABLES.TYPE is always set to 1.
If the format is UNIV_FORMAT_B or higher, this field is the same
as dict_table_t::flags. Zero is not allowed here. */
if (!low_order_bit) {
return(ULINT_UNDEFINED);
}
if (redundant) {
if (zip_ssize || atomic_blobs) {
ib::error()
<< "SYS_TABLES::TYPE=Redundant, zip_ssize:" << zip_ssize
<< " atomic_blobs:" << atomic_blobs;
return(ULINT_UNDEFINED);
}
}
/* Make sure there are no bits that we do not know about. */
if (unused) {
ib::error()
<< "SYS_TABLES::TYPE=" << type << " unused:" << unused;
return(ULINT_UNDEFINED);
}
if (atomic_blobs) {
/* Barracuda row formats COMPRESSED and DYNAMIC build on
the page structure introduced for the COMPACT row format
by allowing keys in secondary indexes to be made from
data stored off-page in the clustered index.
The DICT_N_COLS_COMPACT flag should be in N_COLS,
but we already know that. */
} else if (zip_ssize) {
/* Antelope does not support COMPRESSED format. */
ib::error()
<< "SYS_TABLES::TYPE=" << type
<< ", zip_ssize:" << zip_ssize;
return(ULINT_UNDEFINED);
}
if (zip_ssize) {
/* COMPRESSED row format must have low_order_bit and
atomic_blobs bits set and the DICT_N_COLS_COMPACT flag
should be in N_COLS, but we already know about the
low_order_bit and DICT_N_COLS_COMPACT flags. */
if (!atomic_blobs) {
ib::error() << "SYS_TABLES::TYPE=" << type
<< ", zip_ssize:" << zip_ssize
<< ", atomic_blobs:" << atomic_blobs;
return(ULINT_UNDEFINED);
}
/* Validate that the number is within allowed range. */
if (zip_ssize > PAGE_ZIP_SSIZE_MAX) {
ib::error() << "SYS_TABLES::TYPE=" << type
<< ", zip_ssize:" << zip_ssize
<< " > " << PAGE_ZIP_SSIZE_MAX;
return(ULINT_UNDEFINED);
}
}
/* There is nothing to validate for the data_dir field.
CREATE TABLE ... DATA DIRECTORY is supported for any row
format, so the DATA_DIR flag is compatible with any other
table flags. However, it is not used with TEMPORARY tables. */
if (page_compression || page_compression_level) {
/* page compressed row format must have low_order_bit and
atomic_blobs bits set and the DICT_N_COLS_COMPACT flag
should be in N_COLS, but we already know about the
low_order_bit and DICT_N_COLS_COMPACT flags. */
if (!atomic_blobs || !page_compression) {
ib::error() << "SYS_TABLES::TYPE=" << type
<< " page_compression:" << page_compression
<< " page_compression_level:" << page_compression_level
<< " atomic_blobs:" << atomic_blobs;
return(ULINT_UNDEFINED);
}
}
/* Return the validated SYS_TABLES.TYPE. */
return(type);
}
/********************************************************************//**
Determine the file format from dict_table_t::flags
The low order bit will be zero for REDUNDANT and 1 for COMPACT. For any
@ -978,7 +858,6 @@ dict_tf_to_fsp_flags(ulint table_flags)
ulint fsp_flags;
ulint page_compression_level = DICT_TF_GET_PAGE_COMPRESSION_LEVEL(
table_flags);
ulint atomic_writes = DICT_TF_GET_ATOMIC_WRITES(table_flags);
ut_ad((DICT_TF_GET_PAGE_COMPRESSION(table_flags) == 0)
== (page_compression_level == 0));
@ -1005,47 +884,11 @@ dict_tf_to_fsp_flags(ulint table_flags)
fsp_flags |= 1U << FSP_FLAGS_MEM_DATA_DIR;
}
fsp_flags |= atomic_writes << FSP_FLAGS_MEM_ATOMIC_WRITES;
fsp_flags |= page_compression_level << FSP_FLAGS_MEM_COMPRESSION_LEVEL;
return(fsp_flags);
}
/********************************************************************//**
Convert a 32 bit integer from SYS_TABLES.TYPE to dict_table_t::flags
The following chart shows the translation of the low order bit.
Other bits are the same.
========================= Low order bit ==========================
| REDUNDANT | COMPACT | COMPRESSED and DYNAMIC
SYS_TABLES.TYPE | 1 | 1 | 1
dict_table_t::flags | 0 | 1 | 1
==================================================================
@return ulint containing SYS_TABLES.TYPE */
UNIV_INLINE
ulint
dict_sys_tables_type_to_tf(
/*=======================*/
ulint type, /*!< in: SYS_TABLES.TYPE field */
ulint n_cols) /*!< in: SYS_TABLES.N_COLS field */
{
ulint flags;
ulint redundant = !(n_cols & DICT_N_COLS_COMPACT);
/* Adjust bit zero. */
flags = redundant ? 0 : 1;
/* ZIP_SSIZE, ATOMIC_BLOBS, DATA_DIR, PAGE_COMPRESSION,
PAGE_COMPRESSION_LEVEL are the same. */
flags |= type & (DICT_TF_MASK_ZIP_SSIZE
| DICT_TF_MASK_ATOMIC_BLOBS
| DICT_TF_MASK_DATA_DIR
| DICT_TF_MASK_PAGE_COMPRESSION
| DICT_TF_MASK_PAGE_COMPRESSION_LEVEL);
ut_ad(!DICT_TF_GET_ZIP_SSIZE(flags) || DICT_TF_HAS_ATOMIC_BLOBS(flags));
return(flags);
}
/********************************************************************//**
Convert a 32 bit integer table flags to the 32bit integer that is written
to a SYS_TABLES.TYPE field. The following chart shows the translation of
@ -1075,7 +918,8 @@ dict_tf_to_sys_tables_type(
| DICT_TF_MASK_ATOMIC_BLOBS
| DICT_TF_MASK_DATA_DIR
| DICT_TF_MASK_PAGE_COMPRESSION
| DICT_TF_MASK_PAGE_COMPRESSION_LEVEL);
| DICT_TF_MASK_PAGE_COMPRESSION_LEVEL
| DICT_TF_MASK_NO_ROLLBACK);
return(type);
}

View File

@ -137,10 +137,6 @@ This flag prevents older engines from attempting to open the table and
allows InnoDB to update_create_info() accordingly. */
#define DICT_TF_WIDTH_DATA_DIR 1
/** Width of the SHARED tablespace flag (Oracle MYSQL 5.7).
Not supported by MariaDB. */
#define DICT_TF_WIDTH_SHARED_SPACE 1
/**
Width of the page compression flag
*/
@ -148,36 +144,20 @@ Width of the page compression flag
#define DICT_TF_WIDTH_PAGE_COMPRESSION_LEVEL 4
/**
Width of atomic writes flag
DEFAULT=0, ON = 1, OFF = 2
The NO_ROLLBACK flag (3=yes; the values 1,2 used stand for
ATOMIC_WRITES=ON and ATOMIC_WRITES=OFF between MariaDB 10.1.0 and 10.2.3)
*/
#define DICT_TF_WIDTH_ATOMIC_WRITES 2
/**
Width of the page encryption flag
*/
#define DICT_TF_WIDTH_PAGE_ENCRYPTION 1
#define DICT_TF_WIDTH_PAGE_ENCRYPTION_KEY 8
/** Width of the NO_ROLLBACK flag */
#define DICT_TF_WIDTH_NO_ROLLBACK 1
#define DICT_TF_WIDTH_NO_ROLLBACK 2
/** Width of all the currently known table flags */
#define DICT_TF_BITS (DICT_TF_WIDTH_COMPACT \
+ DICT_TF_WIDTH_ZIP_SSIZE \
+ DICT_TF_WIDTH_ATOMIC_BLOBS \
+ DICT_TF_WIDTH_DATA_DIR \
+ DICT_TF_WIDTH_SHARED_SPACE \
+ DICT_TF_WIDTH_PAGE_COMPRESSION \
+ DICT_TF_WIDTH_PAGE_COMPRESSION_LEVEL \
+ DICT_TF_WIDTH_ATOMIC_WRITES \
+ DICT_TF_WIDTH_PAGE_ENCRYPTION \
+ DICT_TF_WIDTH_PAGE_ENCRYPTION_KEY \
+ DICT_TF_WIDTH_NO_ROLLBACK)
/** A mask of all the known/used bits in table flags */
#define DICT_TF_BIT_MASK (~(~0U << DICT_TF_BITS))
/** Zero relative shift position of the COMPACT field */
#define DICT_TF_POS_COMPACT 0
/** Zero relative shift position of the ZIP_SSIZE field */
@ -189,29 +169,18 @@ Width of the page encryption flag
/** Zero relative shift position of the DATA_DIR field */
#define DICT_TF_POS_DATA_DIR (DICT_TF_POS_ATOMIC_BLOBS \
+ DICT_TF_WIDTH_ATOMIC_BLOBS)
/** Zero relative shift position of the SHARED TABLESPACE field */
#define DICT_TF_POS_SHARED_SPACE (DICT_TF_POS_DATA_DIR \
+ DICT_TF_WIDTH_DATA_DIR)
/** Zero relative shift position of the PAGE_COMPRESSION field */
#define DICT_TF_POS_PAGE_COMPRESSION (DICT_TF_POS_SHARED_SPACE \
+ DICT_TF_WIDTH_SHARED_SPACE)
#define DICT_TF_POS_PAGE_COMPRESSION (DICT_TF_POS_DATA_DIR \
+ DICT_TF_WIDTH_DATA_DIR)
/** Zero relative shift position of the PAGE_COMPRESSION_LEVEL field */
#define DICT_TF_POS_PAGE_COMPRESSION_LEVEL (DICT_TF_POS_PAGE_COMPRESSION \
+ DICT_TF_WIDTH_PAGE_COMPRESSION)
/** Zero relative shift position of the ATOMIC_WRITES field */
#define DICT_TF_POS_ATOMIC_WRITES (DICT_TF_POS_PAGE_COMPRESSION_LEVEL \
+ DICT_TF_WIDTH_PAGE_COMPRESSION_LEVEL)
/** Zero relative shift position of the PAGE_ENCRYPTION field */
#define DICT_TF_POS_PAGE_ENCRYPTION (DICT_TF_POS_ATOMIC_WRITES \
+ DICT_TF_WIDTH_ATOMIC_WRITES)
/** Zero relative shift position of the PAGE_ENCRYPTION_KEY field */
#define DICT_TF_POS_PAGE_ENCRYPTION_KEY (DICT_TF_POS_PAGE_ENCRYPTION \
+ DICT_TF_WIDTH_PAGE_ENCRYPTION)
/** Zero relative shift position of the NO_ROLLBACK field */
#define DICT_TF_POS_NO_ROLLBACK (DICT_TF_POS_PAGE_ENCRYPTION_KEY \
+ DICT_TF_WIDTH_PAGE_ENCRYPTION_KEY)
#define DICT_TF_POS_UNUSED (DICT_TF_POS_NO_ROLLBACK \
#define DICT_TF_POS_NO_ROLLBACK (DICT_TF_POS_PAGE_COMPRESSION_LEVEL \
+ DICT_TF_WIDTH_PAGE_COMPRESSION_LEVEL)
#define DICT_TF_POS_UNUSED (DICT_TF_POS_NO_ROLLBACK \
+ DICT_TF_WIDTH_NO_ROLLBACK)
/** Bit mask of the COMPACT field */
#define DICT_TF_MASK_COMPACT \
((~(~0U << DICT_TF_WIDTH_COMPACT)) \
@ -236,18 +205,10 @@ Width of the page encryption flag
#define DICT_TF_MASK_PAGE_COMPRESSION_LEVEL \
((~(~0U << DICT_TF_WIDTH_PAGE_COMPRESSION_LEVEL)) \
<< DICT_TF_POS_PAGE_COMPRESSION_LEVEL)
/** Bit mask of the ATOMIC_WRITES field */
#define DICT_TF_MASK_ATOMIC_WRITES \
((~(~0U << DICT_TF_WIDTH_ATOMIC_WRITES)) \
<< DICT_TF_POS_ATOMIC_WRITES)
/** Bit mask of the PAGE_ENCRYPTION field */
#define DICT_TF_MASK_PAGE_ENCRYPTION \
((~(~0U << DICT_TF_WIDTH_PAGE_ENCRYPTION)) \
<< DICT_TF_POS_PAGE_ENCRYPTION)
/** Bit mask of the PAGE_ENCRYPTION_KEY field */
#define DICT_TF_MASK_PAGE_ENCRYPTION_KEY \
((~(~0U << DICT_TF_WIDTH_PAGE_ENCRYPTION_KEY)) \
<< DICT_TF_POS_PAGE_ENCRYPTION_KEY)
/** Bit mask of the NO_ROLLBACK field */
#define DICT_TF_MASK_NO_ROLLBACK \
((~(~0U << DICT_TF_WIDTH_NO_ROLLBACK)) \
<< DICT_TF_POS_NO_ROLLBACK)
/** Return the value of the COMPACT field */
#define DICT_TF_GET_COMPACT(flags) \
@ -273,22 +234,7 @@ Width of the page encryption flag
#define DICT_TF_GET_PAGE_COMPRESSION_LEVEL(flags) \
((flags & DICT_TF_MASK_PAGE_COMPRESSION_LEVEL) \
>> DICT_TF_POS_PAGE_COMPRESSION_LEVEL)
/** Return the value of the ATOMIC_WRITES field */
#define DICT_TF_GET_ATOMIC_WRITES(flags) \
((flags & DICT_TF_MASK_ATOMIC_WRITES) \
>> DICT_TF_POS_ATOMIC_WRITES)
/** Return the contents of the PAGE_ENCRYPTION field */
#define DICT_TF_GET_PAGE_ENCRYPTION(flags) \
((flags & DICT_TF_MASK_PAGE_ENCRYPTION) \
>> DICT_TF_POS_PAGE_ENCRYPTION)
/** Return the contents of the PAGE_ENCRYPTION KEY field */
#define DICT_TF_GET_PAGE_ENCRYPTION_KEY(flags) \
((flags & DICT_TF_MASK_PAGE_ENCRYPTION_KEY) \
>> DICT_TF_POS_PAGE_ENCRYPTION_KEY)
/** Return the contents of the UNUSED bits */
#define DICT_TF_GET_UNUSED(flags) \
(flags >> DICT_TF_POS_UNUSED)
/* @} */
/** @brief Table Flags set number 2.
@ -1359,18 +1305,13 @@ struct dict_table_t {
/** Acquire the table handle. */
inline void acquire();
void* thd; /*!< thd */
bool page_0_read; /*!< true if page 0 has
been already read */
fil_space_crypt_t *crypt_data; /*!< crypt data if present */
/** Release the table handle. */
inline void release();
/** @return whether the table supports transactions */
bool no_rollback() const
{
return flags & (1U << DICT_TF_POS_NO_ROLLBACK);
return !(~flags & DICT_TF_MASK_NO_ROLLBACK);
}
/** @return whether this table is readable
@retval true normally

View File

@ -1106,8 +1106,7 @@ fil_ibd_open(
ulint id,
ulint flags,
const char* tablename,
const char* path_in,
dict_table_t* table) /*!< in: table */
const char* path_in)
MY_ATTRIBUTE((warn_unused_result));
enum fil_load_status {
@ -1169,7 +1168,6 @@ fil_space_for_table_exists_in_mem(
when find table space mismatch */
mem_heap_t* heap, /*!< in: heap memory */
table_id_t table_id, /*!< in: table id */
dict_table_t* table, /*!< in: table or NULL */
ulint table_flags); /*!< in: table flags */
/** Try to extend a tablespace if it is smaller than the specified size.

View File

@ -278,10 +278,8 @@ The flags below only exist in fil_space_t::flags, not in FSP_SPACE_FLAGS:
/** Zero relative shift position of the DATA_DIR flag */
#define FSP_FLAGS_MEM_DATA_DIR 25
/** Zero relative shift position of the ATOMIC_WRITES field */
#define FSP_FLAGS_MEM_ATOMIC_WRITES 26
/** Zero relative shift position of the COMPRESSION_LEVEL field */
#define FSP_FLAGS_MEM_COMPRESSION_LEVEL 28
#define FSP_FLAGS_MEM_COMPRESSION_LEVEL 26
/** Zero relative shift position of the POST_ANTELOPE field */
#define FSP_FLAGS_POS_POST_ANTELOPE 0
@ -327,10 +325,6 @@ these are only used in MySQL 5.7 and used for compatibility. */
((~(~0U << FSP_FLAGS_WIDTH_PAGE_COMPRESSION)) \
<< FSP_FLAGS_POS_PAGE_COMPRESSION)
/** Bit mask of the in-memory ATOMIC_WRITES field */
#define FSP_FLAGS_MASK_MEM_ATOMIC_WRITES \
(3U << FSP_FLAGS_MEM_ATOMIC_WRITES)
/** Bit mask of the in-memory COMPRESSION_LEVEL field */
#define FSP_FLAGS_MASK_MEM_COMPRESSION_LEVEL \
(15U << FSP_FLAGS_MEM_COMPRESSION_LEVEL)
@ -371,10 +365,6 @@ these are only used in MySQL 5.7 and used for compatibility. */
#define FSP_FLAGS_GET_PAGE_COMPRESSION_LEVEL(flags) \
((flags & FSP_FLAGS_MASK_MEM_COMPRESSION_LEVEL) \
>> FSP_FLAGS_MEM_COMPRESSION_LEVEL)
/** @return the ATOMIC_WRITES field */
#define FSP_FLAGS_GET_ATOMIC_WRITES(flags) \
((flags & FSP_FLAGS_MASK_MEM_ATOMIC_WRITES) \
>> FSP_FLAGS_MEM_ATOMIC_WRITES)
/* @} */

View File

@ -3002,21 +3002,19 @@ row_import_read_v1(
cfg->m_n_cols = mach_read_from_4(ptr);
if (!dict_tf_is_valid(cfg->m_flags)) {
ib_errf(thd, IB_LOG_LEVEL_ERROR,
ER_TABLE_SCHEMA_MISMATCH,
"Invalid table flags: " ULINTPF, cfg->m_flags);
return(DB_CORRUPTION);
} else if ((err = row_import_read_columns(file, thd, cfg))
!= DB_SUCCESS) {
return(err);
} else if ((err = row_import_read_indexes(file, thd, cfg))
!= DB_SUCCESS) {
return(err);
}
ut_a(err == DB_SUCCESS);
err = row_import_read_columns(file, thd, cfg);
if (err == DB_SUCCESS) {
err = row_import_read_indexes(file, thd, cfg);
}
return(err);
}
@ -3556,7 +3554,7 @@ row_import_for_mysql(
err = fil_ibd_open(
true, true, FIL_TYPE_IMPORT, table->space,
fsp_flags, table->name.m_name, filepath, table);
fsp_flags, table->name.m_name, filepath);
DBUG_EXECUTE_IF("ib_import_open_tablespace_failure",
err = DB_TABLESPACE_NOT_FOUND;);

View File

@ -3558,8 +3558,7 @@ row_drop_single_table_tablespace(
/* If the tablespace is not in the cache, just delete the file. */
if (!fil_space_for_table_exists_in_mem(
space_id, tablename, true, false, NULL, 0, NULL,
table_flags)) {
space_id, tablename, true, false, NULL, 0, table_flags)) {
/* Force a delete of any discarded or temporary files. */
fil_delete_file(filepath);
@ -3897,19 +3896,6 @@ row_drop_table_for_mysql(
we need to avoid running removal of these entries. */
if (!dict_table_is_temporary(table)) {
/* If table has not yet have crypt_data, try to read it to
make freeing the table easier. */
if (!table->crypt_data) {
if (fil_space_t* space = fil_space_acquire_silent(
table->space)) {
/* We use crypt data in dict_table_t
in ha_innodb.cc to push warnings to
user thread. */
table->crypt_data = space->crypt_data;
fil_space_release(space);
}
}
/* We use the private SQL parser of Innobase to generate the
query graphs needed in deleting the dictionary data from system
tables in Innobase. Deleting a row from SYS_INDEXES table also

View File

@ -745,7 +745,8 @@ btr_root_block_get(
if (index && index->table) {
index->table->file_unreadable = true;
ib_push_warning(index->table->thd, DB_DECRYPTION_FAILED,
ib_push_warning(
static_cast<THD*>(NULL), DB_DECRYPTION_FAILED,
"Table %s in tablespace %lu is encrypted but encryption service or"
" used key_id is not available. "
" Can't continue reading table.",

View File

@ -1193,7 +1193,7 @@ loop:
dberr_t err = fil_open_single_table_tablespace(
read_page_0, srv_read_only_mode ? false : true,
space_id, dict_tf_to_fsp_flags(flags),
name, filepath, NULL);
name, filepath);
if (err != DB_SUCCESS) {
ib_logf(IB_LOG_LEVEL_ERROR,
@ -2437,7 +2437,7 @@ err_exit:
err = fil_open_single_table_tablespace(
true, false, table->space,
dict_tf_to_fsp_flags(table->flags),
name, filepath, table);
name, filepath);
if (err != DB_SUCCESS) {
/* We failed to find a sensible

View File

@ -4229,8 +4229,7 @@ fil_open_single_table_tablespace(
ulint flags, /*!< in: expected FSP_SPACE_FLAGS */
const char* tablename, /*!< in: table name in the
databasename/tablename format */
const char* path_in, /*!< in: tablespace filepath */
dict_table_t* table) /*!< in: table */
const char* path_in) /*!< in: table */
{
dberr_t err = DB_SUCCESS;
bool dict_filepath_same_as_default = false;
@ -4339,11 +4338,6 @@ fil_open_single_table_tablespace(
def.file, false, &def.flags, &def.id,
NULL, &def.crypt_data);
if (table) {
table->crypt_data = def.crypt_data;
table->page_0_read = true;
}
def.valid = !def.check_msg && def.id == id
&& fsp_flags_match(flags, def.flags);
@ -4363,11 +4357,6 @@ fil_open_single_table_tablespace(
remote.file, false, &remote.flags, &remote.id,
NULL, &remote.crypt_data);
if (table) {
table->crypt_data = remote.crypt_data;
table->page_0_read = true;
}
/* Validate this single-table-tablespace with SYS_TABLES. */
remote.valid = !remote.check_msg && remote.id == id
&& fsp_flags_match(flags, remote.flags);
@ -4389,11 +4378,6 @@ fil_open_single_table_tablespace(
dict.file, false, &dict.flags, &dict.id,
NULL, &dict.crypt_data);
if (table) {
table->crypt_data = dict.crypt_data;
table->page_0_read = true;
}
/* Validate this single-table-tablespace with SYS_TABLES. */
dict.valid = !dict.check_msg && dict.id == id
&& fsp_flags_match(flags, dict.flags);

View File

@ -6434,8 +6434,6 @@ table_opened:
innobase_copy_frm_flags_from_table_share(ib_table, table->s);
ib_table->thd = (void*)thd;
/* No point to init any statistics if tablespace is still encrypted. */
if (ib_table->is_readable()) {
dict_stats_init(ib_table);

View File

@ -705,8 +705,6 @@ dict_sys_tables_type_validate(
ulint page_compression_level = DICT_TF_GET_PAGE_COMPRESSION_LEVEL(type);
ulint atomic_writes = DICT_TF_GET_ATOMIC_WRITES(type);
ut_a(atomic_writes <= ATOMIC_WRITES_OFF);
/* The low order bit of SYS_TABLES.TYPE is always set to 1.
If the format is UNIV_FORMAT_B or higher, this field is the same
as dict_table_t::flags. Zero is not allowed here. */
@ -716,16 +714,12 @@ dict_sys_tables_type_validate(
if (redundant) {
if (zip_ssize || atomic_blobs) {
fprintf(stderr, "InnoDB: Error: SYS_TABLES::TYPE=Redundant, zip_ssize " ULINTPF " atomic_blobs " ULINTPF "\n",
zip_ssize, atomic_blobs);
return(ULINT_UNDEFINED);
}
}
/* Make sure there are no bits that we do not know about. */
if (unused) {
fprintf(stderr, "InnoDB: Error: SYS_TABLES::TYPE=" ULINTPF ", unused " ULINTPF "\n",
type, unused);
return(ULINT_UNDEFINED);
}
@ -737,11 +731,8 @@ dict_sys_tables_type_validate(
The DICT_N_COLS_COMPACT flag should be in N_COLS,
but we already know that. */
} else if (zip_ssize) {
/* Antelope does not support COMPRESSED format. */
fprintf(stderr, "InnoDB: Error: SYS_TABLES::TYPE=" ULINTPF ", zip_ssize " ULINTPF "\n",
type, zip_ssize);
return(ULINT_UNDEFINED);
}
@ -751,15 +742,11 @@ dict_sys_tables_type_validate(
should be in N_COLS, but we already know about the
low_order_bit and DICT_N_COLS_COMPACT flags. */
if (!atomic_blobs) {
fprintf(stderr, "InnoDB: Error: SYS_TABLES::TYPE=" ULINTPF ", zip_ssize " ULINTPF " atomic_blobs " ULINTPF "\n",
type, zip_ssize, atomic_blobs);
return(ULINT_UNDEFINED);
}
/* Validate that the number is within allowed range. */
if (zip_ssize > PAGE_ZIP_SSIZE_MAX) {
fprintf(stderr, "InnoDB: Error: SYS_TABLES::TYPE=" ULINTPF ", zip_ssize " ULINTPF " max %d\n",
type, zip_ssize, PAGE_ZIP_SSIZE_MAX);
return(ULINT_UNDEFINED);
}
}
@ -776,18 +763,13 @@ dict_sys_tables_type_validate(
low_order_bit and DICT_N_COLS_COMPACT flags. */
if (!atomic_blobs || !page_compression) {
fprintf(stderr, "InnoDB: Error: SYS_TABLES::TYPE=" ULINTPF ", page_compression " ULINTPF " page_compression_level " ULINTPF "\n"
"InnoDB: Error: atomic_blobs " ULINTPF "\n",
type, page_compression, page_compression_level, atomic_blobs);
return(ULINT_UNDEFINED);
}
}
/* Validate that the atomic writes number is within allowed range. */
if (atomic_writes > ATOMIC_WRITES_OFF) {
fprintf(stderr, "InnoDB: Error: SYS_TABLES::TYPE=" ULINTPF ", atomic_writes " ULINTPF "\n",
type, atomic_writes);
return(ULINT_UNDEFINED);
return(ULINT_UNDEFINED);
}
/* Return the validated SYS_TABLES.TYPE. */

View File

@ -1048,10 +1048,6 @@ struct dict_table_t{
table_id_t id; /*!< id of the table */
mem_heap_t* heap; /*!< memory heap */
char* name; /*!< table name */
void* thd; /*!< thd */
bool page_0_read; /*!< true if page 0 has
been already read */
fil_space_crypt_t *crypt_data; /*!< crypt data if present */
const char* dir_path_of_temp_table;/*!< NULL or the directory path
where a TEMPORARY table that was explicitly
created by a user should be placed if

View File

@ -1043,8 +1043,7 @@ fil_open_single_table_tablespace(
ulint flags, /*!< in: expected FSP_SPACE_FLAGS */
const char* tablename, /*!< in: table name in the
databasename/tablename format */
const char* filepath, /*!< in: tablespace filepath */
dict_table_t* table) /*!< in: table */
const char* filepath) /*!< in: tablespace filepath */
__attribute__((nonnull(5), warn_unused_result));
#endif /* !UNIV_HOTBACKUP */

View File

@ -4401,7 +4401,7 @@ os_aio_init(
#ifdef _WIN32
ut_a(completion_port == 0 && read_completion_port == 0);
completion_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
read_completion_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
read_completion_port = srv_read_only_mode? completion_port : CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
ut_a(completion_port && read_completion_port);
#endif

View File

@ -3618,7 +3618,7 @@ row_import_for_mysql(
err = fil_open_single_table_tablespace(
true, true, table->space,
dict_tf_to_fsp_flags(table->flags),
table->name, filepath, table);
table->name, filepath);
DBUG_EXECUTE_IF("ib_import_open_tablespace_failure",
err = DB_TABLESPACE_NOT_FOUND;);

View File

@ -4272,18 +4272,6 @@ row_drop_table_for_mysql(
rw_lock_x_unlock(dict_index_get_lock(index));
}
/* If table has not yet have crypt_data, try to read it to
make freeing the table easier. */
if (!table->crypt_data) {
if (fil_space_t* space = fil_space_acquire_silent(table->space)) {
/* We use crypt data in dict_table_t in ha_innodb.cc
to push warnings to user thread. */
table->crypt_data = space->crypt_data;
fil_space_release(space);
}
}
/* We use the private SQL parser of Innobase to generate the
query graphs needed in deleting the dictionary data from system
tables in Innobase. Deleting a row from SYS_INDEXES table also