diff --git a/include/mysql.h.pp b/include/mysql.h.pp
index 3316574a423..d061df71944 100644
--- a/include/mysql.h.pp
+++ b/include/mysql.h.pp
@@ -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,
diff --git a/include/mysql_com.h b/include/mysql_com.h
index d24957d1990..6f0a2097f13 100644
--- a/include/mysql_com.h
+++ b/include/mysql_com.h
@@ -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:
diff --git a/libmariadb b/libmariadb
index 467a193b399..ff4bfdf1caf 160000
--- a/libmariadb
+++ b/libmariadb
@@ -1 +1 @@
-Subproject commit 467a193b399dfda41d87368a898e9550d754fa14
+Subproject commit ff4bfdf1caf2e0a47382fdbe6d796d0e63ec1062
diff --git a/mysql-test/r/mysqld--help.result b/mysql-test/r/mysqld--help.result
index 09c8bf9813b..b9f745b745d 100644
--- a/mysql-test/r/mysqld--help.result
+++ b/mysql-test/r/mysqld--help.result
@@ -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
diff --git a/mysql-test/suite/encryption/r/innodb_lotoftables.result b/mysql-test/suite/encryption/r/innodb_lotoftables.result
index 06b832ea6fc..cf5724b527a 100644
--- a/mysql-test/suite/encryption/r/innodb_lotoftables.result
+++ b/mysql-test/suite/encryption/r/innodb_lotoftables.result
@@ -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
diff --git a/mysql-test/suite/innodb/r/row_format_redundant.result b/mysql-test/suite/innodb/r/row_format_redundant.result
index 45dfdf01218..2bc8769092f 100644
--- a/mysql-test/suite/innodb/r/row_format_redundant.result
+++ b/mysql-test/suite/innodb/r/row_format_redundant.result
@@ -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
diff --git a/mysql-test/suite/innodb/r/table_flags,32k.rdiff b/mysql-test/suite/innodb/r/table_flags,32k.rdiff
new file mode 100644
index 00000000000..ea2d7048bb7
--- /dev/null
+++ b/mysql-test/suite/innodb/r/table_flags,32k.rdiff
@@ -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),
diff --git a/mysql-test/suite/innodb/r/table_flags,4k.rdiff b/mysql-test/suite/innodb/r/table_flags,4k.rdiff
new file mode 100644
index 00000000000..0e469ee631b
--- /dev/null
+++ b/mysql-test/suite/innodb/r/table_flags,4k.rdiff
@@ -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,
diff --git a/mysql-test/suite/innodb/r/table_flags,64k.rdiff b/mysql-test/suite/innodb/r/table_flags,64k.rdiff
new file mode 100644
index 00000000000..ce2d7faa925
--- /dev/null
+++ b/mysql-test/suite/innodb/r/table_flags,64k.rdiff
@@ -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),
diff --git a/mysql-test/suite/innodb/r/table_flags,8k.rdiff b/mysql-test/suite/innodb/r/table_flags,8k.rdiff
new file mode 100644
index 00000000000..d5b5731b305
--- /dev/null
+++ b/mysql-test/suite/innodb/r/table_flags,8k.rdiff
@@ -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,
diff --git a/mysql-test/suite/innodb/r/table_flags.result b/mysql-test/suite/innodb/r/table_flags.result
new file mode 100644
index 00000000000..ac7187cd610
--- /dev/null
+++ b/mysql-test/suite/innodb/r/table_flags.result
@@ -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
diff --git a/mysql-test/suite/innodb/t/row_format_redundant.test b/mysql-test/suite/innodb/t/row_format_redundant.test
index f8e25b373de..af3fe3b52cf 100644
--- a/mysql-test/suite/innodb/t/row_format_redundant.test
+++ b/mysql-test/suite/innodb/t/row_format_redundant.test
@@ -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=
diff --git a/mysql-test/suite/innodb/t/table_flags.test b/mysql-test/suite/innodb/t/table_flags.test
new file mode 100644
index 00000000000..a2dd249f090
--- /dev/null
+++ b/mysql-test/suite/innodb/t/table_flags.test
@@ -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
diff --git a/mysql-test/suite/sql_sequence/read_only.result b/mysql-test/suite/sql_sequence/read_only.result
index 3f6a95610dd..38edcc0894b 100644
--- a/mysql-test/suite/sql_sequence/read_only.result
+++ b/mysql-test/suite/sql_sequence/read_only.result
@@ -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;
diff --git a/mysql-test/suite/sql_sequence/read_only.test b/mysql-test/suite/sql_sequence/read_only.test
index 04dab2bb525..73103384882 100644
--- a/mysql-test/suite/sql_sequence/read_only.test
+++ b/mysql-test/suite/sql_sequence/read_only.test
@@ -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;
diff --git a/mysql-test/suite/sys_vars/r/sysvars_server_embedded.result b/mysql-test/suite/sys_vars/r/sysvars_server_embedded.result
index 7885cde4ad1..1f8fc634c6f 100644
--- a/mysql-test/suite/sys_vars/r/sysvars_server_embedded.result
+++ b/mysql-test/suite/sys_vars/r/sysvars_server_embedded.result
@@ -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.
diff --git a/mysql-test/suite/sys_vars/r/sysvars_server_notembedded.result b/mysql-test/suite/sys_vars/r/sysvars_server_notembedded.result
index 0c8647fc946..fdfcda8e0ca 100644
--- a/mysql-test/suite/sys_vars/r/sysvars_server_notembedded.result
+++ b/mysql-test/suite/sys_vars/r/sysvars_server_notembedded.result
@@ -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.
diff --git a/sql/item.cc b/sql/item.cc
index c295c83e1e4..cfe5f137e75 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -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),
   /*
diff --git a/sql/item.h b/sql/item.h
index 76ce4aa935f..bc349e8003a 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -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;
 
   /*
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index 8085e3ded1b..2dcffa08999 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -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 +
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 3b9c1c81fd7..4a4514c5d97 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -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);
diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc
index e0d03fc3173..8206e04f6c2 100644
--- a/sql/sql_prepare.cc
+++ b/sql/sql_prepare.cc
@@ -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 &&
diff --git a/sql/sql_prepare.h b/sql/sql_prepare.h
index 820cb43e6d5..203b37b3b26 100644
--- a/sql/sql_prepare.h
+++ b/sql/sql_prepare.h
@@ -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
diff --git a/storage/innobase/btr/btr0btr.cc b/storage/innobase/btr/btr0btr.cc
index d0fcd68c677..89ebe5b8783 100644
--- a/storage/innobase/btr/btr0btr.cc
+++ b/storage/innobase/btr/btr0btr.cc
@@ -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.",
diff --git a/storage/innobase/dict/dict0load.cc b/storage/innobase/dict/dict0load.cc
index 0ca9ebfc622..55d84bf17df 100644
--- a/storage/innobase/dict/dict0load.cc
+++ b/storage/innobase/dict/dict0load.cc
@@ -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;
diff --git a/storage/innobase/fil/fil0fil.cc b/storage/innobase/fil/fil0fil.cc
index 2cbc863102c..4ce1e7755e3 100644
--- a/storage/innobase/fil/fil0fil.cc
+++ b/storage/innobase/fil/fil0fil.cc
@@ -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. */
diff --git a/storage/innobase/fsp/fsp0file.cc b/storage/innobase/fsp/fsp0file.cc
index b8ad49a254f..346962567d6 100644
--- a/storage/innobase/fsp/fsp0file.cc
+++ b/storage/innobase/fsp/fsp0file.cc
@@ -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);
 }
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index 767c2865528..b4e2983dbd3 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -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 */
diff --git a/storage/innobase/include/dict0dict.ic b/storage/innobase/include/dict0dict.ic
index e9507302e66..0dcbafb2724 100644
--- a/storage/innobase/include/dict0dict.ic
+++ b/storage/innobase/include/dict0dict.ic
@@ -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);
 }
diff --git a/storage/innobase/include/dict0mem.h b/storage/innobase/include/dict0mem.h
index 093a036b331..f78267a1465 100644
--- a/storage/innobase/include/dict0mem.h
+++ b/storage/innobase/include/dict0mem.h
@@ -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
diff --git a/storage/innobase/include/fil0fil.h b/storage/innobase/include/fil0fil.h
index 7d9327c598b..8b87a5a2c90 100644
--- a/storage/innobase/include/fil0fil.h
+++ b/storage/innobase/include/fil0fil.h
@@ -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.
diff --git a/storage/innobase/include/fsp0types.h b/storage/innobase/include/fsp0types.h
index cd2a07af4f0..129fd102f0f 100644
--- a/storage/innobase/include/fsp0types.h
+++ b/storage/innobase/include/fsp0types.h
@@ -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)
 
 /* @} */
 
diff --git a/storage/innobase/row/row0import.cc b/storage/innobase/row/row0import.cc
index 82e17c6fb0a..b2ac33a209b 100644
--- a/storage/innobase/row/row0import.cc
+++ b/storage/innobase/row/row0import.cc
@@ -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;);
diff --git a/storage/innobase/row/row0mysql.cc b/storage/innobase/row/row0mysql.cc
index 2a4be043984..6d314f09bb0 100644
--- a/storage/innobase/row/row0mysql.cc
+++ b/storage/innobase/row/row0mysql.cc
@@ -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
diff --git a/storage/xtradb/btr/btr0btr.cc b/storage/xtradb/btr/btr0btr.cc
index e66599e206d..85a083aaee0 100644
--- a/storage/xtradb/btr/btr0btr.cc
+++ b/storage/xtradb/btr/btr0btr.cc
@@ -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.",
diff --git a/storage/xtradb/dict/dict0load.cc b/storage/xtradb/dict/dict0load.cc
index 4991c4f3fcc..4c3dd47761f 100644
--- a/storage/xtradb/dict/dict0load.cc
+++ b/storage/xtradb/dict/dict0load.cc
@@ -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
diff --git a/storage/xtradb/fil/fil0fil.cc b/storage/xtradb/fil/fil0fil.cc
index 12048bc479f..fdd09a6034e 100644
--- a/storage/xtradb/fil/fil0fil.cc
+++ b/storage/xtradb/fil/fil0fil.cc
@@ -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);
diff --git a/storage/xtradb/handler/ha_innodb.cc b/storage/xtradb/handler/ha_innodb.cc
index 28f5acb2dcc..ba426dd3d3b 100644
--- a/storage/xtradb/handler/ha_innodb.cc
+++ b/storage/xtradb/handler/ha_innodb.cc
@@ -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);
diff --git a/storage/xtradb/include/dict0dict.ic b/storage/xtradb/include/dict0dict.ic
index 4ed1afc8094..f68d4e176da 100644
--- a/storage/xtradb/include/dict0dict.ic
+++ b/storage/xtradb/include/dict0dict.ic
@@ -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. */
diff --git a/storage/xtradb/include/dict0mem.h b/storage/xtradb/include/dict0mem.h
index a32581a0e90..2a4422fc18b 100644
--- a/storage/xtradb/include/dict0mem.h
+++ b/storage/xtradb/include/dict0mem.h
@@ -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
diff --git a/storage/xtradb/include/fil0fil.h b/storage/xtradb/include/fil0fil.h
index a09833c3a73..6eab5db6883 100644
--- a/storage/xtradb/include/fil0fil.h
+++ b/storage/xtradb/include/fil0fil.h
@@ -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 */
diff --git a/storage/xtradb/os/os0file.cc b/storage/xtradb/os/os0file.cc
index 20b202506f5..7fbee0312ee 100644
--- a/storage/xtradb/os/os0file.cc
+++ b/storage/xtradb/os/os0file.cc
@@ -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
 
diff --git a/storage/xtradb/row/row0import.cc b/storage/xtradb/row/row0import.cc
index 2f7aece665a..86b2d782b7b 100644
--- a/storage/xtradb/row/row0import.cc
+++ b/storage/xtradb/row/row0import.cc
@@ -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;);
diff --git a/storage/xtradb/row/row0mysql.cc b/storage/xtradb/row/row0mysql.cc
index 59568f5c91b..0079fc79a0e 100644
--- a/storage/xtradb/row/row0mysql.cc
+++ b/storage/xtradb/row/row0mysql.cc
@@ -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