Pull new version from origin

author: Olivier Bertrand <bertrandop@gmail.com> 2020-03-12 19:16:36 +0100
committer: Olivier Bertrand <bertrandop@gmail.com> 2020-03-12 19:16:36 +0100
commit: d26b4eb4c071f39d2ff262026608d26e7a56309d (patch)
tree: f8ed01ab17f186aa3e0175c143d5345def73dc2c /storage
parent: 4ba36cfa0c677b7d094092d6aa5541c6c936a11f (diff)
parent: 51e9381dcc01ebd72d4f0adc057a64213f850d70 (diff)
download: mariadb-git-d26b4eb4c071f39d2ff262026608d26e7a56309d.tar.gz
371 files changed, 6326 insertions, 5595 deletions
diff --git a/storage/connect/CMakeLists.txt b/storage/connect/CMakeLists.txt
index 0bb1576a0fa..916aa1aad3e 100644
--- a/storage/connect/CMakeLists.txt
+++ b/storage/connect/CMakeLists.txt
@@ -346,6 +346,9 @@ ENDIF(CONNECT_WITH_REST)
 OPTION(CONNECT_WITH_REST "Compile CONNECT storage engine with REST support" ON)
 
 IF(CONNECT_WITH_REST)
+  MESSAGE(STATUS "=====> REST support is ON")
+  SET(CONNECT_SOURCES ${CONNECT_SOURCES} tabrest.cpp tabrest.h)
+  add_definitions(-DREST_SUPPORT)
   FIND_PACKAGE(cpprestsdk QUIET)
   IF (cpprestsdk_FOUND)
 	IF(UNIX)
@@ -359,10 +362,10 @@ IF(CONNECT_WITH_REST)
 #     Comment it out if not needed depending on your cpprestsdk installation.
 	  SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MDd")
 	ENDIF(UNIX)
-    IF(REST_LIBRARY)
-      SET(CONNECT_SOURCES ${CONNECT_SOURCES} tabrest.cpp restget.cpp tabrest.h)
-      add_definitions(-DREST_SUPPORT)
-    ENDIF()
+#   IF(REST_LIBRARY)     why this? how about Windows
+    SET(CONNECT_SOURCES ${CONNECT_SOURCES} restget.cpp)
+    add_definitions(-DREST_SOURCE)
+#   ENDIF()
   ELSE(NOT cpprestsdk_FOUND)
 #    MESSAGE(STATUS "=====> cpprestsdk package not found")
   ENDIF (cpprestsdk_FOUND)
diff --git a/storage/connect/connect.cc b/storage/connect/connect.cc
index 461391d2896..dfc619cf4af 100644
--- a/storage/connect/connect.cc
+++ b/storage/connect/connect.cc
@@ -566,7 +566,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp, bool nox, bool abort)
 			rc = tdbp->DeleteDB(g, RC_EF);    // Specific A.M. delete routine
 
 	} else if (tdbp->GetMode() == MODE_UPDATE && tdbp->IsIndexed())
-		rc = ((PTDBDOX)tdbp)->Txfp->UpdateSortedRows(g);
+		rc = ((PTDBDOS)tdbp)->GetTxfp()->UpdateSortedRows(g);
 
 	switch (rc) {
 		case RC_FX:
@@ -593,7 +593,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp, bool nox, bool abort)
 
 			if (!tdbp->IsRemote()) {
 				// Make all the eventual indexes
-				PTDBDOX tbxp = (PTDBDOX)tdbp;
+				PTDBDOS tbxp = (PTDBDOS)tdbp;
 				tbxp->ResetKindex(g, NULL);
 				tbxp->SetKey_Col(NULL);
 				rc = tbxp->ResetTableOpt(g, true, tbxp->GetDef()->Indexable() == 1);
@@ -622,8 +622,8 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp, bool nox, bool abort)
 int CntIndexInit(PGLOBAL g, PTDB ptdb, int id, bool sorted)
   {
   PIXDEF  xdp;
-  PTDBDOX tdbp;
-  DOXDEF *dfp;
+  PTDBDOS tdbp;
+  DOSDEF *dfp;
 
   if (!ptdb)
     return -1;
@@ -633,9 +633,9 @@ int CntIndexInit(PGLOBAL g, PTDB ptdb, int id, bool sorted)
   } else if (ptdb->GetDef()->Indexable() == 3) {
     return 1;
   } else
-    tdbp= (PTDBDOX)ptdb;
+    tdbp= (PTDBDOS)ptdb;
 
-  dfp= (DOXDEF*)tdbp->To_Def;
+  dfp= (DOSDEF*)tdbp->GetDef();
 
 //if (!(k= colp->GetKey()))
 //  if (colp->GetOpt() >= 2) {
@@ -645,16 +645,16 @@ int CntIndexInit(PGLOBAL g, PTDB ptdb, int id, bool sorted)
       // This is a pseudo indexed sorted block optimized column
 //    return 0;
 
-  if (tdbp->To_Kindex)
-    if (((XXBASE*)tdbp->To_Kindex)->GetID() == id) {
-      tdbp->To_Kindex->Reset();                // Same index
-      return (tdbp->To_Kindex->IsMul()) ? 2 : 1;
+  if (tdbp->GetKindex())
+    if (((XXBASE*)tdbp->GetKindex())->GetID() == id) {
+      tdbp->GetKindex()->Reset();                // Same index
+      return (tdbp->GetKindex()->IsMul()) ? 2 : 1;
     } else {
-      tdbp->To_Kindex->Close();
-      tdbp->To_Kindex= NULL;
+      tdbp->GetKindex()->Close();
+      tdbp->SetKindex(NULL);
     } // endif colp
 
-  for (xdp= dfp->To_Indx; xdp; xdp= xdp->GetNext())
+  for (xdp= dfp->GetIndx(); xdp; xdp= xdp->GetNext())
     if (xdp->GetID() == id)
       break;
 
@@ -676,7 +676,7 @@ int CntIndexInit(PGLOBAL g, PTDB ptdb, int id, bool sorted)
   if (tdbp->InitialyzeIndex(g, xdp, sorted))
     return 0;
 
-  return (tdbp->To_Kindex->IsMul()) ? 2 : 1;
+  return (tdbp->GetKindex()->IsMul()) ? 2 : 1;
   } // end of CntIndexInit
 
 #if defined(WORDS_BIGENDIAN)
@@ -710,7 +710,7 @@ RCODE CntIndexRead(PGLOBAL g, PTDB ptdb, OPVAL op,
   int     n, x;
   RCODE   rc;
   XXBASE *xbp;
-	PTDBDOX tdbp;
+	PTDBDOS tdbp;
 
   if (!ptdb)
     return RC_FX;
@@ -736,12 +736,12 @@ RCODE CntIndexRead(PGLOBAL g, PTDB ptdb, OPVAL op,
 
     goto rnd;
   } else
-    tdbp= (PTDBDOX)ptdb;
+    tdbp= (PTDBDOS)ptdb;
 
   // Set reference values and index operator
-  if (!tdbp->To_Link || !tdbp->To_Kindex) {
+  if (!tdbp->GetLink() || !tdbp->GetKindex()) {
 //  if (!tdbp->To_Xdp) {
-      sprintf(g->Message, "Index not initialized for table %s", tdbp->Name);
+      sprintf(g->Message, "Index not initialized for table %s", tdbp->GetName());
       return RC_FX;
 #if 0
       } // endif !To_Xdp
@@ -754,7 +754,7 @@ RCODE CntIndexRead(PGLOBAL g, PTDB ptdb, OPVAL op,
 #endif // 0
     } // endif !To_Kindex
 
-  xbp= (XXBASE*)tdbp->To_Kindex;
+  xbp= (XXBASE*)tdbp->GetKindex();
 
   if (kr) {
 		char   *kp= (char*)kr->key;
@@ -764,13 +764,13 @@ RCODE CntIndexRead(PGLOBAL g, PTDB ptdb, OPVAL op,
 		PVAL    valp;
 		PCOL    colp;
 
-    for (n= 0; n < tdbp->Knum; n++) {
-      colp= (PCOL)tdbp->To_Key_Col[n];
+    for (n= 0; n < tdbp->GetKnum(); n++) {
+      colp= (PCOL)tdbp->Key(n);
 
       if (colp->GetColUse(U_NULLS))
         kp++;                   // Skip null byte
 
-      valp= tdbp->To_Link[n]->GetValue();
+      valp= tdbp->Link(n)->GetValue();
 
       if (!valp->IsTypeNum()) {
         if (colp->GetColUse(U_VAR)) {
@@ -840,7 +840,7 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
   bool    b, rcb;
   PVAL    valp;
   PCOL    colp;
-  PTDBDOX tdbp;
+  PTDBDOS tdbp;
   XXBASE *xbp;
 
   if (!ptdb)
@@ -865,35 +865,35 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
 
     return k[1] - k[0] + 1;
   } else
-    tdbp= (PTDBDOX)ptdb;
+    tdbp= (PTDBDOS)ptdb;
 
-  if (!tdbp->To_Kindex || !tdbp->To_Link) {
-    if (!tdbp->To_Xdp) {
-      sprintf(g->Message, "Index not initialized for table %s", tdbp->Name);
+  if (!tdbp->GetKindex() || !tdbp->GetLink()) {
+    if (!tdbp->GetXdp()) {
+      sprintf(g->Message, "Index not initialized for table %s", tdbp->GetName());
       DBUG_PRINT("Range", ("%s", g->Message));
       return -1;
     } else       // Dynamic index
-      return tdbp->To_Xdp->GetMaxSame();     // TODO a better estimate
+      return tdbp->GetXdp()->GetMaxSame();     // TODO a better estimate
 
   } else
-    xbp= (XXBASE*)tdbp->To_Kindex;
+    xbp= (XXBASE*)tdbp->GetKindex();
 
   for (b= false, i= 0; i < 2; i++) {
     p= kp= key[i];
 
     if (kp) {
-      for (n= 0; n < tdbp->Knum; n++) {
+      for (n= 0; n < tdbp->GetKnum(); n++) {
         if (kmap[i] & (key_part_map)(1 << n)) {
           if (b == true)
             // Cannot do indexing with missing intermediate key
             return -1;
 
-          colp= (PCOL)tdbp->To_Key_Col[n];
+          colp= (PCOL)tdbp->Key(n);
 
           if (colp->GetColUse(U_NULLS))
             p++;                   // Skip null byte  ???
 
-          valp= tdbp->To_Link[n]->GetValue();
+          valp= tdbp->Link(n)->GetValue();
 
           if (!valp->IsTypeNum()) {
             if (colp->GetColUse(U_VAR)) {
diff --git a/storage/connect/connect.h b/storage/connect/connect.h
index cf0373ba635..af1b9ba726e 100644
--- a/storage/connect/connect.h
+++ b/storage/connect/connect.h
@@ -46,6 +46,7 @@ int   CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
                     bool *incl, key_part_map *kmap);
 PGLOBAL CntExit(PGLOBAL g);
 
+#if 0
 /***********************************************************************/
 /*  Definition of classes XKPDEF, DOXDEF, TDBDOX                       */
 /*  These classes purpose is chiefly to access protected items!        */
@@ -76,3 +77,4 @@ class XKPDEF: public KPARTDEF {
  public:
   XKPDEF(const char *name, int n) : KPARTDEF((PSZ)name, n) {}
   }; // end of class XKPDEF
+#endif // 0
diff --git a/storage/connect/filamzip.cpp b/storage/connect/filamzip.cpp
index e76dc496246..f7866b9dae1 100644
--- a/storage/connect/filamzip.cpp
+++ b/storage/connect/filamzip.cpp
@@ -700,7 +700,7 @@ bool UNZIPUTL::openEntry(PGLOBAL g)
 	} // endif rc
 
 	if (trace(1))
-		htrc("Openning entry%s %s\n", fn, (entryopen) ? "oked" : "failed");
+		htrc("Opening entry%s %s\n", fn, (entryopen) ? "oked" : "failed");
 
 	return !entryopen;
 }	// end of openEntry
diff --git a/storage/connect/filter.h b/storage/connect/filter.h
index b0fea3d69e0..c6ab8fddd35 100644
--- a/storage/connect/filter.h
+++ b/storage/connect/filter.h
@@ -48,7 +48,6 @@ class DllExport FILTER : public XOBJECT { /* Filter description block  */
           PVAL  &Val(int i) {return Test[i].Value;}
           bool  &Conv(int i) {return Test[i].Conv;}
           void   SetNext(PFIL filp) {Next = filp;}
-          bool MakeSelector(PGLOBAL g, PSTRG s);
 
   // Methods
   virtual void   Reset(void);
diff --git a/storage/connect/ha_connect.cc b/storage/connect/ha_connect.cc
index da9c41ba247..d64ed0022ed 100644
--- a/storage/connect/ha_connect.cc
+++ b/storage/connect/ha_connect.cc
@@ -170,9 +170,13 @@
 #define JSONMAX      10             // JSON Default max grp size
 
 extern "C" {
+<<<<<<< HEAD
        char version[]= "Version 1.06.0010 August 22, 2019";
+=======
+       char version[]= "Version 1.07.0001 November 12, 2019";
+>>>>>>> 51e9381dcc01ebd72d4f0adc057a64213f850d70
 #if defined(__WIN__)
-       char compver[]= "Version 1.06.0010 " __DATE__ " "  __TIME__;
+       char compver[]= "Version 1.07.0001 " __DATE__ " "  __TIME__;
        char slash= '\\';
 #else   // !__WIN__
        char slash= '/';
@@ -704,9 +708,9 @@ DllExport LPCSTR PlugSetPath(LPSTR to, LPCSTR name, LPCSTR dir)
   used by the default rename_table and delete_table method in
   handler.cc.
 
-  For engines that have two file name extentions (separate meta/index file
+  For engines that have two file name extensions (separate meta/index file
   and data file), the order of elements is relevant. First element of engine
-  file name extentions array should be meta/index file extention. Second
+  file name extensions array should be meta/index file extention. Second
   element - data file extention. This order is assumed by
   prepare_for_repair() when REPAIR TABLE ... USE_FRM is issued.
 
@@ -1043,6 +1047,8 @@ TABTYPE ha_connect::GetRealType(PTOS pos)
 				case TAB_REST:
 					type = TAB_NIY;
 					break;
+				default:
+					break;
 			}	// endswitch type
 #endif   // REST_SUPPORT
 
@@ -2962,10 +2968,19 @@ PCFIL ha_connect::CheckCond(PGLOBAL g, PCFIL filp, const Item *cond)
 			case Item_func::LE_FUNC:     vop= OP_LE;   break;
 			case Item_func::GE_FUNC:     vop= OP_GE;   break;
 			case Item_func::GT_FUNC:     vop= OP_GT;   break;
+<<<<<<< HEAD
 			//case Item_func::LIKE_FUNC:
 			//	vop= OP_LIKE; 
 			//	neg= ((Item_func_like *)condf)->negated;
 			//	break;
+=======
+#if MYSQL_VERSION_ID > 100200
+			case Item_func::LIKE_FUNC:
+				vop = OP_LIKE;
+			  neg= ((Item_func_like*)condf)->negated;
+			  break;
+#endif // VERSION_ID > 100200
+>>>>>>> 51e9381dcc01ebd72d4f0adc057a64213f850d70
 			case Item_func::ISNOTNULL_FUNC:
 				neg= true;	
 				// fall through
@@ -3783,9 +3798,9 @@ int ha_connect::index_init(uint idx, bool sorted)
     active_index= MAX_KEY;
     rc= HA_ERR_INTERNAL_ERROR;
   } else if (tdbp->GetKindex()) {
-    if (((PTDBDOX)tdbp)->To_Kindex->GetNum_K()) {
+    if (((PTDBDOS)tdbp)->GetKindex()->GetNum_K()) {
       if (tdbp->GetFtype() != RECFM_NAF)
-        ((PTDBDOX)tdbp)->GetTxfp()->ResetBuffer(g);
+        ((PTDBDOS)tdbp)->GetTxfp()->ResetBuffer(g);
 
       active_index= idx;
 //  } else {        // Void table
@@ -4503,7 +4518,9 @@ bool ha_connect::check_privileges(THD *thd, PTOS options, const char *dbn, bool
 		case TAB_OEM:
       if (table && table->pos_in_table_list) // if SELECT
       {
-        Switch_to_definer_security_ctx backup_ctx(thd, table->pos_in_table_list);
+#if MYSQL_VERSION_ID > 100200
+				Switch_to_definer_security_ctx backup_ctx(thd, table->pos_in_table_list);
+#endif // VERSION_ID > 100200
         return check_global_access(thd, FILE_ACL);
       }
       else
@@ -5630,6 +5647,8 @@ static int connect_assisted_discovery(handlerton *, THD* thd,
 				case TAB_CSV:
 					ttp = TAB_REST;
 					break;
+				default:
+					break;
 			}	// endswitch type
 #endif   // REST_SUPPORT
 		} // endif ttp
@@ -6039,7 +6058,7 @@ static int connect_assisted_discovery(handlerton *, THD* thd,
 				} // endif !nblin
 
 				for (i= 0; !rc && i < qrp->Nblin; i++) {
-					typ= len= prec= dec= 0;
+					typ= len= prec= dec= flg= 0;
 					tm= NOT_NULL_FLAG;
 					cnm= (char*)"noname";
 					dft= xtra= key= fmt= tn= NULL;
@@ -6080,6 +6099,9 @@ static int connect_assisted_discovery(handlerton *, THD* thd,
 									tm= 0;               // Nullable
 
 								break;
+							case FLD_FLAG:
+								flg = crp->Kdata->GetIntValue(i);
+								break;
 							case FLD_FORMAT:
 								fmt= (crp->Kdata) ? crp->Kdata->GetCharValue(i) : NULL;
 								break;
@@ -6210,7 +6232,7 @@ static int connect_assisted_discovery(handlerton *, THD* thd,
 
 						// Now add the field
 						if (add_field(&sql, cnm, typ, prec, dec, key, tm, rem, dft, xtra,
-							fmt, 0, dbf, v))
+							fmt, flg, dbf, v))
 							rc= HA_ERR_OUT_OF_MEM;
 				} // endfor i
 
@@ -7362,14 +7384,14 @@ maria_declare_plugin(connect)
   &connect_storage_engine,
   "CONNECT",
   "Olivier Bertrand",
-  "Management of External Data (SQL/NOSQL/MED), including many file formats",
+  "Management of External Data (SQL/NOSQL/MED), including Rest query results",
   PLUGIN_LICENSE_GPL,
   connect_init_func,                            /* Plugin Init */
   connect_done_func,                            /* Plugin Deinit */
-  0x0106,                                       /* version number (1.06) */
+  0x0107,                                       /* version number (1.07) */
   NULL,                                         /* status variables */
   connect_system_variables,                     /* system variables */
-  "1.06.0010",                                  /* string version */
+  "1.07.0001",                                  /* string version */
 	MariaDB_PLUGIN_MATURITY_STABLE                /* maturity */
 }
 maria_declare_plugin_end;
diff --git a/storage/connect/javaconn.cpp b/storage/connect/javaconn.cpp
index f919344f20b..e3f64d17064 100644
--- a/storage/connect/javaconn.cpp
+++ b/storage/connect/javaconn.cpp
@@ -142,7 +142,7 @@ bool JAVAConn::Check(jint rc)
 			s = (jstring)env->CallObjectMethod(exc, tid);
 			Msg = GetUTFString(s);
 		} else
-			Msg = "Exception occured";
+			Msg = "Exception occurred";
 
 		env->ExceptionClear();
 	} else if (rc < 0) {
diff --git a/storage/connect/mycat.cc b/storage/connect/mycat.cc
index 411e96e3dc8..f8b3dc03aa5 100644
--- a/storage/connect/mycat.cc
+++ b/storage/connect/mycat.cc
@@ -95,7 +95,7 @@
 #endif   // ZIP_SUPPORT
 #if defined(REST_SUPPORT)
 #include "tabrest.h"
-#endif   // Rest_SUPPORT
+#endif   // REST_SUPPORT
 #include "mycat.h"
 
 /***********************************************************************/
@@ -104,8 +104,9 @@
 #if defined(__WIN__)
 extern "C" HINSTANCE s_hModule;           // Saved module handle
 #endif  // !__WIN__
-
-PQRYRES OEMColumns(PGLOBAL g, PTOS topt, char *tab, char *db, bool info);
+#if defined(JAVA_SUPPORT) || defined(CMGO_SUPPORT)
+bool MongoEnabled(void);
+#endif   // JAVA_SUPPORT || CMGO_SUPPORT
 
 /***********************************************************************/
 /*  Get the plugin directory.                                          */
@@ -347,100 +348,6 @@ uint GetFuncID(const char *func)
   return fnc;
   } // end of GetFuncID
 
-/***********************************************************************/
-/*  OEMColumn: Get table column info for an OEM table.                 */
-/***********************************************************************/
-PQRYRES OEMColumns(PGLOBAL g, PTOS topt, char *tab, char *db, bool info)
-  {
-  typedef PQRYRES (__stdcall *XCOLDEF) (PGLOBAL, void*, char*, char*, bool);
-  const char *module, *subtype;
-  char    c, soname[_MAX_PATH], getname[40] = "Col";
-#if defined(__WIN__)
-  HANDLE  hdll;               /* Handle to the external DLL            */
-#else   // !__WIN__
-  void   *hdll;               /* Handle for the loaded shared library  */
-#endif  // !__WIN__
-  XCOLDEF coldef = NULL;
-  PQRYRES qrp = NULL;
-
-  module = topt->module;
-  subtype = topt->subtype;
-
-  if (!module || !subtype)
-    return NULL;
-
-  /*********************************************************************/
-  /*  Ensure that the .dll doesn't have a path.                        */
-  /*  This is done to ensure that only approved dll from the system    */
-  /*  directories are used (to make this even remotely secure).        */
-  /*********************************************************************/
-  if (check_valid_path(module, strlen(module))) {
-    strcpy(g->Message, "Module cannot contain a path");
-    return NULL;
-  } else
-    PlugSetPath(soname, module, GetPluginDir());
-
-  // The exported name is always in uppercase
-  for (int i = 0; ; i++) {
-    c = subtype[i];
-    getname[i + 3] = toupper(c);
-    if (!c) break;
-    } // endfor i
-
-#if defined(__WIN__)
-  // Load the Dll implementing the table
-  if (!(hdll = LoadLibrary(soname))) {
-    char  buf[256];
-    DWORD rc = GetLastError();
-
-    sprintf(g->Message, MSG(DLL_LOAD_ERROR), rc, soname);
-    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
-                  FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0,
-                  (LPTSTR)buf, sizeof(buf), NULL);
-    strcat(strcat(g->Message, ": "), buf);
-    return NULL;
-    } // endif hDll
-
-  // Get the function returning an instance of the external DEF class
-  if (!(coldef = (XCOLDEF)GetProcAddress((HINSTANCE)hdll, getname))) {
-    sprintf(g->Message, MSG(PROCADD_ERROR), GetLastError(), getname);
-    FreeLibrary((HMODULE)hdll);
-    return NULL;
-    } // endif coldef
-#else   // !__WIN__
-  const char *error = NULL;
-
-  // Load the desired shared library
-  if (!(hdll = dlopen(soname, RTLD_LAZY))) {
-    error = dlerror();
-    sprintf(g->Message, MSG(SHARED_LIB_ERR), soname, SVP(error));
-    return NULL;
-    } // endif Hdll
-
-  // Get the function returning an instance of the external DEF class
-  if (!(coldef = (XCOLDEF)dlsym(hdll, getname))) {
-    error = dlerror();
-    sprintf(g->Message, MSG(GET_FUNC_ERR), getname, SVP(error));
-    dlclose(hdll);
-    return NULL;
-    } // endif coldef
-#endif  // !__WIN__
-
-  // Just in case the external Get function does not set error messages
-  sprintf(g->Message, "Error getting column info from %s", subtype);
-
-  // Get the table column definition
-  qrp = coldef(g, topt, tab, db, info);
-
-#if defined(__WIN__)
-  FreeLibrary((HMODULE)hdll);
-#else   // !__WIN__
-  dlclose(hdll);
-#endif  // !__WIN__
-
-  return qrp;
-  } // end of OEMColumns
-
 /* ------------------------- Class CATALOG --------------------------- */
 
 /***********************************************************************/
@@ -481,10 +388,10 @@ void MYCAT::Reset(void)
 /*  GetTableDesc: retrieve a table descriptor.                         */
 /*  Look for a table descriptor matching the name and type.            */
 /***********************************************************************/
-PRELDEF MYCAT::GetTableDesc(PGLOBAL g, PTABLE tablep,
+PTABDEF MYCAT::GetTableDesc(PGLOBAL g, PTABLE tablep,
                                        LPCSTR type, PRELDEF *)
 {
-  PRELDEF tdp= NULL;
+  PTABDEF tdp= NULL;
 
   if (trace(1))
     htrc("GetTableDesc: name=%s am=%s\n", tablep->GetName(), SVP(type));
@@ -505,12 +412,12 @@ PRELDEF MYCAT::GetTableDesc(PGLOBAL g, PTABLE tablep,
 /*  MakeTableDesc: make a table/view description.                      */
 /*  Note: caller must check if name already exists before calling it.  */
 /***********************************************************************/
-PRELDEF MYCAT::MakeTableDesc(PGLOBAL g, PTABLE tablep, LPCSTR am)
+PTABDEF MYCAT::MakeTableDesc(PGLOBAL g, PTABLE tablep, LPCSTR am)
   {
   TABTYPE tc;
   LPCSTR  name= (PSZ)PlugDup(g, tablep->GetName());
   LPCSTR  schema= (PSZ)PlugDup(g, tablep->GetSchema());
-  PRELDEF tdp= NULL;
+  PTABDEF tdp= NULL;
 
   if (trace(1))
     htrc("MakeTableDesc: name=%s schema=%s am=%s\n",
@@ -578,8 +485,8 @@ PRELDEF MYCAT::MakeTableDesc(PGLOBAL g, PTABLE tablep, LPCSTR am)
     } // endswitch
 
   // Do make the table/view definition
-  if (tdp && tdp->Define(g, this, name, schema, am))
-    tdp= NULL;
+	if (tdp && tdp->Define(g, this, name, schema, am))
+		tdp = NULL;
 
   if (trace(1))
     htrc("Table %s made\n", am);
@@ -592,7 +499,7 @@ PRELDEF MYCAT::MakeTableDesc(PGLOBAL g, PTABLE tablep, LPCSTR am)
 /***********************************************************************/
 PTDB MYCAT::GetTable(PGLOBAL g, PTABLE tablep, MODE mode, LPCSTR type)
   {
-  PRELDEF tdp;
+  PTABDEF tdp;
   PTDB    tdbp= NULL;
 //  LPCSTR  name= tablep->GetName();
 
diff --git a/storage/connect/mycat.h b/storage/connect/mycat.h
index 818e535b32d..6473f7a5c11 100644
--- a/storage/connect/mycat.h
+++ b/storage/connect/mycat.h
@@ -102,14 +102,14 @@ class MYCAT : public CATALOG {
   // Methods
   void    Reset(void);
   bool    StoreIndex(PGLOBAL, PTABDEF) {return false;}  // Temporary
-	PRELDEF GetTableDesc(PGLOBAL g, PTABLE tablep,
+	PTABDEF GetTableDesc(PGLOBAL g, PTABLE tablep,
 		                   LPCSTR type, PRELDEF *prp = NULL);
   PTDB    GetTable(PGLOBAL g, PTABLE tablep, 
                               MODE mode = MODE_READ, LPCSTR type = NULL);
   void    ClearDB(PGLOBAL g);
 
  protected:
-	PRELDEF MakeTableDesc(PGLOBAL g, PTABLE tablep, LPCSTR am);
+	PTABDEF MakeTableDesc(PGLOBAL g, PTABLE tablep, LPCSTR am);
 
   // Members
   ha_connect *Hc;                          // The Connect handler
diff --git a/storage/connect/myconn.cpp b/storage/connect/myconn.cpp
index 6de5a73875c..4303a9e191b 100644
--- a/storage/connect/myconn.cpp
+++ b/storage/connect/myconn.cpp
@@ -472,7 +472,7 @@ int MYSQLC::Open(PGLOBAL g, const char *host, const char *db,
                             int pt, const char *csname)
   {
   const char *pipe = NULL;
-  uint        cto = 10, nrt = 20;
+  //uint      cto = 10, nrt = 20;
   my_bool     my_true= 1;
 
   m_DB = mysql_init(NULL);
@@ -485,11 +485,11 @@ int MYSQLC::Open(PGLOBAL g, const char *host, const char *db,
 	if (trace(1))
 		htrc("MYSQLC Open: m_DB=%.4X size=%d\n", m_DB, (int)sizeof(*m_DB));
 
-	// Removed to do like FEDERATED do
+	// Removed to do like FEDERATED does
 //mysql_options(m_DB, MYSQL_READ_DEFAULT_GROUP, "client-mariadb");
-  mysql_options(m_DB, MYSQL_OPT_USE_REMOTE_CONNECTION, NULL);
-  mysql_options(m_DB, MYSQL_OPT_CONNECT_TIMEOUT, &cto);
-  mysql_options(m_DB, MYSQL_OPT_READ_TIMEOUT, &nrt);
+//mysql_options(m_DB, MYSQL_OPT_USE_REMOTE_CONNECTION, NULL);
+//mysql_options(m_DB, MYSQL_OPT_CONNECT_TIMEOUT, &cto);
+//mysql_options(m_DB, MYSQL_OPT_READ_TIMEOUT, &nrt);
 //mysql_options(m_DB, MYSQL_OPT_WRITE_TIMEOUT, ...);
 
 #if defined(__WIN__)
diff --git a/storage/connect/mysql-test/connect/disabled.def b/storage/connect/mysql-test/connect/disabled.def
index 1de4deb0a60..a4d629fc3d1 100644
--- a/storage/connect/mysql-test/connect/disabled.def
+++ b/storage/connect/mysql-test/connect/disabled.def
@@ -20,4 +20,5 @@ mongo_c         : Need MongoDB running and its C Driver installed
 mongo_java_2    : Need MongoDB running and its Java Driver installed
 mongo_java_3    : Need MongoDB running and its Java Driver installed
 tbl_thread      : Bug MDEV-9844,10179,14214 03/01/2018 OB Option THREAD removed
+grant2          : Until fixed
 #vcol            : Different error code on different versions
diff --git a/storage/connect/mysql-test/connect/t/ini_grant.result b/storage/connect/mysql-test/connect/t/ini_grant.result
new file mode 100644
index 00000000000..96d5e192c7d
--- /dev/null
+++ b/storage/connect/mysql-test/connect/t/ini_grant.result
@@ -0,0 +1,89 @@
+#
+# Checking FILE privileges
+#
+set sql_mode="";
+GRANT ALL PRIVILEGES ON *.* TO user@localhost;
+REVOKE FILE ON *.* FROM user@localhost;
+set sql_mode=default;
+connect user,localhost,user,,;
+connection user;
+SELECT user();
+user()
+user@localhost
+CREATE TABLE t1 (sec CHAR(10) NOT NULL FLAG=1, val CHAR(10) NOT NULL) ENGINE=CONNECT TABLE_TYPE=INI;
+Warnings:
+Warning	1105	No file name. Table will use t1.ini
+INSERT INTO t1 VALUES ('sec1','val1');
+SELECT * FROM t1;
+sec	val
+sec1	val1
+UPDATE t1 SET val='val11';
+SELECT * FROM t1;
+sec	val
+sec1	val11
+DELETE FROM t1;
+SELECT * FROM t1;
+sec	val
+INSERT INTO t1 VALUES('sec2','val2');
+TRUNCATE TABLE t1;
+SELECT * FROM t1;
+sec	val
+CREATE VIEW v1 AS SELECT * FROM t1;
+SELECT * FROM v1;
+sec	val
+DROP VIEW v1;
+DROP TABLE t1;
+CREATE TABLE t1 (sec CHAR(10) NOT NULL FLAG=1, val CHAR(10) NOT NULL) ENGINE=CONNECT TABLE_TYPE=INI FILE_NAME='t1.EXT';
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+connection default;
+SELECT user();
+user()
+root@localhost
+CREATE TABLE t1 (sec CHAR(10) NOT NULL FLAG=1, val CHAR(10) NOT NULL) ENGINE=CONNECT TABLE_TYPE=INI FILE_NAME='t1.EXT';
+INSERT INTO t1 VALUES ('sec1','val1');
+connection user;
+SELECT user();
+user()
+user@localhost
+INSERT INTO t1 VALUES ('sec2','val2');
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+SELECT * FROM t1;
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+UPDATE t1 SET val='val11';
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+DELETE FROM t1;
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+TRUNCATE TABLE t1;
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+ALTER TABLE t1 READONLY=1;
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+DROP TABLE t1;
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+CREATE VIEW v1 AS SELECT * FROM t1;
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+# Testing a VIEW created with FILE privileges but accessed with no FILE
+connection default;
+SELECT user();
+user()
+root@localhost
+CREATE SQL SECURITY INVOKER VIEW v1 AS SELECT * FROM t1;
+connection user;
+SELECT user();
+user()
+user@localhost
+SELECT * FROM v1;
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+INSERT INTO v1 VALUES ('sec3','val3');
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+UPDATE v1 SET val='val11';
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+DELETE FROM v1;
+ERROR 42000: Access denied; you need (at least one of) the FILE privilege(s) for this operation
+disconnect user;
+connection default;
+DROP VIEW v1;
+DROP TABLE t1;
+DROP USER user@localhost;
+#
+# Checking FILE privileges: done
+#
diff --git a/storage/connect/plgdbsem.h b/storage/connect/plgdbsem.h
index f10ae209e9d..a40e32bcfb2 100644
--- a/storage/connect/plgdbsem.h
+++ b/storage/connect/plgdbsem.h
@@ -149,16 +149,22 @@ enum AMT {TYPE_AM_ERROR =   0,        /* Type not defined              */
 	        TYPE_AM_MGO   = 194,				/* MGO access method type no     */
 					TYPE_AM_OUT   = 200};       /* Output relations (storage)    */
 
-enum RECFM {RECFM_NAF   =    -2,      /* Not a file                    */
-            RECFM_OEM   =    -1,      /* OEM file access method        */
-            RECFM_VAR   =     0,      /* Varying length DOS files      */
-            RECFM_FIX   =     1,      /* Fixed length DOS files        */
-            RECFM_BIN   =     2,      /* Binary DOS files (also fixed) */
-            RECFM_VCT   =     3,      /* VCT formatted files           */
-            RECFM_ODBC  =     4,      /* Table accessed via ODBC       */
-						RECFM_JDBC  =     5,      /* Table accessed via JDBC       */
-						RECFM_PLG   =     6,      /* Table accessed via PLGconn    */
-            RECFM_DBF   =     7};     /* DBase formatted file          */
+enum RECFM {RECFM_DFLT  =     0,      /* Default table type            */
+            RECFM_NAF   =     1,      /* Not a file table              */
+            RECFM_OEM   =     2,      /* OEM table                     */
+            RECFM_VAR   =     3,      /* Varying length DOS files      */
+            RECFM_FIX   =     4,      /* Fixed length DOS files        */
+            RECFM_BIN   =     5,      /* Binary DOS files (also fixed) */
+						RECFM_DBF   =     6,      /* DBase formatted file          */
+						RECFM_CSV   =     7,      /* CSV file                      */
+						RECFM_FMT   =     8,      /* FMT formatted file            */
+						RECFM_VCT   =     9,      /* VCT formatted files           */
+						RECFM_XML   =    10,      /* XML formatted files           */
+						RECFM_JASON =    11,      /* JASON formatted files         */
+						RECFM_DIR   =    12,      /* DIR table                     */
+						RECFM_ODBC  =    13,      /* Table accessed via ODBC       */
+						RECFM_JDBC  =    14,      /* Table accessed via JDBC       */
+						RECFM_PLG   =    15};     /* Table accessed via PLGconn    */
 
 enum MISC {DB_TABNO     =     1,      /* DB routines in Utility Table  */
            MAX_MULT_KEY =    10,      /* Max multiple key number       */
@@ -537,7 +543,8 @@ enum XFLD {FLD_NO       =  0,         /* Not a field definition item   */
            FLD_FORMAT   = 16,         /* Field format                  */
            FLD_CAT      = 17,         /* Table catalog                 */
            FLD_SCHEM    = 18,         /* Table schema                  */
-           FLD_TABNAME  = 19};        /* Column Table name             */
+           FLD_TABNAME  = 19,         /* Column Table name             */
+					 FLD_FLAG     = 20};        /* Field flag (CONNECT specific) */
 
 /***********************************************************************/
 /*  Result of last SQL noconv query.                                   */
diff --git a/storage/connect/reldef.cpp b/storage/connect/reldef.cpp
index 8ba8aac3621..2d3c6a6aacd 100644
--- a/storage/connect/reldef.cpp
+++ b/storage/connect/reldef.cpp
@@ -1,11 +1,11 @@
 /************* RelDef CPP Program Source Code File (.CPP) **************/
 /* PROGRAM NAME: RELDEF                                                */
 /* -------------                                                       */
-/*  Version 1.6                                                        */
+/*  Version 1.7                                                        */
 /*                                                                     */
 /* COPYRIGHT:                                                          */
 /* ----------                                                          */
-/*  (C) Copyright to the author Olivier BERTRAND          2004-2016    */
+/*  (C) Copyright to the author Olivier BERTRAND          2004-2019    */
 /*                                                                     */
 /* WHAT THIS PROGRAM DOES:                                             */
 /* -----------------------                                             */
@@ -20,7 +20,7 @@
 #if defined(__WIN__)
 #include <sqlext.h>
 #else
-#include <dlfcn.h>          // dlopen(), dlclose(), dlsym() ...
+//#include <dlfcn.h>          // dlopen(), dlclose(), dlsym() ...
 #include "osutil.h"
 //#include "sqlext.h"
 #endif
@@ -61,6 +61,102 @@ extern handlerton *connect_hton;
 /***********************************************************************/
 USETEMP UseTemp(void);
 char   *GetPluginDir(void);
+PQRYRES OEMColumns(PGLOBAL g, PTOS topt, char* tab, char* db, bool info);
+
+/***********************************************************************/
+/*  OEMColumns: Get table column info for an OEM table.                */
+/***********************************************************************/
+PQRYRES OEMColumns(PGLOBAL g, PTOS topt, char* tab, char* db, bool info)
+{
+	typedef PQRYRES(__stdcall* XCOLDEF) (PGLOBAL, void*, char*, char*, bool);
+	const char* module, * subtype;
+	char    c, soname[_MAX_PATH], getname[40] = "Col";
+#if defined(__WIN__)
+	HANDLE  hdll;               /* Handle to the external DLL            */
+#else   // !__WIN__
+	void* hdll;               /* Handle for the loaded shared library  */
+#endif  // !__WIN__
+	XCOLDEF coldef = NULL;
+	PQRYRES qrp = NULL;
+
+	module = topt->module;
+	subtype = topt->subtype;
+
+	if (!module || !subtype)
+		return NULL;
+
+	/*********************************************************************/
+	/*  Ensure that the .dll doesn't have a path.                        */
+	/*  This is done to ensure that only approved dll from the system    */
+	/*  directories are used (to make this even remotely secure).        */
+	/*********************************************************************/
+	if (check_valid_path(module, strlen(module))) {
+		strcpy(g->Message, "Module cannot contain a path");
+		return NULL;
+	}
+	else
+		PlugSetPath(soname, module, GetPluginDir());
+
+	// The exported name is always in uppercase
+	for (int i = 0; ; i++) {
+		c = subtype[i];
+		getname[i + 3] = toupper(c);
+		if (!c) break;
+	} // endfor i
+
+#if defined(__WIN__)
+	// Load the Dll implementing the table
+	if (!(hdll = LoadLibrary(soname))) {
+		char  buf[256];
+		DWORD rc = GetLastError();
+
+		sprintf(g->Message, MSG(DLL_LOAD_ERROR), rc, soname);
+		FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+			FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0,
+			(LPTSTR)buf, sizeof(buf), NULL);
+		strcat(strcat(g->Message, ": "), buf);
+		return NULL;
+	} // endif hDll
+
+// Get the function returning an instance of the external DEF class
+	if (!(coldef = (XCOLDEF)GetProcAddress((HINSTANCE)hdll, getname))) {
+		sprintf(g->Message, MSG(PROCADD_ERROR), GetLastError(), getname);
+		FreeLibrary((HMODULE)hdll);
+		return NULL;
+	} // endif coldef
+#else   // !__WIN__
+	const char* error = NULL;
+
+	// Load the desired shared library
+	if (!(hdll = dlopen(soname, RTLD_LAZY))) {
+		error = dlerror();
+		sprintf(g->Message, MSG(SHARED_LIB_ERR), soname, SVP(error));
+		return NULL;
+	} // endif Hdll
+
+// Get the function returning an instance of the external DEF class
+	if (!(coldef = (XCOLDEF)dlsym(hdll, getname))) {
+		error = dlerror();
+		sprintf(g->Message, MSG(GET_FUNC_ERR), getname, SVP(error));
+		dlclose(hdll);
+		return NULL;
+	} // endif coldef
+#endif  // !__WIN__
+
+	// Just in case the external Get function does not set error messages
+	sprintf(g->Message, "Error getting column info from %s", subtype);
+
+	// Get the table column definition
+	qrp = coldef(g, topt, tab, db, info);
+
+#if defined(__WIN__)
+	FreeLibrary((HMODULE)hdll);
+#else   // !__WIN__
+	dlclose(hdll);
+#endif  // !__WIN__
+
+	return qrp;
+} // end of OEMColumns
 
 /* --------------------------- Class RELDEF -------------------------- */
 
@@ -208,6 +304,7 @@ TABDEF::TABDEF(void)
   {
   Schema = NULL;
   Desc = NULL;
+	Recfm = RECFM_DFLT;
   Catfunc = FNC_NO;
   Card = 0;
   Elemt = 0;
@@ -221,11 +318,38 @@ TABDEF::TABDEF(void)
   } // end of TABDEF constructor
 
 /***********************************************************************/
+/*  Return the table format.                                           */
+/***********************************************************************/
+RECFM TABDEF::GetTableFormat(const char* type)
+{
+	RECFM recfm = Recfm;
+
+	if (Catfunc != FNC_NO)
+		recfm = RECFM_NAF;
+	else if (recfm == RECFM_DFLT)
+		// Default format depends on the table type
+		switch (GetTypeID(type)) {
+		case TAB_DOS: recfm = RECFM_VAR; break;
+		case TAB_CSV: recfm = RECFM_CSV; break;
+		case TAB_FMT: recfm = RECFM_FMT; break;
+		case TAB_FIX: recfm = RECFM_FIX; break;
+		case TAB_BIN: recfm = RECFM_BIN; break;
+		case TAB_VEC: recfm = RECFM_VCT; break;
+		case TAB_DBF: recfm = RECFM_DBF; break;
+		case TAB_XML: recfm = RECFM_XML; break;
+		case TAB_DIR: recfm = RECFM_DIR; break;
+		default:			recfm = RECFM_NAF; break;
+		} // endswitch type
+
+	return recfm;
+} // end of GetTableFormat
+
+/***********************************************************************/
 /*  Define: initialize the table definition block from XDB file.       */
 /***********************************************************************/
 bool TABDEF::Define(PGLOBAL g, PCATLG cat,
                     LPCSTR name, LPCSTR schema, LPCSTR am)
-  {
+{
   int   poff = 0;
 
   Hc = ((MYCAT*)cat)->GetHandler();
@@ -243,13 +367,17 @@ bool TABDEF::Define(PGLOBAL g, PCATLG cat,
                   NULL;
   csname = GetStringCatInfo(g, "Table_charset", NULL);
 
-  // Get The column definitions
-  if ((poff = GetColCatInfo(g)) < 0)
-    return true;
+	// Do the definition of AM specific fields
+	if (DefineAM(g, am, 0))
+		return true;
 
-  // Do the definition of AM specific fields
-  return DefineAM(g, am, poff);
-  } // end of Define
+	// Get The column definitions
+	if (stricmp(am, "OEM") && GetColCatInfo(g) < 0)
+		return true;
+
+	Hc->tshp = NULL;    // TO BE CHECKED
+	return false;
+} // end of Define
 
 /***********************************************************************/
 /*  This function returns the database data path.                      */
@@ -264,71 +392,71 @@ PCSZ TABDEF::GetPath(void)
 /***********************************************************************/
 int TABDEF::GetColCatInfo(PGLOBAL g)
   {
-  char    *type= GetStringCatInfo(g, "Type", "*");
+  char    *type = GetStringCatInfo(g, "Type", "*");
   char     c, fty, eds;
   int      i, n, loff, poff, nof, nlg;
-  void    *field= NULL;
-  TABTYPE  tc;
-  PCOLDEF  cdp, lcdp= NULL, tocols= NULL;
+  void    *field = NULL;
+  RECFM    trf;
+  PCOLDEF  cdp, lcdp = NULL, tocols= NULL;
   PCOLINFO pcf= (PCOLINFO)PlugSubAlloc(g, NULL, sizeof(COLINFO));
 
   memset(pcf, 0, sizeof(COLINFO));
 
-  // Get a unique char identifier for type
-  tc= (Catfunc == FNC_NO) ? GetTypeID(type) : TAB_PRX;
+  // Get the table format
+	trf = GetTableFormat(type);
 
   // Take care of the column definitions
   i= poff= nof= nlg= 0;
 
 #if defined(__WIN__)
   // Offsets of HTML and DIR tables start from 0, DBF at 1
-  loff= (tc == TAB_DBF) ? 1 : (tc == TAB_XML || tc == TAB_DIR) ? -1 : 0;
+  loff= (trf == RECFM_DBF) ? 1 : (trf  == RECFM_XML || trf  == RECFM_DIR) ? -1 : 0;
 #else   // !__WIN__
   // Offsets of HTML tables start from 0, DIR and DBF at 1
-  loff = (tc == TAB_DBF || tc == TAB_DIR) ? 1 : (tc == TAB_XML) ? -1 : 0;
+  loff = (trf  == RECFM_DBF || trf  == RECFM_DIR) ? 1 : (trf  == RECFM_XML) ? -1 : 0;
 #endif  // !__WIN__
 
   while (true) {
-    // Default Offset depends on table type
-    switch (tc) {
-      case TAB_DOS:
-      case TAB_FIX:
-      case TAB_BIN:
-      case TAB_VEC:
-      case TAB_DBF:
+    // Default Offset depends on table format
+    switch (trf ) {
+      case RECFM_VAR:
+      case RECFM_FIX:
+      case RECFM_BIN:
+      case RECFM_VCT:
+      case RECFM_DBF:
         poff= loff + nof;        // Default next offset
         nlg= MY_MAX(nlg, poff);    // Default lrecl
         break;
-      case TAB_CSV:
-      case TAB_FMT:
+      case RECFM_CSV:
+      case RECFM_FMT:
         nlg+= nof;
-      case TAB_DIR:
-      case TAB_XML:
+      case RECFM_DIR:
+      case RECFM_XML:
         poff= loff + (pcf->Flags & U_VIRTUAL ? 0 : 1);
         break;
-      case TAB_INI:
-      case TAB_MAC:
-      case TAB_TBL:
-      case TAB_XCL:
-      case TAB_OCCUR:
-      case TAB_PRX:
-      case TAB_OEM:
+      //case RECFM_INI:
+      //case RECFM_MAC:
+      //case RECFM_TBL:
+      //case RECFM_XCL:
+      //case RECFM_OCCUR:
+      //case RECFM_PRX:
+      case RECFM_OEM:
         poff = 0;      // Offset represents an independant flag
         break;
-      default:         // VCT PLG ODBC JDBC MYSQL WMI...
+      default:         // PLG ODBC JDBC MYSQL WMI...
         poff = 0;      // NA
         break;
-      } // endswitch tc
+      } // endswitch trf 
 
 //    do {
       field= Hc->GetColumnOption(g, field, pcf);
 //    } while (field && (*pcf->Name =='*' /*|| pcf->Flags & U_VIRTUAL*/));
 
-    if (tc == TAB_DBF && pcf->Type == TYPE_DATE && !pcf->Datefmt) {
+    if (trf  == RECFM_DBF && pcf->Type == TYPE_DATE && !pcf->Datefmt) {
       // DBF date format defaults to 'YYYMMDD'
       pcf->Datefmt= "YYYYMMDD";
       pcf->Length= 8;
-      } // endif tc
+      } // endif trf 
 
     if (!field)
       break;
@@ -341,10 +469,10 @@ int TABDEF::GetColCatInfo(PGLOBAL g)
     else
       loff= cdp->GetOffset();
 
-    switch (tc) {
-      case TAB_VEC:
+    switch (trf ) {
+      case RECFM_VCT:
         cdp->SetOffset(0);     // Not to have shift
-      case TAB_BIN:
+      case RECFM_BIN:
         // BIN/VEC are packed by default
         if (nof) {
           // Field width is the internal representation width
@@ -395,7 +523,7 @@ int TABDEF::GetColCatInfo(PGLOBAL g)
 
       default:
         break;
-      } // endswitch tc
+      } // endswitch trf 
 
     if (lcdp)
       lcdp->SetNext(cdp);
@@ -413,21 +541,15 @@ int TABDEF::GetColCatInfo(PGLOBAL g)
   if (GetDefType() == TYPE_AM_DOS) {
     int     ending, recln= 0;
 
-    // Was commented because sometimes ending is 0 even when
-    // not specified (for instance if quoted is specified)
-//  if ((ending= Hc->GetIntegerOption("Ending")) < 0) {
-    if ((ending= Hc->GetIntegerOption("Ending")) <= 0) {
-      ending= (tc == TAB_BIN || tc == TAB_VEC) ? 0 : CRLF;
-      Hc->SetIntegerOption("Ending", ending);
-      } // endif ending
+		ending = Hc->GetIntegerOption("Ending");
 
     // Calculate the default record size
-    switch (tc) {
-      case TAB_FIX:
-      case TAB_BIN:
+    switch (trf ) {
+      case RECFM_FIX:
+      case RECFM_BIN:
         recln= nlg + ending;     // + length of line ending
         break;
-      case TAB_VEC:
+      case RECFM_VCT:
         recln= nlg;
 
 //      if ((k= (pak < 0) ? 8 : pak) > 1)
@@ -436,18 +558,18 @@ int TABDEF::GetColCatInfo(PGLOBAL g)
 //        recln= ((recln + k - 1) / k) * k;
 
         break;
-      case TAB_DOS:
-      case TAB_DBF:
+      case RECFM_VAR:
+      case RECFM_DBF:
         recln= nlg;
         break;
-      case TAB_CSV:
-      case TAB_FMT:
+      case RECFM_CSV:
+      case RECFM_FMT:
         // The number of separators (assuming an extra one can exist)
 //      recln= poff * ((qotd) ? 3 : 1);  to be investigated
         recln= nlg + poff * 3;     // To be safe
       default:
         break;
-      } // endswitch tc
+      } // endswitch trf 
 
     // lrecl must be at least recln to avoid buffer overflow
     if (trace(1))
@@ -461,7 +583,7 @@ int TABDEF::GetColCatInfo(PGLOBAL g)
     if (trace(1))
       htrc("Lrecl set to %d\n", recln);
 
-    } // endif Lrecl
+    } // endif TYPE
 
   // Attach the column definition to the tabdef
   SetCols(tocols);
@@ -500,7 +622,8 @@ PTABDEF OEMDEF::GetXdef(PGLOBAL g)
     return NULL;
   } else
 //  PlugSetPath(soname, Module, GetPluginDir());  // Crashes on Fedora
-    strncat(strcpy(soname, GetPluginDir()), Module, _MAX_PATH);
+    strncat(strcpy(soname, GetPluginDir()), Module,
+			sizeof(soname) - strlen(soname) - 1);
 
 #if defined(__WIN__)
   // Is the DLL already loaded?
@@ -596,10 +719,6 @@ PTABDEF OEMDEF::GetXdef(PGLOBAL g)
     cat->Cbuf = (char*)PlugSubAlloc(g, NULL, cat->Cblen);
     } // endif Cbuf
 
-  // Here "OEM" should be replace by a more useful value
-  if (xdefp->Define(g, cat, Name, Schema, "OEM"))
-    return NULL;
-
   // Ok, return external block
   return xdefp;
   } // end of GetXdef
@@ -622,7 +741,7 @@ bool OEMDEF::DeleteTableFile(PGLOBAL g)
 /***********************************************************************/
 bool OEMDEF::DefineAM(PGLOBAL g, LPCSTR, int)
   {
-  Module = GetStringCatInfo(g, "Module", "");
+	Module = GetStringCatInfo(g, "Module", "");
   Subtype = GetStringCatInfo(g, "Subtype", Module);
 
   if (!*Module)
@@ -632,7 +751,13 @@ bool OEMDEF::DefineAM(PGLOBAL g, LPCSTR, int)
                                           + strlen(Subtype) + 3);
   sprintf(desc, "%s(%s)", Module, Subtype);
   Desc = desc;
-  return false;
+
+	// If define block not here yet, get it now
+	if (!Pxdef && !(Pxdef = GetXdef(g)))
+		return true;            // Error
+
+	// Here "OEM" should be replace by a more useful value
+  return Pxdef->Define(g, Cat, Name, Schema, Subtype);
   } // end of DefineAM
 
 /***********************************************************************/
@@ -640,7 +765,6 @@ bool OEMDEF::DefineAM(PGLOBAL g, LPCSTR, int)
 /***********************************************************************/
 PTDB OEMDEF::GetTable(PGLOBAL g, MODE mode)
   {
-  RECFM rfm;
   PTDB  tdbp = NULL;
 
   // If define block not here yet, get it now
@@ -653,18 +777,10 @@ PTDB OEMDEF::GetTable(PGLOBAL g, MODE mode)
   /*********************************************************************/
   if (!(tdbp = Pxdef->GetTable(g, mode)))
     return NULL;
-  else
-    rfm = tdbp->GetFtype();
-
-  if (rfm == RECFM_NAF)
-    return tdbp;
-  else if (rfm == RECFM_OEM) {
-    if (Multiple)
-      tdbp = new(g) TDBMUL(tdbp);       // No block optimization yet
-
-    return tdbp;
-    } // endif OEM
+  else if (Multiple && tdbp->GetFtype() == RECFM_OEM)
+    tdbp = new(g) TDBMUL(tdbp);       // No block optimization yet
 
+#if 0
   /*********************************************************************/
   /*  The OEM table is based on a file type (currently DOS+ only)      */
   /*********************************************************************/
@@ -723,7 +839,7 @@ PTDB OEMDEF::GetTable(PGLOBAL g, MODE mode)
 
   if (Multiple)
     tdbp = new(g) TDBMUL(tdbp);
-
+#endif // 0
   return tdbp;
   } // end of GetTable
 
diff --git a/storage/connect/reldef.h b/storage/connect/reldef.h
index f8256a59b3d..73e178ed51c 100644
--- a/storage/connect/reldef.h
+++ b/storage/connect/reldef.h
@@ -84,10 +84,12 @@ public:
   void    SetNext(PTABDEF tdfp) {Next = tdfp;}
   int     GetMultiple(void) {return Multiple;}
   int     GetPseudo(void) {return Pseudo;}
-  PCSZ    GetPath(void);
+	RECFM   GetRecfm(void) {return Recfm;}
+	PCSZ    GetPath(void);
 //PSZ     GetPath(void)
 //          {return (Database) ? (PSZ)Database : Cat->GetDataPath();}
-  bool    SepIndex(void) {return GetBoolCatInfo("SepIndex", false);}
+	RECFM   GetTableFormat(const char* type);
+	bool    SepIndex(void) {return GetBoolCatInfo("SepIndex", false);}
   bool    IsReadOnly(void) {return Read_Only;}
   virtual AMT    GetDefType(void) {return TYPE_AM_TAB;}
   virtual PIXDEF GetIndx(void) {return NULL;}
@@ -108,7 +110,8 @@ public:
   // Members
   PCSZ    Schema;               /* Table schema (for ODBC)             */
   PCSZ    Desc;                 /* Table description                   */
-  uint    Catfunc;              /* Catalog function ID                 */
+	RECFM   Recfm;                /* File or table format                */
+	uint    Catfunc;              /* Catalog function ID                 */
   int     Card;                 /* (max) number of rows in table       */
   int     Elemt;                /* Number of rows in blocks or rowset  */
   int     Sort;                 /* Table already sorted ???            */
diff --git a/storage/connect/restget.cpp b/storage/connect/restget.cpp
index 6b184ae6926..29dae230780 100644
--- a/storage/connect/restget.cpp
+++ b/storage/connect/restget.cpp
@@ -4,12 +4,6 @@
 /***********************************************************************/
 #include <cpprest/filestream.h>
 #include <cpprest/http_client.h>
-#if defined(MARIADB)
-#include <my_global.h>
-#else
-#include "mini-global.h"
-#define _OS_H_INCLUDED     // Prevent os.h to be called
-#endif
 
 using namespace utility::conversions; // String conversions utilities
 using namespace web;                  // Common features like URIs.
@@ -17,24 +11,26 @@ using namespace web::http;            // Common HTTP functionality
 using namespace web::http::client;    // HTTP client features
 using namespace concurrency::streams; // Asynchronous streams
 
-#include "global.h"
+typedef const char* PCSZ;
+
+extern "C" int restGetFile(char* m, bool xt, PCSZ http, PCSZ uri, PCSZ fn);
 
 /***********************************************************************/
 /*  Make a local copy of the requested file.                           */
 /***********************************************************************/
-int restGetFile(PGLOBAL g, PCSZ http, PCSZ uri, PCSZ fn)
+int restGetFile(char *m, bool xt, PCSZ http, PCSZ uri, PCSZ fn)
 {
   int  rc = 0;
-	bool xt = trace(515);
   auto fileStream = std::make_shared<ostream>();
 
   if (!http || !fn) {
-    strcpy(g->Message, "Missing http or filename");
-    return 2;
+    //strcpy(g->Message, "Missing http or filename");
+		strcpy(m, "Missing http or filename");
+		return 2;
   } // endif
 
 	if (xt)
-	  htrc("restGetFile: fn=%s\n", fn);
+		fprintf(stderr, "restGetFile: fn=%s\n", fn);
 
   // Open stream to output file.
   pplx::task<void> requestTask = fstream::open_ostream(to_string_t(fn))
@@ -42,7 +38,7 @@ int restGetFile(PGLOBAL g, PCSZ http, PCSZ uri, PCSZ fn)
       *fileStream= outFile;
 
 			if (xt)
-				htrc("Outfile isopen=%d\n", outFile.is_open());
+				fprintf(stderr, "Outfile isopen=%d\n", outFile.is_open());
 
       // Create http_client to send the request.
       http_client client(to_string_t(http));
@@ -58,8 +54,8 @@ int restGetFile(PGLOBAL g, PCSZ http, PCSZ uri, PCSZ fn)
     // Handle response headers arriving.
     .then([=](http_response response) {
 			if (xt)
-				htrc("Received response status code:%u\n",
-                       response.status_code());
+				fprintf(stderr, "Received response status code:%u\n",
+                                  response.status_code());
 
       // Write response body into the file.
       return response.body().read_to_end(fileStream->streambuf());
@@ -68,27 +64,27 @@ int restGetFile(PGLOBAL g, PCSZ http, PCSZ uri, PCSZ fn)
     // Close the file stream.
     .then([=](size_t n) {
 			if (xt)
-			  htrc("Return size=%u\n", n);
+				fprintf(stderr, "Return size=%zu\n", n);
 
       return fileStream->close();
     });
 
   // Wait for all the outstanding I/O to complete and handle any exceptions
   try {
-    requestTask.wait();
-
 		if (xt)
-      htrc("In Wait\n");
+			fprintf(stderr, "Waiting\n");
 
+		requestTask.wait();
   } catch (const std::exception &e) {
 		if (xt)
-		  htrc("Error exception: %s\n", e.what());
-    sprintf(g->Message, "Error exception: %s", e.what());
-    rc= 1;
+			fprintf(stderr, "Error exception: %s\n", e.what());
+
+		sprintf(m, "Error exception: %s", e.what());
+		rc= 1;
   } // end try/catch
 
 	if (xt)
-	  htrc("restget done: rc=%d\n", rc);
+		fprintf(stderr, "restget done: rc=%d\n", rc);
 
   return rc;
 } // end of restGetFile
diff --git a/storage/connect/tabcmg.cpp b/storage/connect/tabcmg.cpp
index da1cfd34ac7..b9b7f6e4b60 100644
--- a/storage/connect/tabcmg.cpp
+++ b/storage/connect/tabcmg.cpp
@@ -53,25 +53,30 @@ bool CMGDISC::FindInDoc(PGLOBAL g, bson_iter_t *iter, const bson_t *doc,
 {
 	if (!doc || bson_iter_init(iter, doc)) {
 		const char *key;
-		char  colname[65];
-		char 	fmt[129];
-		bool  newcol;
+		char   colname[65];
+		char 	 fmt[129];
+		bool   newcol;
+		size_t n;
 
 		while (bson_iter_next(iter)) {
 			key = bson_iter_key(iter);
 			newcol = true;
 
 			if (pcn) {
-				strncpy(colname, pcn, 64);
-				colname[64] = 0;
-				strncat(strncat(colname, "_", 65), key, 65);
+				n = sizeof(colname) - 1;
+				strncpy(colname, pcn, n);
+				colname[n] = 0;
+				n -= strlen(colname);
+				strncat(strncat(colname, "_", n), key, n - 1);
 			}	else
 				strcpy(colname, key);
 
 			if (pfmt) {
-				strncpy(fmt, pfmt, 128);
-				fmt[128] = 0;
-				strncat(strncat(fmt, ".", 129), key, 129);
+				n = sizeof(fmt) - 1;
+				strncpy(fmt, pfmt, n);
+				fmt[n] = 0;
+				n -= strlen(fmt);
+				strncat(strncat(fmt, ".", n), key, n - 1);
 			} else
 				strcpy(fmt, key);
 
diff --git a/storage/connect/tabdos.cpp b/storage/connect/tabdos.cpp
index 4f6e2c81744..8efe2aad702 100644
--- a/storage/connect/tabdos.cpp
+++ b/storage/connect/tabdos.cpp
@@ -45,7 +45,7 @@
 #include "global.h"
 #include "osutil.h"
 #include "plgdbsem.h"
-#include "catalog.h"
+//#include "catalog.h"
 #include "mycat.h"
 #include "xindex.h"
 #include "filamap.h"
@@ -161,7 +161,12 @@ bool DOSDEF::DefineAM(PGLOBAL g, LPCSTR am, int)
 //Last = GetIntCatInfo("Last", 0);
   Ending = GetIntCatInfo("Ending", CRLF);
 
-  if (Recfm == RECFM_FIX || Recfm == RECFM_BIN) {
+	if (Ending <= 0) {
+		Ending = (Recfm == RECFM_BIN || Recfm == RECFM_VCT) ? 0 : CRLF;
+		SetIntCatInfo("Ending", Ending);
+	} // endif ending
+
+	if (Recfm == RECFM_FIX || Recfm == RECFM_BIN) {
     Huge = GetBoolCatInfo("Huge", Cat->GetDefHuge());
     Padded = GetBoolCatInfo("Padded", false);
     Blksize = GetIntCatInfo("Blksize", 0);
@@ -191,7 +196,8 @@ bool DOSDEF::GetOptFileName(PGLOBAL g, char *filename)
     case RECFM_FIX: ftype = ".fop"; break;
     case RECFM_BIN: ftype = ".bop"; break;
     case RECFM_VCT: ftype = ".vop"; break;
-    case RECFM_DBF: ftype = ".dbp"; break;
+		case RECFM_CSV: ftype = ".cop"; break;
+		case RECFM_DBF: ftype = ".dbp"; break;
     default:
       sprintf(g->Message, MSG(INVALID_FTYPE), Recfm);
       return true;
@@ -261,7 +267,8 @@ bool DOSDEF::DeleteIndexFile(PGLOBAL g, PIXDEF pxdf)
     case RECFM_FIX: ftype = ".fnx"; break;
     case RECFM_BIN: ftype = ".bnx"; break;
     case RECFM_VCT: ftype = ".vnx"; break;
-    case RECFM_DBF: ftype = ".dbx"; break;
+		case RECFM_CSV: ftype = ".cnx"; break;
+		case RECFM_DBF: ftype = ".dbx"; break;
     default:
       sprintf(g->Message, MSG(BAD_RECFM_VAL), Recfm);
       return true;
@@ -2257,7 +2264,7 @@ int TDBDOS::ReadDB(PGLOBAL g)
 /***********************************************************************/
 bool TDBDOS::PrepareWriting(PGLOBAL)
   {
-  if (!Ftype && (Mode == MODE_INSERT || Txfp->GetUseTemp())) {
+  if (Ftype == RECFM_VAR && (Mode == MODE_INSERT || Txfp->GetUseTemp())) {
     char *p;
 
     /*******************************************************************/
@@ -2542,7 +2549,8 @@ void DOSCOL::ReadColumn(PGLOBAL g)
   /*********************************************************************/
   /*  For a variable length file, check if the field exists.           */
   /*********************************************************************/
-  if (tdbp->Ftype == RECFM_VAR && strlen(tdbp->To_Line) < (unsigned)Deplac)
+  if ((tdbp->Ftype == RECFM_VAR || tdbp->Ftype == RECFM_CSV)
+				&& strlen(tdbp->To_Line) < (unsigned)Deplac)
     field = 0;
   else if (Dsp)
     for(i = 0; i < field; i++)
@@ -2552,7 +2560,8 @@ void DOSCOL::ReadColumn(PGLOBAL g)
   switch (tdbp->Ftype) {
     case RECFM_VAR:
     case RECFM_FIX:            // Fixed length text file
-    case RECFM_DBF:            // Fixed length DBase file
+		case RECFM_CSV:            // Variable length CSV or FMT file
+		case RECFM_DBF:            // Fixed length DBase file
       if (Nod) switch (Buf_Type) {
         case TYPE_INT:
         case TYPE_SHORT:
diff --git a/storage/connect/tabdos.h b/storage/connect/tabdos.h
index bdde37adaad..207a1277fce 100644
--- a/storage/connect/tabdos.h
+++ b/storage/connect/tabdos.h
@@ -80,7 +80,6 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
 	PCSZ    Entry;						  /* Zip entry name or pattern						 */
 	PCSZ    Pwd;						    /* Zip password             						 */
 	PIXDEF  To_Indx;            /* To index definitions blocks           */
-  RECFM   Recfm;              /* 0:VAR, 1:FIX, 2:BIN, 3:VCT, 6:DBF     */
   bool    Mapped;             /* 0: disk file, 1: memory mapped file   */
 	bool    Zipped;             /* true for zipped table file            */
 	bool    Mulentries;         /* true for multiple entries             */
diff --git a/storage/connect/tabfix.cpp b/storage/connect/tabfix.cpp
index 1969fd4465f..4a0a75460cd 100644
--- a/storage/connect/tabfix.cpp
+++ b/storage/connect/tabfix.cpp
@@ -84,7 +84,7 @@ PTDB TDBFIX::Clone(PTABS t)
 
   tp = new(g) TDBFIX(g, this);
 
-  if (Ftype < 2) {
+  if (Ftype == RECFM_VAR || Ftype == RECFM_FIX) {
     // File is text
     PDOSCOL cp1, cp2;
 
diff --git a/storage/connect/tabfmt.cpp b/storage/connect/tabfmt.cpp
index 746382178fb..b395c49c95d 100644
--- a/storage/connect/tabfmt.cpp
+++ b/storage/connect/tabfmt.cpp
@@ -1,11 +1,11 @@
 /************* TabFmt C++ Program Source Code File (.CPP) **************/
 /* PROGRAM NAME: TABFMT                                                */
 /* -------------                                                       */
-/*  Version 3.9.2                                                      */
+/*  Version 3.9.3                                                      */
 /*                                                                     */
 /* COPYRIGHT:                                                          */
 /* ----------                                                          */
-/*  (C) Copyright to the author Olivier BERTRAND          2001 - 2017  */
+/*  (C) Copyright to the author Olivier BERTRAND          2001 - 2019  */
 /*                                                                     */
 /* WHAT THIS PROGRAM DOES:                                             */
 /* -----------------------                                             */
@@ -477,6 +477,7 @@ bool CSVDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
   if (DOSDEF::DefineAM(g, "CSV", poff))
     return true;
 
+	Recfm = RECFM_CSV;
   GetCharCatInfo("Separator", ",", buf, sizeof(buf));
   Sep = (strlen(buf) == 2 && buf[0] == '\\' && buf[1] == 't') ? '\t' : *buf;
   Quoted = GetIntCatInfo("Quoted", -1);
diff --git a/storage/connect/tabjson.cpp b/storage/connect/tabjson.cpp
index 0b282345c8a..7e8d6c8d9f0 100644
--- a/storage/connect/tabjson.cpp
+++ b/storage/connect/tabjson.cpp
@@ -394,10 +394,11 @@ err:
 
 bool JSONDISC::Find(PGLOBAL g, PJVAL jvp, PCSZ key, int j)
 {
-  char *p, *pc = colname + strlen(colname);
-  int   ars;
-  PJOB  job;
-  PJAR  jar;
+  char  *p, *pc = colname + strlen(colname);
+  int    ars;
+	size_t n;
+  PJOB   job;
+  PJAR   jar;
 
   if ((valp = jvp ? jvp->GetValue() : NULL)) {
     jcol.Type = valp->GetType();
@@ -423,8 +424,10 @@ bool JSONDISC::Find(PGLOBAL g, PJVAL jvp, PCSZ key, int j)
           PCSZ k = jrp->GetKey();
 
           if (*k != '$') {
-            strncat(strncat(fmt, sep, 128), k, 128);
-            strncat(strncat(colname, "_", 64), k, 64);
+						n = sizeof(fmt) - strlen(fmt) -1;
+						strncat(strncat(fmt, sep, n), k, n - strlen(sep));
+						n = sizeof(colname) - strlen(colname) - 1;
+						strncat(strncat(colname, "_", n), k, n - 1);
           } // endif Key
 
           if (Find(g, jrp->GetVal(), k, j + 1))
@@ -443,19 +446,26 @@ bool JSONDISC::Find(PGLOBAL g, PJVAL jvp, PCSZ key, int j)
           ars = MY_MIN(jar->GetSize(false), 1);
 
         for (int k = 0; k < ars; k++) {
-          if (!tdp->Xcol || stricmp(tdp->Xcol, key)) {
-            sprintf(buf, "%d", k);
-
-            if (tdp->Uri)
-              strncat(strncat(fmt, sep, 128), buf, 128);
-            else
-              strncat(strncat(strncat(fmt, "[", 128), buf, 128), "]", 128);
+					n = sizeof(fmt) - (strlen(fmt) + 1);
 
-            if (all)
-              strncat(strncat(colname, "_", 64), buf, 64);
+					if (!tdp->Xcol || stricmp(tdp->Xcol, key)) {
+            sprintf(buf, "%d", k);
 
-          } else
-            strncat(fmt, (tdp->Uri ? sep : "[*]"), 128);
+						if (tdp->Uri) {
+							strncat(strncat(fmt, sep, n), buf, n - strlen(sep));
+						} else {
+							strncat(strncat(fmt, "[", n), buf, n - 1);
+							strncat(fmt, "]", n - (strlen(buf) + 1));
+						} // endif uri
+
+						if (all) {
+							n = sizeof(colname) - (strlen(colname) + 1);
+							strncat(strncat(colname, "_", n), buf, n - 1);
+						} // endif all
+
+					} else {
+						strncat(fmt, (tdp->Uri ? sep : "[*]"), n);
+					}
 
           if (Find(g, jar->GetValue(k), "", j))
             return true;
diff --git a/storage/connect/tabmysql.cpp b/storage/connect/tabmysql.cpp
index ceffafac02c..7e165fb5a80 100644
--- a/storage/connect/tabmysql.cpp
+++ b/storage/connect/tabmysql.cpp
@@ -342,11 +342,13 @@ bool MYSQLDEF::DefineAM(PGLOBAL g, LPCSTR am, int)
     Delayed = !!GetIntCatInfo("Delayed", 0);
   } else {
     // MYSQL access from a PROXY table 
-    Tabschema = GetStringCatInfo(g, "Database", Tabschema ? Tabschema : PlugDup(g, "*"));
+		TABLE_SHARE* s;
+
+		Tabschema = GetStringCatInfo(g, "Database", Tabschema ? Tabschema : PlugDup(g, "*"));
     Isview = GetBoolCatInfo("View", false);
 
     // We must get other connection parms from the calling table
-    Remove_tshp(Cat);
+    s = Remove_tshp(Cat);
     url = GetStringCatInfo(g, "Connect", NULL);
 
     if (!url || !*url) { 
@@ -365,6 +367,9 @@ bool MYSQLDEF::DefineAM(PGLOBAL g, LPCSTR am, int)
     } // endif url
 
     Tabname = Name;
+
+		// Needed for column description
+		Restore_tshp(Cat, s);
   } // endif am
 
   if ((Srcdef = GetStringCatInfo(g, "Srcdef", NULL))) {
diff --git a/storage/connect/tabrest.cpp b/storage/connect/tabrest.cpp
index 9e1a643c89f..9c6b724973f 100644
--- a/storage/connect/tabrest.cpp
+++ b/storage/connect/tabrest.cpp
@@ -1,5 +1,5 @@
-/*************** Rest C++ Program Source Code File (.CPP) **************/
-/* PROGRAM NAME: Rest   Version 1.5                                    */
+/************** tabrest C++ Program Source Code File (.CPP) ************/
+/* PROGRAM NAME: tabrest   Version 1.7                                 */
 /*  (C) Copyright to the author Olivier BERTRAND          2018 - 2019  */
 /*  This program is the REST Web API support for MariaDB.              */
 /*  When compiled without MARIADB defined, it is the EOM module code.  */
@@ -9,13 +9,18 @@
 /*  Definitions needed by the included files.                          */
 /***********************************************************************/
 #if defined(MARIADB)
-#include <my_global.h> // All MariaDB stuff
+#include <my_global.h>    // All MariaDB stuff
 #else   // !MARIADB       OEM module
 #include "mini-global.h"
 #define _MAX_PATH 260
-#if !defined(__WIN__)
+#if !defined(REST_SOURCE)
+#if defined(__WIN__) || defined(_WINDOWS)
+#include <windows.h>
+#else		 // !__WIN__
 #define __stdcall
+#include <dlfcn.h>         // dlopen(), dlclose(), dlsym() ...
 #endif   // !__WIN__
+#endif	 // !REST_SOURCE
 #define _OS_H_INCLUDED     // Prevent os.h to be called
 #endif  // !MARIADB
 
@@ -23,7 +28,6 @@
 /*  Include application header files:                                  */
 /*  global.h    is header containing all global declarations.          */
 /*  plgdbsem.h  is header containing the DB application declarations.  */
-/*  (x)table.h  is header containing the TDBASE declarations.          */
 /***********************************************************************/
 #include "global.h"
 #include "plgdbsem.h"
@@ -31,22 +35,14 @@
 #include "filamtxt.h"
 #include "tabdos.h"
 #include "plgxml.h"
+#if defined(XML_SUPPORT)
 #include "tabxml.h"
+#endif   // XML_SUPPORT
 #include "tabjson.h"
 #include "tabfmt.h"
 #include "tabrest.h"
 
-/***********************************************************************/
-/*  Get the file from the Web.                                         */
-/***********************************************************************/
-int restGetFile(PGLOBAL g, PCSZ http, PCSZ uri, PCSZ fn);
-
-#if defined(__WIN__)
-static PCSZ slash = "\\";
-#else // !__WIN__
-static PCSZ slash = "/";
-#define stricmp strcasecmp
-#endif // !__WIN__
+static XGETREST getRestFnc = NULL;
 
 #if !defined(MARIADB)
 /***********************************************************************/
@@ -76,6 +72,74 @@ PTABDEF __stdcall GetREST(PGLOBAL g, void *memp)
 #endif   // !MARIADB
 
 /***********************************************************************/
+/*  GetREST: get the external TABDEF from OEM module.                  */
+/***********************************************************************/
+XGETREST GetRestFunction(PGLOBAL g)
+{
+	if (getRestFnc)
+		return getRestFnc;
+	
+#if !defined(MARIADB) || !defined(REST_SOURCE)
+	if (trace(515))
+		htrc("Looking for GetRest library\n");
+
+#if defined(__WIN__) || defined(_WINDOWS)
+	HANDLE Hdll;
+	const char* soname = "GetRest.dll";   // Module name
+
+	if (!(Hdll = LoadLibrary(soname))) {
+		char  buf[256];
+		DWORD rc = GetLastError();
+
+		sprintf(g->Message, MSG(DLL_LOAD_ERROR), rc, soname);
+		FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+			FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0,
+			(LPTSTR)buf, sizeof(buf), NULL);
+		strcat(strcat(g->Message, ": "), buf);
+		return NULL;
+	} // endif Hdll
+
+// Get the function returning an instance of the external DEF class
+	if (!(getRestFnc = (XGETREST)GetProcAddress((HINSTANCE)Hdll, "restGetFile"))) {
+		char  buf[256];
+		DWORD rc = GetLastError();
+
+		sprintf(g->Message, MSG(PROCADD_ERROR), rc, "restGetFile");
+		FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+			FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0,
+			(LPTSTR)buf, sizeof(buf), NULL);
+		strcat(strcat(g->Message, ": "), buf);
+		FreeLibrary((HMODULE)Hdll);
+		return NULL;
+	} // endif getRestFnc
+#else   // !__WIN__
+	void* Hso;
+	const char* error = NULL;
+	const char* soname = "GetRest.so";   // Module name
+
+	// Load the desired shared library
+	if (!(Hso = dlopen(soname, RTLD_LAZY))) {
+		error = dlerror();
+		sprintf(g->Message, MSG(SHARED_LIB_ERR), soname, SVP(error));
+		return NULL;
+	} // endif Hdll
+
+// Get the function returning an instance of the external DEF class
+	if (!(getRestFnc = (XGETREST)dlsym(Hso, "restGetFile"))) {
+		error = dlerror();
+		sprintf(g->Message, MSG(GET_FUNC_ERR), "restGetFile", SVP(error));
+		dlclose(Hso);
+		return NULL;
+	} // endif getdef
+#endif  // !__WIN__
+#else
+	getRestFnc = restGetFile;
+#endif
+
+	return getRestFnc;
+} // end of GetRestFunction
+
+/***********************************************************************/
 /*  Return the columns definition to MariaDB.                          */
 /***********************************************************************/
 #if defined(MARIADB)
@@ -87,6 +151,10 @@ PQRYRES __stdcall ColREST(PGLOBAL g, PTOS tp, char *tab, char *db, bool info)
   PQRYRES qrp= NULL;
   char filename[_MAX_PATH + 1];  // MAX PATH ???
   PCSZ http, uri, fn, ftype;
+	XGETREST grf = GetRestFunction(g);
+
+	if (!grf)
+		return NULL;
 
   http = GetStringTableOption(g, tp, "Http", NULL);
   uri = GetStringTableOption(g, tp, "Uri", NULL);
@@ -100,18 +168,20 @@ PQRYRES __stdcall ColREST(PGLOBAL g, PTOS tp, char *tab, char *db, bool info)
 
   //  We used the file name relative to recorded datapath
   strcat(strcat(strcat(strcpy(filename, "."), slash), db), slash);
-  strncat(filename, fn, _MAX_PATH);
+  strncat(filename, fn, _MAX_PATH - strlen(filename));
 
   // Retrieve the file from the web and copy it locally
-  if (http && restGetFile(g, http, uri, filename)) {
-    // sprintf(g->Message, "Failed to get file at %s", http);
-  } else if (!stricmp(ftype, "XML"))
-    qrp = XMLColumns(g, db, tab, tp, info);
-  else if (!stricmp(ftype, "JSON"))
+	if (http && grf(g->Message, trace(515), http, uri, filename)) {
+			// sprintf(g->Message, "Failed to get file at %s", http);
+  } else if (!stricmp(ftype, "JSON"))
     qrp = JSONColumns(g, db, NULL, tp, info);
   else if (!stricmp(ftype, "CSV"))
     qrp = CSVColumns(g, NULL, tp, info);
-  else
+#if defined(XML_SUPPORT)
+	else if (!stricmp(ftype, "XML"))
+		qrp = XMLColumns(g, db, tab, tp, info);
+#endif   // XML_SUPPORT
+	else
     sprintf(g->Message, "Usupported file type %s", ftype);
 
   return qrp;
@@ -124,9 +194,14 @@ PQRYRES __stdcall ColREST(PGLOBAL g, PTOS tp, char *tab, char *db, bool info)
 /***********************************************************************/
 bool RESTDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
 {
-  char    filename[_MAX_PATH + 1];
+	char    filename[_MAX_PATH + 1];
   int     rc = 0, n;
-  LPCSTR  ftype;
+	bool    xt = trace(515);
+	LPCSTR  ftype;
+	XGETREST grf = GetRestFunction(g);
+
+	if (!grf)
+		return true;
 
 #if defined(MARIADB)
   ftype = GetStringCatInfo(g, "Type", "JSON");
@@ -135,11 +210,13 @@ bool RESTDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
   ftype = GetStringCatInfo(g, "Ftype", "JSON");
 #endif  // !MARIADB
 
-  if (trace(515))
+  if (xt)
     htrc("ftype = %s am = %s\n", ftype, SVP(am));
 
   n = (!stricmp(ftype, "JSON")) ? 1
+#if defined(XML_SUPPORT)
     : (!stricmp(ftype, "XML"))  ? 2
+#endif   // XML_SUPPORT
     : (!stricmp(ftype, "CSV"))  ? 3 : 0;
 
   if (n == 0) {
@@ -154,19 +231,22 @@ bool RESTDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
 
   //  We used the file name relative to recorded datapath
   //PlugSetPath(filename, Fn, GetPath());
-  strncat(strcpy(filename, GetPath()), Fn, _MAX_PATH);
+  strcpy(filename, GetPath());
+	strncat(filename, Fn, _MAX_PATH - strlen(filename));
 
   // Retrieve the file from the web and copy it locally
-  rc = restGetFile(g, Http, Uri, filename);
+	rc = grf(g->Message, xt, Http, Uri, filename);
 
-  if (trace(515))
+  if (xt)
     htrc("Return from restGetFile: rc=%d\n", rc);
 
   if (rc)
     return true;
   else switch (n) {
     case 1: Tdp = new (g) JSONDEF; break;
-    case 2: Tdp = new (g) XMLDEF;  break;
+#if defined(XML_SUPPORT)
+		case 2: Tdp = new (g) XMLDEF;  break;
+#endif   // XML_SUPPORT
     case 3: Tdp = new (g) CSVDEF;  break;
     default: Tdp = NULL;
   } // endswitch n
@@ -175,7 +255,7 @@ bool RESTDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
   if (Tdp && Tdp->Define(g, Cat, Name, Schema, "REST"))
     Tdp = NULL; // Error occured
 
-  if (trace(515))
+  if (xt)
     htrc("Tdp defined\n", rc);
 
   // Return true in case of error
diff --git a/storage/connect/tabrest.h b/storage/connect/tabrest.h
index 1725f256079..9cf2d10a6b8 100644
--- a/storage/connect/tabrest.h
+++ b/storage/connect/tabrest.h
@@ -5,6 +5,27 @@
 /***********************************************************************/
 #pragma once
 
+#if defined(__WIN__)
+static PCSZ slash = "\\";
+#else // !__WIN__
+static PCSZ slash = "/";
+#define stricmp strcasecmp
+#endif // !__WIN__
+
+typedef int(__stdcall* XGETREST) (char*, bool, PCSZ, PCSZ, PCSZ);
+
+/***********************************************************************/
+/*  Functions used by REST.                                            */
+/***********************************************************************/
+XGETREST GetRestFunction(PGLOBAL g);
+#if defined(REST_SOURCE)
+extern "C" int restGetFile(char* m, bool xt, PCSZ http, PCSZ uri, PCSZ fn);
+#endif   // REST_SOURCE
+#if defined(MARIADB)
+PQRYRES RESTColumns(PGLOBAL g, PTOS tp, char* tab, char* db, bool info);
+#endif  // !MARIADB
+
+
 /***********************************************************************/
 /*  Restest table.                                                     */
 /***********************************************************************/
diff --git a/storage/connect/tabutil.cpp b/storage/connect/tabutil.cpp
index 325f36b1e19..f5a105a530d 100644
--- a/storage/connect/tabutil.cpp
+++ b/storage/connect/tabutil.cpp
@@ -59,12 +59,24 @@ int GetConvSize(void);
 /*  Used by MYSQL tables to get MySQL parameters from the calling proxy */
 /*  table (PROXY, TBL, XCL, or OCCUR) when used by one of these.        */
 /************************************************************************/
-void Remove_tshp(PCATLG cat)
+TABLE_SHARE *Remove_tshp(PCATLG cat)
 {
-  ((MYCAT*)cat)->GetHandler()->tshp = NULL;
+  TABLE_SHARE *s = ((MYCAT*)cat)->GetHandler()->tshp;
+
+	((MYCAT*)cat)->GetHandler()->tshp = NULL;
+	return s;
 } // end of Remove_thsp
 
 /************************************************************************/
+/*  Used by MYSQL tables to get MySQL parameters from the calling proxy */
+/*  table (PROXY, TBL, XCL, or OCCUR) when used by one of these.        */
+/************************************************************************/
+void Restore_tshp(PCATLG cat, TABLE_SHARE *s)
+{
+	((MYCAT*)cat)->GetHandler()->tshp = s;
+} // end of Restore_thsp
+
+/************************************************************************/
 /*  GetTableShare: allocates and open a table share.                    */
 /************************************************************************/
 TABLE_SHARE *GetTableShare(PGLOBAL g, THD *thd, const char *db, 
diff --git a/storage/connect/tabutil.h b/storage/connect/tabutil.h
index 62678508ca1..c8e7e75106f 100644
--- a/storage/connect/tabutil.h
+++ b/storage/connect/tabutil.h
@@ -18,7 +18,8 @@ TABLE_SHARE *GetTableShare(PGLOBAL g, THD *thd, const char *db,
 PQRYRES TabColumns(PGLOBAL g, THD *thd, const char *db, 
                                         const char *name, bool& info);
 
-void Remove_tshp(PCATLG cat);
+TABLE_SHARE *Remove_tshp(PCATLG cat);
+void Restore_tshp(PCATLG cat, TABLE_SHARE *s);
 
 /* -------------------------- PROXY classes -------------------------- */
 
diff --git a/storage/connect/tabvct.cpp b/storage/connect/tabvct.cpp
index 40d020202ea..0ed466f6ffb 100644
--- a/storage/connect/tabvct.cpp
+++ b/storage/connect/tabvct.cpp
@@ -115,11 +115,14 @@ bool VCTDEF::DefineAM(PGLOBAL g, LPCSTR, int poff)
 
   Recfm = RECFM_VCT;
 
+	// poff is no more in use; This will have to be revisited
+#if 0
   // For packed files the logical record length is calculated in poff
   if (poff != Lrecl) {
     Lrecl = poff;
     SetIntCatInfo("Lrecl", poff);
     } // endif poff
+#endif // 0
 
   Padded = false;
   Blksize = 0;
diff --git a/storage/connect/xindex.cpp b/storage/connect/xindex.cpp
index db4d6cbb00d..95f038d494c 100644
--- a/storage/connect/xindex.cpp
+++ b/storage/connect/xindex.cpp
@@ -659,7 +659,7 @@ bool XINDEX::Make(PGLOBAL g, PIXDEF sxp)
   /*  Not true for DBF tables because of eventual soft deleted lines.  */
   /*  Note: for Num_K = 1 any non null value is Ok.                    */
   /*********************************************************************/
-  if (Srtd && !filp && Tdbp->Ftype != RECFM_VAR 
+  if (Srtd && !filp && Tdbp->Ftype != RECFM_VAR && Tdbp->Ftype != RECFM_CSV
                     && Tdbp->Txfp->GetAmType() != TYPE_AM_DBF) {
     Incr = (Num_K > 1) ? To_Rec[1] : Num_K;
     PlgDBfree(Record);
@@ -837,7 +837,8 @@ bool XINDEX::SaveIndex(PGLOBAL g, PIXDEF sxp)
     case RECFM_FIX: ftype = ".fnx"; break;
     case RECFM_BIN: ftype = ".bnx"; break;
     case RECFM_VCT: ftype = ".vnx"; break;
-    case RECFM_DBF: ftype = ".dbx"; break;
+		case RECFM_CSV: ftype = ".cnx"; break;
+		case RECFM_DBF: ftype = ".dbx"; break;
     default:
       sprintf(g->Message, MSG(INVALID_FTYPE), Tdbp->Ftype);
       return true;
@@ -990,7 +991,8 @@ bool XINDEX::Init(PGLOBAL g)
     case RECFM_FIX: ftype = ".fnx"; break;
     case RECFM_BIN: ftype = ".bnx"; break;
     case RECFM_VCT: ftype = ".vnx"; break;
-    case RECFM_DBF: ftype = ".dbx"; break;
+		case RECFM_CSV: ftype = ".cnx"; break;
+		case RECFM_DBF: ftype = ".dbx"; break;
     default:
       sprintf(g->Message, MSG(INVALID_FTYPE), Tdbp->Ftype);
       return true;
@@ -1243,7 +1245,8 @@ bool XINDEX::MapInit(PGLOBAL g)
     case RECFM_FIX: ftype = ".fnx"; break;
     case RECFM_BIN: ftype = ".bnx"; break;
     case RECFM_VCT: ftype = ".vnx"; break;
-    case RECFM_DBF: ftype = ".dbx"; break;
+		case RECFM_CSV: ftype = ".cnx"; break;
+		case RECFM_DBF: ftype = ".dbx"; break;
     default:
       sprintf(g->Message, MSG(INVALID_FTYPE), Tdbp->Ftype);
       return true;
@@ -1457,7 +1460,8 @@ bool XINDEX::GetAllSizes(PGLOBAL g,/* int &ndif,*/ int &numk)
     case RECFM_FIX: ftype = ".fnx"; break;
     case RECFM_BIN: ftype = ".bnx"; break;
     case RECFM_VCT: ftype = ".vnx"; break;
-    case RECFM_DBF: ftype = ".dbx"; break;
+		case RECFM_CSV: ftype = ".cnx"; break;
+		case RECFM_DBF: ftype = ".dbx"; break;
     default:
       sprintf(g->Message, MSG(INVALID_FTYPE), Tdbp->Ftype);
       return true;
diff --git a/storage/connect/xtable.h b/storage/connect/xtable.h
index bc9265e0223..1b499e09047 100644
--- a/storage/connect/xtable.h
+++ b/storage/connect/xtable.h
@@ -173,9 +173,12 @@ class DllExport TDBASE : public TDB {
   inline  void    SetKindex(PKXBASE kxp) {To_Kindex = kxp;}
 
   // Properties
-	virtual PKXBASE GetKindex(void) {return To_Kindex;}
+	PKXBASE GetKindex(void) {return To_Kindex;}
+	PXOB   *GetLink(void) {return To_Link;}
+	PIXDEF  GetXdp(void) {return To_Xdp;}
 	void    ResetKindex(PGLOBAL g, PKXBASE kxp);
   PCOL    Key(int i) {return (To_Key_Col) ? To_Key_Col[i] : NULL;}
+	PXOB    Link(int i) { return (To_Link) ? To_Link[i] : NULL; }
 
   // Methods
   virtual bool   IsUsingTemp(PGLOBAL) {return false;}
diff --git a/storage/example/ha_example.cc b/storage/example/ha_example.cc
index 643fa1ae09a..ab402c636d1 100644
--- a/storage/example/ha_example.cc
+++ b/storage/example/ha_example.cc
@@ -225,9 +225,9 @@ static void init_example_psi_keys()
   used by the default rename_table and delete_table method in
   handler.cc and by the default discover_many method.
 
-  For engines that have two file name extentions (separate meta/index file
+  For engines that have two file name extensions (separate meta/index file
   and data file), the order of elements is relevant. First element of engine
-  file name extentions array should be meta/index file extention. Second
+  file name extensions array should be meta/index file extention. Second
   element - data file extention. This order is assumed by
   prepare_for_repair() when REPAIR TABLE ... USE_FRM is issued.
 
diff --git a/storage/federatedx/AUTHORS b/storage/federatedx/AUTHORS
index 6314d2e4a3d..cdd6600fb5a 100644
--- a/storage/federatedx/AUTHORS
+++ b/storage/federatedx/AUTHORS
@@ -7,5 +7,5 @@ Pluggable Storage Engine Skeleton setup
 Brian Aker  <brian@mysql.com> | <brian@tangent.org> - Original Design
 Calvin Sun - Windows Support
 Brian Miezejewski - Bug fixes
-Antony T Curtis   - Help in inital development, transactions and various help
+Antony T Curtis   - Help in initial development, transactions and various help
 Michael Widenius  - Bug fixes and some simple early optimizations
diff --git a/storage/federatedx/ha_federatedx.cc b/storage/federatedx/ha_federatedx.cc
index 74d547cb674..4a717eead20 100644
--- a/storage/federatedx/ha_federatedx.cc
+++ b/storage/federatedx/ha_federatedx.cc
@@ -798,12 +798,12 @@ static int parse_url(MEM_ROOT *mem_root, FEDERATEDX_SHARE *share,
       goto error;
 
     if (share->hostname[0] == '\0')
-      share->hostname= NULL;
+      share->hostname= strdup_root(mem_root, my_localhost);
 
   }
   if (!share->port)
   {
-    if (!share->hostname || strcmp(share->hostname, my_localhost) == 0)
+    if (0 == strcmp(share->hostname, my_localhost))
       share->socket= (char *) MYSQL_UNIX_ADDR;
     else
       share->port= MYSQL_PORT;
@@ -3385,8 +3385,7 @@ int ha_federatedx::create(const char *name, TABLE *table_arg,
     goto error;
 
   /* loopback socket connections hang due to LOCK_open mutex */
-  if ((!tmp_share.hostname || !strcmp(tmp_share.hostname,my_localhost)) &&
-      !tmp_share.port)
+  if (0 == strcmp(tmp_share.hostname, my_localhost) && !tmp_share.port)
     goto error;
 
   /*
diff --git a/storage/innobase/btr/btr0btr.cc b/storage/innobase/btr/btr0btr.cc
index 2f353c9e7e7..ed3b632b300 100644
--- a/storage/innobase/btr/btr0btr.cc
+++ b/storage/innobase/btr/btr0btr.cc
@@ -775,7 +775,7 @@ btr_node_ptr_set_child_page_no(
 	rec_t*		rec,	/*!< in: node pointer record */
 	page_zip_des_t*	page_zip,/*!< in/out: compressed page whose uncompressed
 				part will be updated, or NULL */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		page_no,/*!< in: child node address */
 	mtr_t*		mtr)	/*!< in: mtr */
 {
@@ -810,7 +810,7 @@ btr_node_ptr_get_child(
 /*===================*/
 	const rec_t*	node_ptr,/*!< in: node pointer */
 	dict_index_t*	index,	/*!< in: index */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	mtr_t*		mtr)	/*!< in: mtr */
 {
 	ut_ad(rec_offs_validate(node_ptr, index, offsets));
@@ -829,10 +829,10 @@ Returns the upper level node pointer to a page. It is assumed that mtr holds
 an sx-latch on the tree.
 @return rec_get_offsets() of the node pointer record */
 static
-ulint*
+offset_t*
 btr_page_get_father_node_ptr_func(
 /*==============================*/
-	ulint*		offsets,/*!< in: work area for the return value */
+	offset_t*	offsets,/*!< in: work area for the return value */
 	mem_heap_t*	heap,	/*!< in: memory heap to use */
 	btr_cur_t*	cursor,	/*!< in: cursor pointing to user record,
 				out: cursor on node pointer record,
@@ -936,10 +936,10 @@ Returns the upper level node pointer to a page. It is assumed that mtr holds
 an x-latch on the tree.
 @return rec_get_offsets() of the node pointer record */
 static
-ulint*
+offset_t*
 btr_page_get_father_block(
 /*======================*/
-	ulint*		offsets,/*!< in: work area for the return value */
+	offset_t*	offsets,/*!< in: work area for the return value */
 	mem_heap_t*	heap,	/*!< in: memory heap to use */
 	dict_index_t*	index,	/*!< in: b-tree index */
 	buf_block_t*	block,	/*!< in: child page in the index */
@@ -1823,7 +1823,7 @@ btr_root_raise_and_insert(
 				on the root page; when the function returns,
 				the cursor is positioned on the predecessor
 				of the inserted record */
-	ulint**		offsets,/*!< out: offsets on inserted record */
+	offset_t**	offsets,/*!< out: offsets on inserted record */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap, or NULL */
 	const dtuple_t*	tuple,	/*!< in: tuple to insert */
 	ulint		n_ext,	/*!< in: number of externally stored columns */
@@ -2156,7 +2156,7 @@ btr_page_get_split_rec(
 	rec_t*		next_rec;
 	ulint		n;
 	mem_heap_t*	heap;
-	ulint*		offsets;
+	offset_t*	offsets;
 
 	page = btr_cur_get_page(cursor);
 
@@ -2262,7 +2262,7 @@ btr_page_insert_fits(
 	const rec_t*	split_rec,/*!< in: suggestion for first record
 				on upper half-page, or NULL if
 				tuple to be inserted should be first */
-	ulint**		offsets,/*!< in: rec_get_offsets(
+	offset_t**	offsets,/*!< in: rec_get_offsets(
 				split_rec, cursor->index); out: garbage */
 	const dtuple_t*	tuple,	/*!< in: tuple to insert */
 	ulint		n_ext,	/*!< in: number of externally stored columns */
@@ -2362,8 +2362,8 @@ btr_insert_on_non_leaf_level_func(
 	dberr_t		err;
 	rec_t*		rec;
 	mem_heap_t*	heap = NULL;
-	ulint           offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*          offsets         = offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets         = offsets_;
 	rec_offs_init(offsets_);
 	rtr_info_t	rtr_info;
 
@@ -2471,7 +2471,7 @@ btr_attach_half_pages(
 	if (direction == FSP_DOWN) {
 
 		btr_cur_t	cursor;
-		ulint*		offsets;
+		offset_t*	offsets;
 
 		lower_page = buf_block_get_frame(new_block);
 		lower_page_no = new_block->page.id.page_no();
@@ -2593,7 +2593,7 @@ btr_page_tuple_smaller(
 /*===================*/
 	btr_cur_t*	cursor,	/*!< in: b-tree cursor */
 	const dtuple_t*	tuple,	/*!< in: tuple to consider */
-	ulint**		offsets,/*!< in/out: temporary storage */
+	offset_t**	offsets,/*!< in/out: temporary storage */
 	ulint		n_uniq,	/*!< in: number of unique fields
 				in the index page records */
 	mem_heap_t**	heap)	/*!< in/out: heap for offsets */
@@ -2633,7 +2633,7 @@ rec_t*
 btr_insert_into_right_sibling(
 	ulint		flags,
 	btr_cur_t*	cursor,
-	ulint**		offsets,
+	offset_t**	offsets,
 	mem_heap_t*	heap,
 	const dtuple_t*	tuple,
 	ulint		n_ext,
@@ -2769,7 +2769,7 @@ btr_page_split_and_insert(
 	btr_cur_t*	cursor,	/*!< in: cursor at which to insert; when the
 				function returns, the cursor is positioned
 				on the predecessor of the inserted record */
-	ulint**		offsets,/*!< out: offsets on inserted record */
+	offset_t**	offsets,/*!< out: offsets on inserted record */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap, or NULL */
 	const dtuple_t*	tuple,	/*!< in: tuple to insert */
 	ulint		n_ext,	/*!< in: number of externally stored columns */
@@ -3321,7 +3321,7 @@ btr_lift_page_up(
 
 	{
 		btr_cur_t	cursor;
-		ulint*		offsets	= NULL;
+		offset_t*	offsets	= NULL;
 		mem_heap_t*	heap	= mem_heap_create(
 			sizeof(*offsets)
 			* (REC_OFFS_HEADER_SIZE + 1 + 1
@@ -3518,7 +3518,7 @@ btr_compress(
 	page_t*		page;
 	btr_cur_t	father_cursor;
 	mem_heap_t*	heap;
-	ulint*		offsets;
+	offset_t*	offsets;
 	ulint		nth_rec = 0; /* remove bogus warning */
 	bool		mbr_changed = false;
 #ifdef UNIV_DEBUG
@@ -3661,7 +3661,7 @@ retry:
 	if (is_left) {
 		btr_cur_t	cursor2;
 		rtr_mbr_t	new_mbr;
-		ulint*		offsets2 = NULL;
+		offset_t*	offsets2 = NULL;
 
 		/* For rtree, we need to update father's mbr. */
 		if (dict_index_is_spatial(index)) {
@@ -3857,7 +3857,7 @@ retry:
 
 		/* For rtree, we need to update father's mbr. */
 		if (dict_index_is_spatial(index)) {
-			ulint*	offsets2;
+			offset_t* offsets2;
 			ulint	rec_info;
 
 			offsets2 = rec_get_offsets(
@@ -4304,7 +4304,7 @@ btr_print_recursive(
 	ulint		width,	/*!< in: print this many entries from start
 				and end */
 	mem_heap_t**	heap,	/*!< in/out: heap for rec_get_offsets() */
-	ulint**		offsets,/*!< in/out: buffer for rec_get_offsets() */
+	offset_t**	offsets,/*!< in/out: buffer for rec_get_offsets() */
 	mtr_t*		mtr)	/*!< in: mtr */
 {
 	const page_t*	page	= buf_block_get_frame(block);
@@ -4368,8 +4368,8 @@ btr_print_index(
 	mtr_t		mtr;
 	buf_block_t*	root;
 	mem_heap_t*	heap	= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets	= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets	= offsets_;
 	rec_offs_init(offsets_);
 
 	fputs("--------------------------\n"
@@ -4403,7 +4403,7 @@ btr_check_node_ptr(
 {
 	mem_heap_t*	heap;
 	dtuple_t*	tuple;
-	ulint*		offsets;
+	offset_t*	offsets;
 	btr_cur_t	cursor;
 	page_t*		page = buf_block_get_frame(block);
 
@@ -4483,8 +4483,8 @@ btr_index_rec_validate(
 	ulint		len;
 	const page_t*	page;
 	mem_heap_t*	heap	= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets	= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets	= offsets_;
 	rec_offs_init(offsets_);
 
 	page = page_align(rec);
@@ -4716,8 +4716,8 @@ btr_validate_level(
 	bool		ret	= true;
 	mtr_t		mtr;
 	mem_heap_t*	heap	= mem_heap_create(256);
-	ulint*		offsets	= NULL;
-	ulint*		offsets2= NULL;
+	offset_t*	offsets	= NULL;
+	offset_t*	offsets2= NULL;
 #ifdef UNIV_ZIP_DEBUG
 	page_zip_des_t*	page_zip;
 #endif /* UNIV_ZIP_DEBUG */
diff --git a/storage/innobase/btr/btr0bulk.cc b/storage/innobase/btr/btr0bulk.cc
index 6f11796487d..3e170017408 100644
--- a/storage/innobase/btr/btr0bulk.cc
+++ b/storage/innobase/btr/btr0bulk.cc
@@ -175,7 +175,7 @@ PageBulk::init()
 void
 PageBulk::insert(
 	const rec_t*		rec,
-	ulint*			offsets)
+	offset_t*		offsets)
 {
 	ulint		rec_size;
 
@@ -188,7 +188,7 @@ PageBulk::insert(
 	/* Check whether records are in order. */
 	if (!page_rec_is_infimum(m_cur_rec)) {
 		rec_t*	old_rec = m_cur_rec;
-		ulint*	old_offsets = rec_get_offsets(
+		offset_t* old_offsets = rec_get_offsets(
 			old_rec, m_index, NULL,	is_leaf,
 			ULINT_UNDEFINED, &m_heap);
 
@@ -401,7 +401,7 @@ rec_t*
 PageBulk::getSplitRec()
 {
 	rec_t*		rec;
-	ulint*		offsets;
+	offset_t*	offsets;
 	ulint		total_used_size;
 	ulint		total_recs_size;
 	ulint		n_recs;
@@ -447,7 +447,7 @@ PageBulk::copyIn(
 {
 
 	rec_t*		rec = split_rec;
-	ulint*		offsets = NULL;
+	offset_t*	offsets = NULL;
 
 	ut_ad(m_rec_no == 0);
 	ut_ad(page_rec_is_user_rec(rec));
@@ -493,7 +493,7 @@ PageBulk::copyOut(
 	ut_ad(n > 0);
 
 	/* Set last record's next in page */
-	ulint*		offsets = NULL;
+	offset_t*	offsets = NULL;
 	rec = page_rec_get_prev(split_rec);
 	offsets = rec_get_offsets(rec, m_index, offsets,
 				  page_rec_is_leaf(split_rec),
@@ -602,7 +602,7 @@ the blob data is logged first, then the record is logged in bulk mode.
 dberr_t
 PageBulk::storeExt(
 	const big_rec_t*	big_rec,
-	ulint*			offsets)
+	offset_t*		offsets)
 {
 	/* Note: not all fileds are initialized in btr_pcur. */
 	btr_pcur_t	btr_pcur;
@@ -862,7 +862,7 @@ BtrBulk::insert(
 	ulint		rec_size = rec_get_converted_size(m_index, tuple, n_ext);
 	big_rec_t*	big_rec = NULL;
 	rec_t*		rec = NULL;
-	ulint*		offsets = NULL;
+	offset_t*	offsets = NULL;
 
 	if (page_bulk->needExt(tuple, rec_size)) {
 		/* The record is so big that we have to store some fields
diff --git a/storage/innobase/btr/btr0cur.cc b/storage/innobase/btr/btr0cur.cc
index 3465ff2edcb..c79ea1c5467 100644
--- a/storage/innobase/btr/btr0cur.cc
+++ b/storage/innobase/btr/btr0cur.cc
@@ -1,9 +1,9 @@
 /*****************************************************************************
 
-Copyright (c) 1994, 2018, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 1994, 2019, Oracle and/or its affiliates. All Rights Reserved.
 Copyright (c) 2008, Google Inc.
 Copyright (c) 2012, Facebook Inc.
-Copyright (c) 2015, 2019, MariaDB Corporation.
+Copyright (c) 2015, 2020, MariaDB Corporation.
 
 Portions of this file contain modifications contributed and copyrighted by
 Google, Inc. Those modifications are gratefully acknowledged and are described
@@ -158,7 +158,7 @@ btr_cur_unmark_extern_fields(
 				part will be updated, or NULL */
 	rec_t*		rec,	/*!< in/out: record in a clustered index */
 	dict_index_t*	index,	/*!< in: index of the page */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	mtr_t*		mtr);	/*!< in: mtr, or NULL if not logged */
 /*******************************************************************//**
 Adds path information to the cursor for the current page, for which
@@ -183,7 +183,7 @@ btr_rec_free_updated_extern_fields(
 	rec_t*		rec,	/*!< in: record */
 	page_zip_des_t*	page_zip,/*!< in: compressed page whose uncompressed
 				part will be updated, or NULL */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	const upd_t*	update,	/*!< in: update vector */
 	bool		rollback,/*!< in: performing rollback? */
 	mtr_t*		mtr);	/*!< in: mini-transaction handle which contains
@@ -197,7 +197,7 @@ btr_rec_free_externally_stored_fields(
 	dict_index_t*	index,	/*!< in: index of the data, the index
 				tree MUST be X-latched */
 	rec_t*		rec,	/*!< in: record */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	page_zip_des_t*	page_zip,/*!< in: compressed page whose uncompressed
 				part will be updated, or NULL */
 	bool		rollback,/*!< in: performing rollback? */
@@ -476,8 +476,8 @@ incompatible:
 	from the cache. */
 
 	mem_heap_t* heap = NULL;
-	ulint* offsets = rec_get_offsets(rec, index, NULL, true,
-					 ULINT_UNDEFINED, &heap);
+	offset_t* offsets = rec_get_offsets(rec, index, NULL, true,
+					    ULINT_UNDEFINED, &heap);
 	if (rec_offs_any_default(offsets)) {
 inconsistent:
 		mem_heap_free(heap);
@@ -804,46 +804,66 @@ btr_cur_will_modify_tree(
 	const ulint n_recs = page_get_n_recs(page);
 
 	if (lock_intention <= BTR_INTENTION_BOTH) {
-		ulint	margin;
+		compile_time_assert(BTR_INTENTION_DELETE < BTR_INTENTION_BOTH);
+		compile_time_assert(BTR_INTENTION_BOTH < BTR_INTENTION_INSERT);
 
-		/* check delete will cause. (BTR_INTENTION_BOTH
-		or BTR_INTENTION_DELETE) */
-		/* first, 2nd, 2nd-last and last records are 4 records */
-		if (n_recs < 5) {
-			return(true);
+		if (!page_has_siblings(page)) {
+			return true;
 		}
 
-		/* is first, 2nd or last record */
-		if (page_rec_is_first(rec, page)
-		    || (page_has_next(page)
-			&& (page_rec_is_last(rec, page)
-			    || page_rec_is_second_last(rec, page)))
-		    || (page_has_prev(page)
-			&& page_rec_is_second(rec, page))) {
-			return(true);
-		}
+		ulint margin = rec_size;
 
 		if (lock_intention == BTR_INTENTION_BOTH) {
+			ulint	level = btr_page_get_level(page);
+
+			/* This value is the worst expectation for the node_ptr
+			records to be deleted from this page. It is used to
+			expect whether the cursor position can be the left_most
+			record in this page or not. */
+			ulint   max_nodes_deleted = 0;
+
+			/* By modifying tree operations from the under of this
+			level, logically (2 ^ (level - 1)) opportunities to
+			deleting records in maximum even unreally rare case. */
+			if (level > 7) {
+				/* TODO: adjust this practical limit. */
+				max_nodes_deleted = 64;
+			} else if (level > 0) {
+				max_nodes_deleted = (ulint)1 << (level - 1);
+			}
+			/* check delete will cause. (BTR_INTENTION_BOTH
+			or BTR_INTENTION_DELETE) */
+			if (n_recs <= max_nodes_deleted * 2
+			    || page_rec_is_first(rec, page)) {
+				/* The cursor record can be the left most record
+				in this page. */
+				return true;
+			}
+
+			if (page_has_prev(page)
+			    && page_rec_distance_is_at_most(
+				    page_get_infimum_rec(page), rec,
+				    max_nodes_deleted)) {
+				return true;
+			}
+
+			if (page_has_next(page)
+			    && page_rec_distance_is_at_most(
+				    rec, page_get_supremum_rec(page),
+				    max_nodes_deleted)) {
+				return true;
+			}
+
 			/* Delete at leftmost record in a page causes delete
 			& insert at its parent page. After that, the delete
 			might cause btr_compress() and delete record at its
-			parent page. Thus we should consider max 2 deletes. */
-
-			margin = rec_size * 2;
-		} else {
-			ut_ad(lock_intention == BTR_INTENTION_DELETE);
-
-			margin = rec_size;
+			parent page. Thus we should consider max deletes. */
+			margin *= max_nodes_deleted;
 		}
-		/* NOTE: call mach_read_from_4() directly to avoid assertion
-		failure. It is safe because we already have SX latch of the
-		index tree */
+
+		/* Safe because we already have SX latch of the index tree */
 		if (page_get_data_size(page)
-			< margin + BTR_CUR_PAGE_COMPRESS_LIMIT(index)
-		    || (mach_read_from_4(page + FIL_PAGE_NEXT)
-				== FIL_NULL
-			&& mach_read_from_4(page + FIL_PAGE_PREV)
-				== FIL_NULL)) {
+		    < margin + BTR_CUR_PAGE_COMPRESS_LIMIT(index)) {
 			return(true);
 		}
 	}
@@ -1142,10 +1162,10 @@ btr_cur_search_to_nth_level_func(
 	btr_search_t*	info;
 #endif /* BTR_CUR_ADAPT */
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
-	ulint		offsets2_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets2	= offsets2_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
+	offset_t	offsets2_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets2	= offsets2_;
 	rec_offs_init(offsets_);
 	rec_offs_init(offsets2_);
 	/* Currently, PAGE_CUR_LE is the only search mode used for searches
@@ -2025,9 +2045,9 @@ need_opposite_intention:
 				offsets2 = rec_get_offsets(
 					first_rec, index, offsets2,
 					false, ULINT_UNDEFINED, &heap);
-				cmp_rec_rec_with_match(node_ptr, first_rec,
-					offsets, offsets2, index, FALSE,
-					&matched_fields);
+				cmp_rec_rec(node_ptr, first_rec,
+					    offsets, offsets2, index, false,
+					    &matched_fields);
 
 				if (matched_fields
 				    >= rec_offs_n_fields(offsets) - 1) {
@@ -2043,10 +2063,10 @@ need_opposite_intention:
 					offsets2 = rec_get_offsets(
 						last_rec, index, offsets2,
 						false, ULINT_UNDEFINED, &heap);
-					cmp_rec_rec_with_match(
+					cmp_rec_rec(
 						node_ptr, last_rec,
 						offsets, offsets2, index,
-						FALSE, &matched_fields);
+						false, &matched_fields);
 					if (matched_fields
 					    >= rec_offs_n_fields(offsets) - 1) {
 						detected_same_key_root = true;
@@ -2406,8 +2426,8 @@ btr_cur_open_at_index_side_func(
 	ulint		n_blocks = 0;
 	ulint		n_releases = 0;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	dberr_t		err = DB_SUCCESS;
 
 	rec_offs_init(offsets_);
@@ -2775,8 +2795,8 @@ btr_cur_open_at_rnd_pos_func(
 	ulint		n_blocks = 0;
 	ulint		n_releases = 0;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(!index->is_spatial());
@@ -3065,7 +3085,7 @@ btr_cur_insert_if_possible(
 				cursor stays valid */
 	const dtuple_t*	tuple,	/*!< in: tuple to insert; the size info need not
 				have been stored to tuple */
-	ulint**		offsets,/*!< out: offsets on *rec */
+	offset_t**	offsets,/*!< out: offsets on *rec */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap, or NULL */
 	ulint		n_ext,	/*!< in: number of externally stored columns */
 	mtr_t*		mtr)	/*!< in/out: mini-transaction */
@@ -3228,7 +3248,7 @@ btr_cur_optimistic_insert(
 				specified */
 	btr_cur_t*	cursor,	/*!< in: cursor on page after which to insert;
 				cursor stays valid */
-	ulint**		offsets,/*!< out: offsets on *rec */
+	offset_t**	offsets,/*!< out: offsets on *rec */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap */
 	dtuple_t*	entry,	/*!< in/out: entry to insert */
 	rec_t**		rec,	/*!< out: pointer to inserted record if
@@ -3528,7 +3548,7 @@ btr_cur_pessimistic_insert(
 				insertion will certainly succeed */
 	btr_cur_t*	cursor,	/*!< in: cursor after which to insert;
 				cursor stays valid */
-	ulint**		offsets,/*!< out: offsets on *rec */
+	offset_t**	offsets,/*!< out: offsets on *rec */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap
 				that can be emptied */
 	dtuple_t*	entry,	/*!< in/out: entry to insert */
@@ -3666,8 +3686,8 @@ btr_cur_pessimistic_insert(
 		if (entry->info_bits & REC_INFO_MIN_REC_FLAG) {
 			ut_ad(entry->info_bits == REC_INFO_METADATA);
 			ut_ad(index->is_instant());
-			ut_ad((flags & ulint(~BTR_KEEP_IBUF_BITMAP))
-			      == BTR_NO_LOCKING_FLAG);
+			ut_ad(flags & BTR_NO_LOCKING_FLAG);
+			ut_ad(!(flags & BTR_CREATE_FLAG));
 		} else {
 			btr_search_update_hash_on_insert(
 				cursor, btr_get_search_latch(index));
@@ -3696,7 +3716,7 @@ btr_cur_upd_lock_and_undo(
 /*======================*/
 	ulint		flags,	/*!< in: undo logging and locking flags */
 	btr_cur_t*	cursor,	/*!< in: cursor on record to update */
-	const ulint*	offsets,/*!< in: rec_get_offsets() on cursor */
+	const offset_t*	offsets,/*!< in: rec_get_offsets() on cursor */
 	const upd_t*	update,	/*!< in: update vector */
 	ulint		cmpl_info,/*!< in: compiler info on secondary index
 				updates */
@@ -3827,7 +3847,7 @@ btr_cur_parse_update_in_place(
 	roll_ptr_t	roll_ptr;
 	ulint		rec_offset;
 	mem_heap_t*	heap;
-	ulint*		offsets;
+	offset_t*	offsets;
 
 	if (end_ptr < ptr + 1) {
 
@@ -3912,7 +3932,7 @@ btr_cur_update_alloc_zip_func(
 	page_cur_t*	cursor,	/*!< in/out: B-tree page cursor */
 	dict_index_t*	index,	/*!< in: the index corresponding to cursor */
 #ifdef UNIV_DEBUG
-	ulint*		offsets,/*!< in/out: offsets of the cursor record */
+	offset_t*	offsets,/*!< in/out: offsets of the cursor record */
 #endif /* UNIV_DEBUG */
 	ulint		length,	/*!< in: size needed */
 	bool		create,	/*!< in: true=delete-and-insert,
@@ -3994,7 +4014,7 @@ btr_cur_update_in_place(
 	btr_cur_t*	cursor,	/*!< in: cursor on the record to update;
 				cursor stays valid and positioned on the
 				same record */
-	ulint*		offsets,/*!< in/out: offsets on cursor->page_cur.rec */
+	offset_t*	offsets,/*!< in/out: offsets on cursor->page_cur.rec */
 	const upd_t*	update,	/*!< in: update vector */
 	ulint		cmpl_info,/*!< in: compiler info on secondary index
 				updates */
@@ -4215,7 +4235,7 @@ btr_cur_optimistic_update(
 	btr_cur_t*	cursor,	/*!< in: cursor on the record to update;
 				cursor stays valid and positioned on the
 				same record */
-	ulint**		offsets,/*!< out: offsets on cursor->page_cur.rec */
+	offset_t**	offsets,/*!< out: offsets on cursor->page_cur.rec */
 	mem_heap_t**	heap,	/*!< in/out: pointer to NULL or memory heap */
 	const upd_t*	update,	/*!< in: update vector; this must also
 				contain trx id and roll ptr fields */
@@ -4242,7 +4262,6 @@ btr_cur_optimistic_update(
 	dtuple_t*	new_entry;
 	roll_ptr_t	roll_ptr;
 	ulint		i;
-	ulint		n_ext;
 
 	block = btr_cur_get_block(cursor);
 	page = buf_block_get_frame(block);
@@ -4319,10 +4338,8 @@ any_extern:
 			+ DTUPLE_EST_ALLOC(rec_offs_n_fields(*offsets)));
 	}
 
-	new_entry = row_rec_to_index_entry(rec, index, *offsets,
-					   &n_ext, *heap);
-	/* We checked above that there are no externally stored fields. */
-	ut_a(!n_ext);
+	new_entry = row_rec_to_index_entry(rec, index, *offsets, *heap);
+	ut_ad(!dtuple_get_n_ext(new_entry));
 
 	/* The page containing the clustered index record
 	corresponding to new_entry is latched in mtr.
@@ -4553,7 +4570,7 @@ btr_cur_pessimistic_update(
 	btr_cur_t*	cursor,	/*!< in/out: cursor on the record to update;
 				cursor may become invalid if *big_rec == NULL
 				|| !(flags & BTR_KEEP_POS_FLAG) */
-	ulint**		offsets,/*!< out: offsets on cursor->page_cur.rec */
+	offset_t**	offsets,/*!< out: offsets on cursor->page_cur.rec */
 	mem_heap_t**	offsets_heap,
 				/*!< in/out: pointer to memory heap
 				that can be emptied */
@@ -4586,7 +4603,6 @@ btr_cur_pessimistic_update(
 	roll_ptr_t	roll_ptr;
 	ibool		was_first;
 	ulint		n_reserved	= 0;
-	ulint		n_ext;
 	ulint		max_ins_size	= 0;
 
 	*offsets = NULL;
@@ -4651,7 +4667,7 @@ btr_cur_pessimistic_update(
 	ut_ad(rec_offs_validate(rec, index, *offsets));
 
 	dtuple_t*	new_entry = row_rec_to_index_entry(
-		rec, index, *offsets, &n_ext, entry_heap);
+		rec, index, *offsets, entry_heap);
 
 	/* The page containing the clustered index record
 	corresponding to new_entry is latched in mtr.  If the
@@ -4671,7 +4687,6 @@ btr_cur_pessimistic_update(
 
 	ut_ad(!page_is_comp(page) || !rec_get_node_ptr_flag(rec));
 	ut_ad(rec_offs_validate(rec, index, *offsets));
-	n_ext += btr_push_update_extern_fields(new_entry, update, entry_heap);
 
 	if ((flags & BTR_NO_UNDO_LOG_FLAG)
 	    && rec_offs_any_extern(*offsets)) {
@@ -4692,6 +4707,8 @@ btr_cur_pessimistic_update(
 			index, rec, page_zip, *offsets, update, true, mtr);
 	}
 
+	ulint n_ext = dtuple_get_n_ext(new_entry);
+
 	if (page_zip_rec_needs_ext(
 			rec_get_converted_size(index, new_entry, n_ext),
 			page_is_comp(page),
@@ -5098,7 +5115,7 @@ btr_cur_parse_del_mark_set_clust_rec(
 		clustered index fields. */
 		ut_ad(pos <= MAX_REF_PARTS);
 
-		ulint offsets[REC_OFFS_HEADER_SIZE + MAX_REF_PARTS + 2];
+		offset_t offsets[REC_OFFS_HEADER_SIZE + MAX_REF_PARTS + 2];
 		rec_offs_init(offsets);
 		mem_heap_t*	heap	= NULL;
 
@@ -5141,7 +5158,7 @@ btr_cur_del_mark_set_clust_rec(
 	buf_block_t*	block,	/*!< in/out: buffer block of the record */
 	rec_t*		rec,	/*!< in/out: record */
 	dict_index_t*	index,	/*!< in: clustered index of the record */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec) */
 	que_thr_t*	thr,	/*!< in: query thread */
 	const dtuple_t*	entry,	/*!< in: dtuple for the deleting record, also
 				contains the virtual cols if there are any */
@@ -5427,8 +5444,8 @@ btr_cur_optimistic_delete_func(
 	buf_block_t*	block;
 	rec_t*		rec;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	ibool		no_compress_needed;
 	rec_offs_init(offsets_);
 
@@ -5611,7 +5628,7 @@ btr_cur_pessimistic_delete(
 	bool		success;
 	ibool		ret		= FALSE;
 	mem_heap_t*	heap;
-	ulint*		offsets;
+	offset_t*	offsets;
 #ifdef UNIV_DEBUG
 	bool		parent_latched	= false;
 #endif /* UNIV_DEBUG */
@@ -5759,7 +5776,7 @@ discard_page:
 			rtr_mbr_t	father_mbr;
 			rec_t*		father_rec;
 			btr_cur_t	father_cursor;
-			ulint*		offsets;
+			offset_t*	offsets;
 			bool		upd_ret;
 			ulint		len;
 
@@ -6505,7 +6522,7 @@ btr_record_not_null_field_in_rec(
 	ulint		n_unique,	/*!< in: dict_index_get_n_unique(index),
 					number of columns uniquely determine
 					an index entry */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec, index),
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec, index),
 					its size could be for all fields or
 					that of "n_unique" */
 	ib_uint64_t*	n_not_null)	/*!< in/out: array to record number of
@@ -6559,8 +6576,8 @@ btr_estimate_number_of_different_key_vals(
 	uintmax_t	add_on;
 	mtr_t		mtr;
 	mem_heap_t*	heap		= NULL;
-	ulint*		offsets_rec	= NULL;
-	ulint*		offsets_next_rec = NULL;
+	offset_t*	offsets_rec	= NULL;
+	offset_t*	offsets_next_rec = NULL;
 
 	/* For spatial index, there is no such stats can be
 	fetched. */
@@ -6722,10 +6739,10 @@ btr_estimate_number_of_different_key_vals(
 							   ULINT_UNDEFINED,
 							   &heap);
 
-			cmp_rec_rec_with_match(rec, next_rec,
-					       offsets_rec, offsets_next_rec,
-					       index, stats_null_not_equal,
-					       &matched_fields);
+			cmp_rec_rec(rec, next_rec,
+				    offsets_rec, offsets_next_rec,
+				    index, stats_null_not_equal,
+				    &matched_fields);
 
 			for (j = matched_fields; j < n_cols; j++) {
 				/* We add one if this index record has
@@ -6748,7 +6765,7 @@ btr_estimate_number_of_different_key_vals(
 			and assign the old offsets_rec buffer to
 			offsets_next_rec. */
 			{
-				ulint*	offsets_tmp = offsets_rec;
+				offset_t* offsets_tmp = offsets_rec;
 				offsets_rec = offsets_next_rec;
 				offsets_next_rec = offsets_tmp;
 			}
@@ -6833,7 +6850,7 @@ static
 ulint
 btr_rec_get_field_ref_offs(
 /*=======================*/
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		n)	/*!< in: index of the external field */
 {
 	ulint	field_ref_offs;
@@ -6862,7 +6879,7 @@ btr_rec_get_field_ref_offs(
 ulint
 btr_rec_get_externally_stored_len(
 	const rec_t*	rec,
-	const ulint*	offsets)
+	const offset_t*	offsets)
 {
 	ulint	n_fields;
 	ulint	total_extern_len = 0;
@@ -6901,7 +6918,7 @@ btr_cur_set_ownership_of_extern_field(
 				part will be updated, or NULL */
 	rec_t*		rec,	/*!< in/out: clustered index record */
 	dict_index_t*	index,	/*!< in: index of the page */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		i,	/*!< in: field number */
 	ibool		val,	/*!< in: value to set */
 	mtr_t*		mtr)	/*!< in: mtr, or NULL if not logged */
@@ -6951,7 +6968,7 @@ btr_cur_disown_inherited_fields(
 				part will be updated, or NULL */
 	rec_t*		rec,	/*!< in/out: record in a clustered index */
 	dict_index_t*	index,	/*!< in: index of the page */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	const upd_t*	update,	/*!< in: update vector */
 	mtr_t*		mtr)	/*!< in/out: mini-transaction */
 {
@@ -6982,7 +6999,7 @@ btr_cur_unmark_extern_fields(
 				part will be updated, or NULL */
 	rec_t*		rec,	/*!< in/out: record in a clustered index */
 	dict_index_t*	index,	/*!< in: index of the page */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	mtr_t*		mtr)	/*!< in: mtr, or NULL if not logged */
 {
 	ulint	n;
@@ -7006,84 +7023,6 @@ btr_cur_unmark_extern_fields(
 }
 
 /*******************************************************************//**
-Flags the data tuple fields that are marked as extern storage in the
-update vector.  We use this function to remember which fields we must
-mark as extern storage in a record inserted for an update.
-@return number of flagged external columns */
-ulint
-btr_push_update_extern_fields(
-/*==========================*/
-	dtuple_t*	tuple,	/*!< in/out: data tuple */
-	const upd_t*	update,	/*!< in: update vector */
-	mem_heap_t*	heap)	/*!< in: memory heap */
-{
-	ulint			n_pushed	= 0;
-	ulint			n;
-	const upd_field_t*	uf;
-
-	uf = update->fields;
-	n = upd_get_n_fields(update);
-
-	for (; n--; uf++) {
-		if (dfield_is_ext(&uf->new_val)) {
-			dfield_t*	field
-				= dtuple_get_nth_field(tuple, uf->field_no);
-
-			if (!dfield_is_ext(field)) {
-				dfield_set_ext(field);
-				n_pushed++;
-			}
-
-			switch (uf->orig_len) {
-				byte*	data;
-				ulint	len;
-				byte*	buf;
-			case 0:
-				break;
-			case BTR_EXTERN_FIELD_REF_SIZE:
-				/* Restore the original locally stored
-				part of the column.  In the undo log,
-				InnoDB writes a longer prefix of externally
-				stored columns, so that column prefixes
-				in secondary indexes can be reconstructed. */
-				dfield_set_data(field,
-						(byte*) dfield_get_data(field)
-						+ dfield_get_len(field)
-						- BTR_EXTERN_FIELD_REF_SIZE,
-						BTR_EXTERN_FIELD_REF_SIZE);
-				dfield_set_ext(field);
-				break;
-			default:
-				/* Reconstruct the original locally
-				stored part of the column.  The data
-				will have to be copied. */
-				ut_a(uf->orig_len > BTR_EXTERN_FIELD_REF_SIZE);
-
-				data = (byte*) dfield_get_data(field);
-				len = dfield_get_len(field);
-
-				buf = (byte*) mem_heap_alloc(heap,
-							     uf->orig_len);
-				/* Copy the locally stored prefix. */
-				memcpy(buf, data,
-				       unsigned(uf->orig_len)
-				       - BTR_EXTERN_FIELD_REF_SIZE);
-				/* Copy the BLOB pointer. */
-				memcpy(buf + unsigned(uf->orig_len)
-				       - BTR_EXTERN_FIELD_REF_SIZE,
-				       data + len - BTR_EXTERN_FIELD_REF_SIZE,
-				       BTR_EXTERN_FIELD_REF_SIZE);
-
-				dfield_set_data(field, buf, uf->orig_len);
-				dfield_set_ext(field);
-			}
-		}
-	}
-
-	return(n_pushed);
-}
-
-/*******************************************************************//**
 Returns the length of a BLOB part stored on the header page.
 @return part length */
 static
@@ -7155,7 +7094,7 @@ struct btr_blob_log_check_t {
 	/** Mini transaction holding the latches for m_pcur */
 	mtr_t*		m_mtr;
 	/** rec_get_offsets(rec, index); offset of clust_rec */
-	const ulint*	m_offsets;
+	const offset_t*	m_offsets;
 	/** The block containing clustered record */
 	buf_block_t**	m_block;
 	/** The clustered record pointer */
@@ -7175,7 +7114,7 @@ struct btr_blob_log_check_t {
 	btr_blob_log_check_t(
 		btr_pcur_t*	pcur,
 		mtr_t*		mtr,
-		const ulint*	offsets,
+		const offset_t*	offsets,
 		buf_block_t**	block,
 		rec_t**		rec,
 		enum blob_op	op)
@@ -7246,7 +7185,7 @@ struct btr_blob_log_check_t {
 		*m_rec		= btr_pcur_get_rec(m_pcur);
 
 		rec_offs_make_valid(*m_rec, index, true,
-				    const_cast<ulint*>(m_offsets));
+				    const_cast<offset_t*>(m_offsets));
 
 		ut_ad(m_mtr->memo_contains_page_flagged(
 		      *m_rec,
@@ -7277,7 +7216,7 @@ btr_store_big_rec_extern_fields(
 	btr_pcur_t*	pcur,		/*!< in/out: a persistent cursor. if
 					btr_mtr is restarted, then this can
 					be repositioned. */
-	ulint*		offsets,	/*!< in/out: rec_get_offsets() on
+	offset_t*	offsets,	/*!< in/out: rec_get_offsets() on
 					pcur. the "external storage" flags
 					in offsets will correctly correspond
 					to rec when this function returns */
@@ -7537,33 +7476,6 @@ btr_store_big_rec_extern_fields(
 				/* Initialize the unused "prev page" pointer */
 				mlog_write_ulint(page + FIL_PAGE_PREV,
 						 FIL_NULL, MLOG_4BYTES, &mtr);
-				/* Write a back pointer to the record
-				into the otherwise unused area.  This
-				information could be useful in
-				debugging.  Later, we might want to
-				implement the possibility to relocate
-				BLOB pages.  Then, we would need to be
-				able to adjust the BLOB pointer in the
-				record.  We do not store the heap
-				number of the record, because it can
-				change in page_zip_reorganize() or
-				btr_page_reorganize().  However, also
-				the page number of the record may
-				change when B-tree nodes are split or
-				merged.
-				NOTE: FIL_PAGE_FILE_FLUSH_LSN space is
-				used by R-tree index for a Split Sequence
-				Number */
-				ut_ad(!dict_index_is_spatial(index));
-
-				mlog_write_ulint(page
-						 + FIL_PAGE_FILE_FLUSH_LSN_OR_KEY_VERSION,
-						 space_id,
-						 MLOG_4BYTES, &mtr);
-				mlog_write_ulint(page
-						 + FIL_PAGE_FILE_FLUSH_LSN_OR_KEY_VERSION + 4,
-						 rec_page_no,
-						 MLOG_4BYTES, &mtr);
 
 				/* Zero out the unused part of the page. */
 				memset(page + page_zip_get_size(page_zip)
@@ -7789,7 +7701,7 @@ btr_free_externally_stored_field(
 	byte*		field_ref,	/*!< in/out: field reference */
 	const rec_t*	rec,		/*!< in: record containing field_ref, for
 					page_zip_write_blob_ptr(), or NULL */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec, index),
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec, index),
 					or NULL */
 	page_zip_des_t*	page_zip,	/*!< in: compressed page corresponding
 					to rec, or NULL if rec == NULL */
@@ -7963,7 +7875,7 @@ btr_rec_free_externally_stored_fields(
 	dict_index_t*	index,	/*!< in: index of the data, the index
 				tree MUST be X-latched */
 	rec_t*		rec,	/*!< in/out: record */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	page_zip_des_t*	page_zip,/*!< in: compressed page whose uncompressed
 				part will be updated, or NULL */
 	bool		rollback,/*!< in: performing rollback? */
@@ -8004,7 +7916,7 @@ btr_rec_free_updated_extern_fields(
 	rec_t*		rec,	/*!< in/out: record */
 	page_zip_des_t*	page_zip,/*!< in: compressed page whose uncompressed
 				part will be updated, or NULL */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	const upd_t*	update,	/*!< in: update vector */
 	bool		rollback,/*!< in: performing rollback? */
 	mtr_t*		mtr)	/*!< in: mini-transaction handle which contains
@@ -8402,7 +8314,7 @@ protected by a lock or a page latch
 byte*
 btr_rec_copy_externally_stored_field(
 	const rec_t*		rec,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	const page_size_t&	page_size,
 	ulint			no,
 	ulint*			len,
diff --git a/storage/innobase/btr/btr0defragment.cc b/storage/innobase/btr/btr0defragment.cc
index 39007c34258..dd8a2546691 100644
--- a/storage/innobase/btr/btr0defragment.cc
+++ b/storage/innobase/btr/btr0defragment.cc
@@ -338,8 +338,8 @@ btr_defragment_calc_n_recs_for_size(
 {
 	page_t* page = buf_block_get_frame(block);
 	ulint n_recs = 0;
-	ulint offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint* offsets = offsets_;
+	offset_t offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t* offsets = offsets_;
 	rec_offs_init(offsets_);
 	mem_heap_t* heap = NULL;
 	ulint size = 0;
diff --git a/storage/innobase/btr/btr0pcur.cc b/storage/innobase/btr/btr0pcur.cc
index cf82657a3bc..46549c13c3d 100644
--- a/storage/innobase/btr/btr0pcur.cc
+++ b/storage/innobase/btr/btr0pcur.cc
@@ -302,16 +302,21 @@ btr_pcur_restore_position_func(
 			if (cursor->rel_pos == BTR_PCUR_ON) {
 #ifdef UNIV_DEBUG
 				const rec_t*	rec;
-				const ulint*	offsets1;
-				const ulint*	offsets2;
+				offset_t	offsets1_[REC_OFFS_NORMAL_SIZE];
+				offset_t	offsets2_[REC_OFFS_NORMAL_SIZE];
+				offset_t*	offsets1 = offsets1_;
+				offset_t*	offsets2 = offsets2_;
 				rec = btr_pcur_get_rec(cursor);
 
+				rec_offs_init(offsets1_);
+				rec_offs_init(offsets2_);
+
 				heap = mem_heap_create(256);
 				offsets1 = rec_get_offsets(
-					cursor->old_rec, index, NULL, true,
+					cursor->old_rec, index, offsets1, true,
 					cursor->old_n_fields, &heap);
 				offsets2 = rec_get_offsets(
-					rec, index, NULL, true,
+					rec, index, offsets2, true,
 					cursor->old_n_fields, &heap);
 
 				ut_ad(!cmp_rec_rec(cursor->old_rec,
@@ -370,11 +375,13 @@ btr_pcur_restore_position_func(
 	ut_ad(cursor->rel_pos == BTR_PCUR_ON
 	      || cursor->rel_pos == BTR_PCUR_BEFORE
 	      || cursor->rel_pos == BTR_PCUR_AFTER);
+	offset_t offsets[REC_OFFS_NORMAL_SIZE];
+	rec_offs_init(offsets);
 	if (cursor->rel_pos == BTR_PCUR_ON
 	    && btr_pcur_is_on_user_rec(cursor)
 	    && !cmp_dtuple_rec(tuple, btr_pcur_get_rec(cursor),
 			       rec_get_offsets(btr_pcur_get_rec(cursor),
-					       index, NULL, true,
+					       index, offsets, true,
 					       ULINT_UNDEFINED, &heap))) {
 
 		/* We have to store the NEW value for the modify clock,
diff --git a/storage/innobase/btr/btr0scrub.cc b/storage/innobase/btr/btr0scrub.cc
index 975520220c0..b0d1c91e5d8 100644
--- a/storage/innobase/btr/btr0scrub.cc
+++ b/storage/innobase/btr/btr0scrub.cc
@@ -478,7 +478,7 @@ btr_pessimistic_scrub(
 	/* arguments to btr_page_split_and_insert */
 	mem_heap_t* heap = NULL;
 	dtuple_t* entry = NULL;
-	ulint* offsets = NULL;
+	offset_t* offsets = NULL;
 	ulint n_ext = 0;
 	ulint flags = BTR_MODIFY_TREE;
 
diff --git a/storage/innobase/btr/btr0sea.cc b/storage/innobase/btr/btr0sea.cc
index a19c67ac1fd..ee1eaaac8ea 100644
--- a/storage/innobase/btr/btr0sea.cc
+++ b/storage/innobase/btr/btr0sea.cc
@@ -97,7 +97,7 @@ static inline
 ulint
 rec_fold(
 	const rec_t*	rec,
-	const ulint*	offsets,
+	const offset_t*	offsets,
 	ulint		n_fields,
 	ulint		n_bytes,
 	index_id_t	tree_id)
@@ -669,7 +669,7 @@ btr_search_update_hash_ref(
 	    && (block->curr_n_bytes == info->n_bytes)
 	    && (block->curr_left_side == info->left_side)) {
 		mem_heap_t*	heap		= NULL;
-		ulint		offsets_[REC_OFFS_NORMAL_SIZE];
+		offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
 		rec_offs_init(offsets_);
 
 		rec = btr_cur_get_rec(cursor);
@@ -722,8 +722,8 @@ btr_search_check_guess(
 	ulint		match;
 	int		cmp;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	ibool		success		= FALSE;
 	rec_offs_init(offsets_);
 
@@ -1082,7 +1082,7 @@ void btr_search_drop_page_hash_index(buf_block_t* block)
 	ulint			i;
 	mem_heap_t*		heap;
 	const dict_index_t*	index;
-	ulint*			offsets;
+	offset_t*		offsets;
 	rw_lock_t*		latch;
 	btr_search_t*		info;
 
@@ -1337,8 +1337,8 @@ btr_search_build_page_hash_index(
 	const rec_t**	recs;
 	ulint		i;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 
 #ifdef MYSQL_INDEX_DISABLE_AHI
 	if (index->disable_ahi) return;
@@ -1642,7 +1642,7 @@ void btr_search_update_hash_on_delete(btr_cur_t* cursor)
 	const rec_t*	rec;
 	ulint		fold;
 	dict_index_t*	index;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
 	mem_heap_t*	heap		= NULL;
 	rec_offs_init(offsets_);
 
@@ -1797,8 +1797,8 @@ btr_search_update_hash_on_insert(btr_cur_t* cursor, rw_lock_t* ahi_latch)
 	ibool		left_side;
 	bool		locked		= false;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(ahi_latch == btr_get_search_latch(cursor->index));
@@ -1955,8 +1955,8 @@ btr_search_hash_table_validate(ulint hash_table_id)
 	ulint		i;
 	ulint		cell_count;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 
 	if (!btr_search_enabled) {
 		return(TRUE);
diff --git a/storage/innobase/buf/buf0buf.cc b/storage/innobase/buf/buf0buf.cc
index 6b46cc7097b..6f64709c9bb 100644
--- a/storage/innobase/buf/buf0buf.cc
+++ b/storage/innobase/buf/buf0buf.cc
@@ -103,6 +103,7 @@ struct set_numa_interleave_t
 					" policy to MPOL_INTERLEAVE: "
 					<< strerror(errno);
 			}
+			numa_bitmask_free(numa_mems_allowed);
 		}
 	}
 
@@ -130,29 +131,6 @@ struct set_numa_interleave_t
 #include "snappy-c.h"
 #endif
 
-inline void* aligned_malloc(size_t size, size_t align) {
-    void *result;
-#ifdef _MSC_VER
-    result = _aligned_malloc(size, align);
-#elif defined (HAVE_POSIX_MEMALIGN)
-    if(posix_memalign(&result, align, size)) {
-	    result = 0;
-    }
-#else
-    /* Use unaligned malloc as fallback */
-    result = malloc(size);
-#endif
-    return result;
-}
-
-inline void aligned_free(void *ptr) {
-#ifdef _MSC_VER
-        _aligned_free(ptr);
-#else
-      free(ptr);
-#endif
-}
-
 /*
 		IMPLEMENTATION OF THE BUFFER POOL
 		=================================
@@ -1663,6 +1641,7 @@ buf_chunk_init(
 				" buffer pool page frames to MPOL_INTERLEAVE"
 				" (error: " << strerror(errno) << ").";
 		}
+		numa_bitmask_free(numa_mems_allowed);
 	}
 #endif /* HAVE_LIBNUMA */
 
@@ -2274,8 +2253,8 @@ buf_page_realloc(
 		ut_d(block->page.in_page_hash = FALSE);
 		ulint	fold = block->page.id.fold();
 		ut_ad(fold == new_block->page.id.fold());
-		HASH_DELETE(buf_page_t, hash, buf_pool->page_hash, fold, (&block->page));
-		HASH_INSERT(buf_page_t, hash, buf_pool->page_hash, fold, (&new_block->page));
+		HASH_REPLACE(buf_page_t, hash, buf_pool->page_hash, fold,
+			     &block->page, &new_block->page);
 
 		ut_ad(new_block->page.in_page_hash);
 
@@ -3393,8 +3372,8 @@ buf_relocate(
 	/* relocate buf_pool->page_hash */
 	ulint	fold = bpage->id.fold();
 	ut_ad(fold == dpage->id.fold());
-	HASH_DELETE(buf_page_t, hash, buf_pool->page_hash, fold, bpage);
-	HASH_INSERT(buf_page_t, hash, buf_pool->page_hash, fold, dpage);
+	HASH_REPLACE(buf_page_t, hash, buf_pool->page_hash, fold, bpage,
+		     dpage);
 }
 
 /** Hazard Pointer implementation. */
diff --git a/storage/innobase/buf/buf0dblwr.cc b/storage/innobase/buf/buf0dblwr.cc
index 3f998165ccc..55ce17513c2 100644
--- a/storage/innobase/buf/buf0dblwr.cc
+++ b/storage/innobase/buf/buf0dblwr.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1995, 2017, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2013, 2019, MariaDB Corporation.
+Copyright (c) 2013, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -989,6 +989,7 @@ try_again:
 		int64_t	sig_count = os_event_reset(buf_dblwr->b_event);
 		mutex_exit(&buf_dblwr->mutex);
 
+		os_aio_simulated_wake_handler_threads();
 		os_event_wait_low(buf_dblwr->b_event, sig_count);
 		goto try_again;
 	}
@@ -1118,6 +1119,7 @@ try_again:
 		checkpoint. */
 		int64_t	sig_count = os_event_reset(buf_dblwr->b_event);
 		mutex_exit(&buf_dblwr->mutex);
+		os_aio_simulated_wake_handler_threads();
 
 		os_event_wait_low(buf_dblwr->b_event, sig_count);
 		goto try_again;
diff --git a/storage/innobase/buf/buf0lru.cc b/storage/innobase/buf/buf0lru.cc
index cfe3f9a6bcb..17583eb3399 100644
--- a/storage/innobase/buf/buf0lru.cc
+++ b/storage/innobase/buf/buf0lru.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, 2019, MariaDB Corporation.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -59,6 +59,7 @@ static const ulint BUF_LRU_OLD_TOLERANCE = 20;
 @see buf_LRU_old_adjust_len */
 #define BUF_LRU_NON_OLD_MIN_LEN	5
 
+#ifdef BTR_CUR_HASH_ADAPT
 /** When dropping the search hash index entries before deleting an ibd
 file, we build a local array of pages belonging to that tablespace
 in the buffer pool. Following is the size of that array.
@@ -67,6 +68,7 @@ flush_list when dropping a table. This is to ensure that other threads
 are not blocked for extended period of time when using very large
 buffer pools. */
 static const ulint BUF_LRU_DROP_SEARCH_SIZE = 1024;
+#endif /* BTR_CUR_HASH_ADAPT */
 
 /** We scan these many blocks when looking for a clean page to evict
 during LRU eviction. */
@@ -376,7 +378,6 @@ drop_ahi:
 
 	return true;
 }
-#endif /* BTR_CUR_HASH_ADAPT */
 
 /******************************************************************//**
 While flushing (or removing dirty) pages from a tablespace we don't
@@ -465,6 +466,7 @@ buf_flush_try_yield(
 
 	return(false);
 }
+#endif /* BTR_CUR_HASH_ADAPT */
 
 /******************************************************************//**
 Removes a single page from a given tablespace inside a specific
@@ -640,6 +642,7 @@ rescan:
 			goto rescan;
 		}
 
+#ifdef BTR_CUR_HASH_ADAPT
 		++processed;
 
 		/* Yield if we have hogged the CPU and mutexes for too long. */
@@ -649,6 +652,7 @@ rescan:
 
 			processed = 0;
 		}
+#endif /* BTR_CUR_HASH_ADAPT */
 
 		/* The check for trx is interrupted is expensive, we want
 		to check every N iterations. */
diff --git a/storage/innobase/dict/dict0crea.cc b/storage/innobase/dict/dict0crea.cc
index c8b16c25b68..581be6a85c1 100644
--- a/storage/innobase/dict/dict0crea.cc
+++ b/storage/innobase/dict/dict0crea.cc
@@ -2345,49 +2345,6 @@ dict_replace_tablespace_in_dictionary(
 	return(error);
 }
 
-/** Delete records from SYS_TABLESPACES and SYS_DATAFILES associated
-with a particular tablespace ID.
-@param[in]	space	Tablespace ID
-@param[in,out]	trx	Current transaction
-@return DB_SUCCESS if OK, dberr_t if the operation failed */
-
-dberr_t
-dict_delete_tablespace_and_datafiles(
-	ulint		space,
-	trx_t*		trx)
-{
-	dberr_t		err = DB_SUCCESS;
-
-	ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_X));
-	ut_ad(mutex_own(&dict_sys->mutex));
-	ut_ad(srv_sys_tablespaces_open);
-
-	trx->op_info = "delete tablespace and datafiles from dictionary";
-
-	pars_info_t*	info = pars_info_create();
-	ut_a(!is_system_tablespace(space));
-	pars_info_add_int4_literal(info, "space", space);
-
-	err = que_eval_sql(info,
-			   "PROCEDURE P () IS\n"
-			   "BEGIN\n"
-			   "DELETE FROM SYS_TABLESPACES\n"
-			   "WHERE SPACE = :space;\n"
-			   "DELETE FROM SYS_DATAFILES\n"
-			   "WHERE SPACE = :space;\n"
-			   "END;\n",
-			   FALSE, trx);
-
-	if (err != DB_SUCCESS) {
-		ib::warn() << "Could not delete space_id "
-			<< space << " from data dictionary";
-	}
-
-	trx->op_info = "";
-
-	return(err);
-}
-
 /** Assign a new table ID and put it into the table cache and the transaction.
 @param[in,out]	table	Table that needs an ID
 @param[in,out]	trx	Transaction */
diff --git a/storage/innobase/dict/dict0dict.cc b/storage/innobase/dict/dict0dict.cc
index 24dc3890ff9..eb7280b8673 100644
--- a/storage/innobase/dict/dict0dict.cc
+++ b/storage/innobase/dict/dict0dict.cc
@@ -2,7 +2,7 @@
 
 Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
 Copyright (c) 2012, Facebook Inc.
-Copyright (c) 2013, 2019, MariaDB Corporation.
+Copyright (c) 2013, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -523,7 +523,10 @@ dict_table_close(
 
 		mutex_exit(&dict_sys->mutex);
 
-		if (drop_aborted) {
+		/* dict_table_try_drop_aborted() can generate undo logs.
+		So it should be avoided after shutdown of background
+		threads */
+		if (drop_aborted && !srv_undo_sources) {
 			dict_table_try_drop_aborted(NULL, table_id, 0);
 		}
 	}
diff --git a/storage/innobase/dict/dict0mem.cc b/storage/innobase/dict/dict0mem.cc
index 567f39d67a1..425aa6c8270 100644
--- a/storage/innobase/dict/dict0mem.cc
+++ b/storage/innobase/dict/dict0mem.cc
@@ -1453,7 +1453,7 @@ void dict_table_t::rollback_instant(unsigned n)
 bool
 dict_index_t::vers_history_row(
 	const rec_t*		rec,
-	const ulint*		offsets)
+	const offset_t*		offsets)
 {
 	ut_ad(is_primary());
 
@@ -1484,8 +1484,8 @@ dict_index_t::vers_history_row(
 	bool error = false;
 	mem_heap_t* heap = NULL;
 	dict_index_t* clust_index = NULL;
-	ulint offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint* offsets = offsets_;
+	offset_t offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t* offsets = offsets_;
 	rec_offs_init(offsets_);
 
 	mtr_t mtr;
diff --git a/storage/innobase/dict/dict0stats.cc b/storage/innobase/dict/dict0stats.cc
index faf6483e983..f60d574d3b9 100644
--- a/storage/innobase/dict/dict0stats.cc
+++ b/storage/innobase/dict/dict0stats.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2009, 2019, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2015, 2019, MariaDB Corporation.
+Copyright (c) 2015, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -1014,8 +1014,8 @@ dict_stats_analyze_index_level(
 	bool		prev_rec_is_copied;
 	byte*		prev_rec_buf = NULL;
 	ulint		prev_rec_buf_size = 0;
-	ulint*		rec_offsets;
-	ulint*		prev_rec_offsets;
+	offset_t*	rec_offsets;
+	offset_t*	prev_rec_offsets;
 	ulint		i;
 
 	DEBUG_PRINTF("    %s(table=%s, index=%s, level=" ULINTPF ")\n",
@@ -1036,9 +1036,9 @@ dict_stats_analyze_index_level(
 	i = (REC_OFFS_HEADER_SIZE + 1 + 1) + n_uniq;
 
 	heap = mem_heap_create((2 * sizeof *rec_offsets) * i);
-	rec_offsets = static_cast<ulint*>(
+	rec_offsets = static_cast<offset_t*>(
 		mem_heap_alloc(heap, i * sizeof *rec_offsets));
-	prev_rec_offsets = static_cast<ulint*>(
+	prev_rec_offsets = static_cast<offset_t*>(
 		mem_heap_alloc(heap, i * sizeof *prev_rec_offsets));
 	rec_offs_set_n_alloc(rec_offsets, i);
 	rec_offs_set_n_alloc(prev_rec_offsets, i);
@@ -1169,13 +1169,9 @@ dict_stats_analyze_index_level(
 				prev_rec, index, prev_rec_offsets, !level,
 				n_uniq, &heap);
 
-			cmp_rec_rec_with_match(rec,
-					       prev_rec,
-					       rec_offsets,
-					       prev_rec_offsets,
-					       index,
-					       FALSE,
-					       &matched_fields);
+			cmp_rec_rec(prev_rec, rec,
+				    prev_rec_offsets, rec_offsets, index,
+				    false, &matched_fields);
 
 			for (i = matched_fields; i < n_uniq; i++) {
 
@@ -1331,11 +1327,11 @@ to the number of externally stored pages which were encountered
 @return offsets1 or offsets2 (the offsets of *out_rec),
 or NULL if the page is empty and does not contain user records. */
 UNIV_INLINE
-ulint*
+offset_t*
 dict_stats_scan_page(
 	const rec_t**		out_rec,
-	ulint*			offsets1,
-	ulint*			offsets2,
+	offset_t*		offsets1,
+	offset_t*		offsets2,
 	const dict_index_t*	index,
 	const page_t*		page,
 	ulint			n_prefix,
@@ -1343,8 +1339,8 @@ dict_stats_scan_page(
 	ib_uint64_t*		n_diff,
 	ib_uint64_t*		n_external_pages)
 {
-	ulint*		offsets_rec		= offsets1;
-	ulint*		offsets_next_rec	= offsets2;
+	offset_t*	offsets_rec		= offsets1;
+	offset_t*	offsets_next_rec	= offsets2;
 	const rec_t*	rec;
 	const rec_t*	next_rec;
 	/* A dummy heap, to be passed to rec_get_offsets().
@@ -1395,9 +1391,8 @@ dict_stats_scan_page(
 
 		/* check whether rec != next_rec when looking at
 		the first n_prefix fields */
-		cmp_rec_rec_with_match(rec, next_rec,
-				       offsets_rec, offsets_next_rec,
-				       index, FALSE, &matched_fields);
+		cmp_rec_rec(rec, next_rec, offsets_rec, offsets_next_rec,
+			    index, false, &matched_fields);
 
 		if (matched_fields < n_prefix) {
 			/* rec != next_rec, => rec is non-boring */
@@ -1410,23 +1405,16 @@ dict_stats_scan_page(
 		}
 
 		rec = next_rec;
-		{
-			/* Assign offsets_rec = offsets_next_rec
-			so that offsets_rec matches with rec which
-			was just assigned rec = next_rec above.
-			Also need to point offsets_next_rec to the
-			place where offsets_rec was pointing before
-			because we have just 2 placeholders where
-			data is actually stored:
-			offsets1 and offsets2 and we
-			are using them in circular fashion
-			(offsets[_next]_rec are just pointers to
-			those placeholders). */
-			ulint*	offsets_tmp;
-			offsets_tmp = offsets_rec;
-			offsets_rec = offsets_next_rec;
-			offsets_next_rec = offsets_tmp;
-		}
+		/* Assign offsets_rec = offsets_next_rec so that
+		offsets_rec matches with rec which was just assigned
+		rec = next_rec above.  Also need to point
+		offsets_next_rec to the place where offsets_rec was
+		pointing before because we have just 2 placeholders
+		where data is actually stored: offsets1 and offsets2
+		and we are using them in circular fashion
+		(offsets[_next]_rec are just pointers to those
+		placeholders). */
+		std::swap(offsets_rec, offsets_next_rec);
 
 		if (should_count_external_pages) {
 			*n_external_pages += btr_rec_get_externally_stored_len(
@@ -1465,9 +1453,9 @@ dict_stats_analyze_index_below_cur(
 	const page_t*	page;
 	mem_heap_t*	heap;
 	const rec_t*	rec;
-	ulint*		offsets1;
-	ulint*		offsets2;
-	ulint*		offsets_rec;
+	offset_t*	offsets1;
+	offset_t*	offsets2;
+	offset_t*	offsets_rec;
 	ulint		size;
 	mtr_t		mtr;
 
@@ -1485,10 +1473,10 @@ dict_stats_analyze_index_below_cur(
 
 	heap = mem_heap_create(size * (sizeof *offsets1 + sizeof *offsets2));
 
-	offsets1 = static_cast<ulint*>(mem_heap_alloc(
+	offsets1 = static_cast<offset_t*>(mem_heap_alloc(
 			heap, size * sizeof *offsets1));
 
-	offsets2 = static_cast<ulint*>(mem_heap_alloc(
+	offsets2 = static_cast<offset_t*>(mem_heap_alloc(
 			heap, size * sizeof *offsets2));
 
 	rec_offs_set_n_alloc(offsets1, size);
@@ -1746,8 +1734,8 @@ dict_stats_analyze_index_for_n_prefix(
 		ut_a(left <= right);
 		ut_a(right <= last_idx_on_level);
 
-		const ulint	rnd = right == left ? 0 :
-			ut_rnd_gen_ulint() % (right - left);
+		const ulint	rnd = ut_rnd_interval(
+			static_cast<ulint>(right - left));
 
 		const ib_uint64_t	dive_below_idx
 			= boundaries->at(static_cast<unsigned>(left + rnd));
diff --git a/storage/innobase/eval/eval0eval.cc b/storage/innobase/eval/eval0eval.cc
index 577157d2eb9..97540d00198 100644
--- a/storage/innobase/eval/eval0eval.cc
+++ b/storage/innobase/eval/eval0eval.cc
@@ -30,9 +30,6 @@ Created 12/29/1997 Heikki Tuuri
 #include "row0sel.h"
 #include "rem0cmp.h"
 
-/** The RND function seed */
-static ulint	eval_rnd	= 128367121;
-
 /** Dummy adress used when we should allocate a buffer of size 0 in
 eval_node_alloc_val_buf */
 
@@ -310,120 +307,18 @@ eval_aggregate(
 /*===========*/
 	func_node_t*	node)	/*!< in: aggregate operation node */
 {
-	que_node_t*	arg;
 	lint		val;
-	lint		arg_val;
-	int		func;
 
 	ut_ad(que_node_get_type(node) == QUE_NODE_FUNC);
 
 	val = eval_node_get_int_val(node);
 
-	func = node->func;
-
-	if (func == PARS_COUNT_TOKEN) {
-
-		val = val + 1;
-	} else {
-		ut_ad(func == PARS_SUM_TOKEN);
-
-		arg = node->args;
-		arg_val = eval_node_get_int_val(arg);
-
-		val = val + arg_val;
-	}
-
+	ut_a(node->func == PARS_COUNT_TOKEN);
+	val = val + 1;
 	eval_node_set_int_val(node, val);
 }
 
 /*****************************************************************//**
-Evaluates a predefined function node where the function is not relevant
-in benchmarks. */
-static
-void
-eval_predefined_2(
-/*==============*/
-	func_node_t*	func_node)	/*!< in: predefined function node */
-{
-	que_node_t*	arg;
-	que_node_t*	arg1;
-	que_node_t*	arg2 = 0; /* remove warning (??? bug ???) */
-	lint		int_val;
-	byte*		data;
-	ulint		len1;
-	ulint		len2;
-	int		func;
-	ulint		i;
-
-	ut_ad(que_node_get_type(func_node) == QUE_NODE_FUNC);
-
-	arg1 = func_node->args;
-
-	if (arg1) {
-		arg2 = que_node_get_next(arg1);
-	}
-
-	func = func_node->func;
-
-	if (func == PARS_PRINTF_TOKEN) {
-
-		arg = arg1;
-
-		while (arg) {
-			dfield_print(que_node_get_val(arg));
-
-			arg = que_node_get_next(arg);
-		}
-
-		putc('\n', stderr);
-
-	} else if (func == PARS_ASSERT_TOKEN) {
-
-		if (!eval_node_get_ibool_val(arg1)) {
-			fputs("SQL assertion fails in a stored procedure!\n",
-			      stderr);
-		}
-
-		ut_a(eval_node_get_ibool_val(arg1));
-
-		/* This function, or more precisely, a debug procedure,
-		returns no value */
-
-	} else if (func == PARS_RND_TOKEN) {
-
-		len1 = (ulint) eval_node_get_int_val(arg1);
-		len2 = (ulint) eval_node_get_int_val(arg2);
-
-		ut_ad(len2 >= len1);
-
-		if (len2 > len1) {
-			int_val = (lint) (len1
-					  + (eval_rnd % (len2 - len1 + 1)));
-		} else {
-			int_val = (lint) len1;
-		}
-
-		eval_rnd = ut_rnd_gen_next_ulint(eval_rnd);
-
-		eval_node_set_int_val(func_node, int_val);
-
-	} else if (func == PARS_RND_STR_TOKEN) {
-
-		len1 = (ulint) eval_node_get_int_val(arg1);
-
-		data = eval_node_ensure_val_buf(func_node, len1);
-
-		for (i = 0; i < len1; i++) {
-			data[i] = (byte)(97 + (eval_rnd % 3));
-
-			eval_rnd = ut_rnd_gen_next_ulint(eval_rnd);
-		}
-	} else {
-		ut_error;
-	}
-}
-
-/*****************************************************************//**
 Evaluates a notfound-function node. */
 UNIV_INLINE
 void
@@ -494,46 +389,6 @@ eval_substr(
 }
 
 /*****************************************************************//**
-Evaluates a replstr-procedure node. */
-static
-void
-eval_replstr(
-/*=========*/
-	func_node_t*	func_node)	/*!< in: function node */
-{
-	que_node_t*	arg1;
-	que_node_t*	arg2;
-	que_node_t*	arg3;
-	que_node_t*	arg4;
-	byte*		str1;
-	byte*		str2;
-	ulint		len1;
-	ulint		len2;
-
-	arg1 = func_node->args;
-	arg2 = que_node_get_next(arg1);
-
-	ut_ad(que_node_get_type(arg1) == QUE_NODE_SYMBOL);
-
-	arg3 = que_node_get_next(arg2);
-	arg4 = que_node_get_next(arg3);
-
-	str1 = static_cast<byte*>(dfield_get_data(que_node_get_val(arg1)));
-	str2 = static_cast<byte*>(dfield_get_data(que_node_get_val(arg2)));
-
-	len1 = (ulint) eval_node_get_int_val(arg3);
-	len2 = (ulint) eval_node_get_int_val(arg4);
-
-	if ((dfield_get_len(que_node_get_val(arg1)) < len1 + len2)
-	    || (dfield_get_len(que_node_get_val(arg2)) < len2)) {
-
-		ut_error;
-	}
-
-	ut_memcpy(str1 + len1, str2, len2);
-}
-
-/*****************************************************************//**
 Evaluates an instr-function node. */
 static
 void
@@ -607,44 +462,6 @@ match_found:
 
 /*****************************************************************//**
 Evaluates a predefined function node. */
-UNIV_INLINE
-void
-eval_binary_to_number(
-/*==================*/
-	func_node_t*	func_node)	/*!< in: function node */
-{
-	que_node_t*	arg1;
-	dfield_t*	dfield;
-	byte*		str1;
-	byte*		str2;
-	ulint		len1;
-	ulint		int_val;
-
-	arg1 = func_node->args;
-
-	dfield = que_node_get_val(arg1);
-
-	str1 = static_cast<byte*>(dfield_get_data(dfield));
-	len1 = dfield_get_len(dfield);
-
-	if (len1 > 4) {
-		ut_error;
-	}
-
-	if (len1 == 4) {
-		str2 = str1;
-	} else {
-		int_val = 0;
-		str2 = (byte*) &int_val;
-
-		ut_memcpy(str2 + (4 - len1), str1, len1);
-	}
-
-	eval_node_copy_and_alloc_val(func_node, str2, 4);
-}
-
-/*****************************************************************//**
-Evaluates a predefined function node. */
 static
 void
 eval_concat(
@@ -734,95 +551,12 @@ eval_to_binary(
 }
 
 /*****************************************************************//**
-Evaluates a predefined function node. */
-UNIV_INLINE
-void
-eval_predefined(
-/*============*/
-	func_node_t*	func_node)	/*!< in: function node */
+Evaluate LENGTH(). */
+inline void eval_length(func_node_t* func_node)
 {
-	que_node_t*	arg1;
-	lint		int_val;
-	byte*		data;
-	int		func;
-
-	func = func_node->func;
-
-	arg1 = func_node->args;
-
-	if (func == PARS_LENGTH_TOKEN) {
-
-		int_val = (lint) dfield_get_len(que_node_get_val(arg1));
-
-	} else if (func == PARS_TO_CHAR_TOKEN) {
-
-		/* Convert number to character string as a
-		signed decimal integer. */
-
-		ulint	uint_val;
-		int	int_len;
-
-		int_val = eval_node_get_int_val(arg1);
-
-		/* Determine the length of the string. */
-
-		if (int_val == 0) {
-			int_len = 1; /* the number 0 occupies 1 byte */
-		} else {
-			int_len = 0;
-			if (int_val < 0) {
-				uint_val = ((ulint) -int_val - 1) + 1;
-				int_len++; /* reserve space for minus sign */
-			} else {
-				uint_val = (ulint) int_val;
-			}
-			for (; uint_val > 0; int_len++) {
-				uint_val /= 10;
-			}
-		}
-
-		/* allocate the string */
-		data = eval_node_ensure_val_buf(func_node, ulint(int_len) + 1);
-
-		/* add terminating NUL character */
-		data[int_len] = 0;
-
-		/* convert the number */
-
-		if (int_val == 0) {
-			data[0] = '0';
-		} else {
-			int tmp;
-			if (int_val < 0) {
-				data[0] = '-'; /* preceding minus sign */
-				uint_val = ((ulint) -int_val - 1) + 1;
-			} else {
-				uint_val = (ulint) int_val;
-			}
-			for (tmp = int_len; uint_val > 0; uint_val /= 10) {
-				data[--tmp] = (byte)
-					('0' + (byte)(uint_val % 10));
-			}
-		}
-
-		dfield_set_len(que_node_get_val(func_node), ulint(int_len));
-
-		return;
-
-	} else if (func == PARS_TO_NUMBER_TOKEN) {
-
-		int_val = atoi((char*)
-			       dfield_get_data(que_node_get_val(arg1)));
-
-	} else if (func == PARS_SYSDATE_TOKEN) {
-		int_val = (lint) time(NULL);
-	} else {
-		eval_predefined_2(func_node);
-
-		return;
-	}
-
-	eval_node_set_int_val(func_node, int_val);
+	eval_node_set_int_val(func_node,
+			      dfield_get_len(que_node_get_val
+					     (func_node->args)));
 }
 
 /*****************************************************************//**
@@ -851,8 +585,7 @@ eval_func(
 
 		if (dfield_is_null(que_node_get_val(arg))
 		    && (fclass != PARS_FUNC_CMP)
-		    && (func != PARS_NOTFOUND_TOKEN)
-		    && (func != PARS_PRINTF_TOKEN)) {
+		    && (func != PARS_NOTFOUND_TOKEN)) {
 			ut_error;
 		}
 
@@ -877,24 +610,20 @@ eval_func(
 		case PARS_SUBSTR_TOKEN:
 			eval_substr(func_node);
 			return;
-		case PARS_REPLSTR_TOKEN:
-			eval_replstr(func_node);
-			return;
 		case PARS_INSTR_TOKEN:
 			eval_instr(func_node);
 			return;
-		case PARS_BINARY_TO_NUMBER_TOKEN:
-			eval_binary_to_number(func_node);
-			return;
 		case PARS_CONCAT_TOKEN:
 			eval_concat(func_node);
 			return;
 		case PARS_TO_BINARY_TOKEN:
 			eval_to_binary(func_node);
 			return;
-		default:
-			eval_predefined(func_node);
+		case PARS_LENGTH_TOKEN:
+			eval_length(func_node);
 			return;
+		default:
+			ut_error;
 		}
 	case PARS_FUNC_LOGICAL:
 		eval_logical(func_node);
diff --git a/storage/innobase/fil/fil0crypt.cc b/storage/innobase/fil/fil0crypt.cc
index 0375432b001..496f428c1ba 100644
--- a/storage/innobase/fil/fil0crypt.cc
+++ b/storage/innobase/fil/fil0crypt.cc
@@ -1,6 +1,6 @@
 /*****************************************************************************
 Copyright (C) 2013, 2015, Google Inc. All Rights Reserved.
-Copyright (c) 2014, 2019, MariaDB Corporation.
+Copyright (c) 2014, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -654,51 +654,10 @@ fil_space_encrypt(
 		return (src_frame);
 	}
 
-	fil_space_crypt_t* crypt_data = space->crypt_data;
-	const page_size_t	page_size(space->flags);
 	ut_ad(space->pending_io());
-	byte* tmp = fil_encrypt_buf(crypt_data, space->id, offset, lsn,
-				    src_frame, page_size, dst_frame);
-
-#ifdef UNIV_DEBUG
-	if (tmp) {
-		/* Verify that encrypted buffer is not corrupted */
-		dberr_t err = DB_SUCCESS;
-		byte* src = src_frame;
-		bool page_compressed_encrypted = (mach_read_from_2(tmp+FIL_PAGE_TYPE) == FIL_PAGE_PAGE_COMPRESSED_ENCRYPTED);
-		byte uncomp_mem[UNIV_PAGE_SIZE_MAX];
-		byte tmp_mem[UNIV_PAGE_SIZE_MAX];
-
-		if (page_compressed_encrypted) {
-			memcpy(uncomp_mem, src, srv_page_size);
-			ulint unzipped1 = fil_page_decompress(
-				tmp_mem, uncomp_mem);
-			ut_ad(unzipped1);
-			if (unzipped1 != srv_page_size) {
-				src = uncomp_mem;
-			}
-		}
-
-		ut_ad(!buf_page_is_corrupted(true, src, page_size, space));
-		ut_ad(fil_space_decrypt(crypt_data, tmp_mem, page_size, tmp,
-					&err));
-		ut_ad(err == DB_SUCCESS);
-
-		/* Need to decompress the page if it was also compressed */
-		if (page_compressed_encrypted) {
-			byte buf[UNIV_PAGE_SIZE_MAX];
-			memcpy(buf, tmp_mem, srv_page_size);
-			ulint unzipped2 = fil_page_decompress(tmp_mem, buf);
-			ut_ad(unzipped2);
-		}
-
-		memcpy(tmp_mem + FIL_PAGE_FILE_FLUSH_LSN_OR_KEY_VERSION,
-		       src + FIL_PAGE_FILE_FLUSH_LSN_OR_KEY_VERSION, 8);
-		ut_ad(!memcmp(src, tmp_mem, page_size.physical()));
-	}
-#endif /* UNIV_DEBUG */
-
-	return tmp;
+	return fil_encrypt_buf(space->crypt_data, space->id, offset, lsn,
+			       src_frame, page_size_t(space->flags),
+			       dst_frame);
 }
 
 /** Decrypt a page.
@@ -2335,7 +2294,7 @@ static void fil_crypt_rotation_list_fill()
 			}
 		}
 
-		UT_LIST_ADD_LAST(fil_system.rotation_list, space);
+		fil_system.rotation_list.push_back(*space);
 	}
 }
 
diff --git a/storage/innobase/fil/fil0fil.cc b/storage/innobase/fil/fil0fil.cc
index e22b1c4e314..434490c002c 100644
--- a/storage/innobase/fil/fil0fil.cc
+++ b/storage/innobase/fil/fil0fil.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1995, 2017, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2014, 2019, MariaDB Corporation.
+Copyright (c) 2014, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -155,7 +155,7 @@ current working directory ".", but in the MySQL Embedded Server Library
 it is an absolute path. */
 const char*	fil_path_to_mysql_datadir;
 
-/** Common InnoDB file extentions */
+/** Common InnoDB file extensions */
 const char* dot_ext[] = { "", ".ibd", ".isl", ".cfg" };
 
 /** The number of fsyncs done to the log */
@@ -861,9 +861,7 @@ skip_flush:
 			if (space->is_in_unflushed_spaces()
 			    && fil_space_is_flushed(space)) {
 
-				UT_LIST_REMOVE(
-					fil_system.unflushed_spaces,
-					space);
+				fil_system.unflushed_spaces.remove(*space);
 			}
 		}
 
@@ -1165,7 +1163,7 @@ fil_node_close_to_free(
 		} else if (space->is_in_unflushed_spaces()
 			   && fil_space_is_flushed(space)) {
 
-			UT_LIST_REMOVE(fil_system.unflushed_spaces, space);
+			fil_system.unflushed_spaces.remove(*space);
 		}
 
 		node->close();
@@ -1188,13 +1186,11 @@ fil_space_detach(
 	if (space->is_in_unflushed_spaces()) {
 
 		ut_ad(!fil_buffering_disabled(space));
-
-		UT_LIST_REMOVE(fil_system.unflushed_spaces, space);
+		fil_system.unflushed_spaces.remove(*space);
 	}
 
 	if (space->is_in_rotation_list()) {
-
-		UT_LIST_REMOVE(fil_system.rotation_list, space);
+		fil_system.rotation_list.remove(*space);
 	}
 
 	UT_LIST_REMOVE(fil_system.space_list, space);
@@ -1409,7 +1405,7 @@ fil_space_create(
 		    srv_encrypt_tables)) {
 		/* Key rotation is not enabled, need to inform background
 		encryption threads. */
-		UT_LIST_ADD_LAST(fil_system.rotation_list, space);
+		fil_system.rotation_list.push_back(*space);
 		mutex_exit(&fil_system.mutex);
 		os_event_set(fil_crypt_threads_event);
 	} else {
@@ -1707,7 +1703,7 @@ void fil_system_t::close()
 {
 	ut_ad(this == &fil_system);
 	ut_a(!UT_LIST_GET_LEN(LRU));
-	ut_a(!UT_LIST_GET_LEN(unflushed_spaces));
+	ut_a(unflushed_spaces.empty());
 	ut_a(!UT_LIST_GET_LEN(space_list));
 	ut_ad(!sys_space);
 	ut_ad(!temp_space);
@@ -4088,8 +4084,8 @@ fil_node_complete_io(fil_node_t* node, const IORequest& type)
 			node->needs_flush = true;
 
 			if (!node->space->is_in_unflushed_spaces()) {
-				UT_LIST_ADD_FIRST(fil_system.unflushed_spaces,
-						  node->space);
+				fil_system.unflushed_spaces.push_front(
+					*node->space);
 			}
 		}
 	}
@@ -4573,7 +4569,6 @@ void
 fil_flush_file_spaces(
 	fil_type_t	purpose)
 {
-	fil_space_t*	space;
 	ulint*		space_ids;
 	ulint		n_space_ids;
 
@@ -4581,30 +4576,25 @@ fil_flush_file_spaces(
 
 	mutex_enter(&fil_system.mutex);
 
-	n_space_ids = UT_LIST_GET_LEN(fil_system.unflushed_spaces);
+	n_space_ids = fil_system.unflushed_spaces.size();
 	if (n_space_ids == 0) {
 
 		mutex_exit(&fil_system.mutex);
 		return;
 	}
 
-	/* Assemble a list of space ids to flush.  Previously, we
-	traversed fil_system.unflushed_spaces and called UT_LIST_GET_NEXT()
-	on a space that was just removed from the list by fil_flush().
-	Thus, the space could be dropped and the memory overwritten. */
 	space_ids = static_cast<ulint*>(
 		ut_malloc_nokey(n_space_ids * sizeof(*space_ids)));
 
 	n_space_ids = 0;
 
-	for (space = UT_LIST_GET_FIRST(fil_system.unflushed_spaces);
-	     space;
-	     space = UT_LIST_GET_NEXT(unflushed_spaces, space)) {
+	for (intrusive::list<fil_space_t, unflushed_spaces_tag_t>::iterator it
+	     = fil_system.unflushed_spaces.begin(),
+	     end = fil_system.unflushed_spaces.end();
+	     it != end; ++it) {
 
-		if (space->purpose == purpose
-		    && !space->is_stopping()) {
-
-			space_ids[n_space_ids++] = space->id;
+		if (it->purpose == purpose && !it->is_stopping()) {
+			space_ids[n_space_ids++] = it->id;
 		}
 	}
 
@@ -5222,8 +5212,8 @@ fil_space_remove_from_keyrotation(fil_space_t* space)
 	ut_ad(space);
 
 	if (!space->referenced() && space->is_in_rotation_list()) {
-		ut_a(UT_LIST_GET_LEN(fil_system.rotation_list) > 0);
-		UT_LIST_REMOVE(fil_system.rotation_list, space);
+		ut_a(!fil_system.rotation_list.empty());
+		fil_system.rotation_list.remove(*space);
 	}
 }
 
@@ -5239,53 +5229,45 @@ If NULL, use the first fil_space_t on fil_system.space_list.
 @param[in]	key_version	key version of the key state thread
 @return pointer to the next fil_space_t.
 @retval NULL if this was the last */
-fil_space_t*
-fil_system_t::keyrotate_next(
-	fil_space_t*	prev_space,
-	bool		recheck,
-	uint		key_version)
+fil_space_t *fil_system_t::keyrotate_next(fil_space_t *prev_space,
+                                          bool recheck, uint key_version)
 {
-	mutex_enter(&fil_system.mutex);
+  mutex_enter(&fil_system.mutex);
 
-	/* If one of the encryption threads already started the encryption
-	of the table then don't remove the unencrypted spaces from
-	rotation list
+  /* If one of the encryption threads already started the encryption
+  of the table then don't remove the unencrypted spaces from rotation list
 
-	If there is a change in innodb_encrypt_tables variables value then
-	don't remove the last processed tablespace from the rotation list. */
-	const bool remove = ((!recheck || prev_space->crypt_data)
-			     && (!key_version == !srv_encrypt_tables));
+  If there is a change in innodb_encrypt_tables variables value then
+  don't remove the last processed tablespace from the rotation list. */
+  const bool remove= (!recheck || prev_space->crypt_data) &&
+                     !key_version == !srv_encrypt_tables;
+  intrusive::list<fil_space_t, rotation_list_tag_t>::iterator it=
+      prev_space == NULL ? fil_system.rotation_list.end() : prev_space;
 
-	fil_space_t* space = prev_space;
+  if (it == fil_system.rotation_list.end())
+    it= fil_system.rotation_list.begin();
+  else
+  {
+    /* Move on to the next fil_space_t */
+    prev_space->release();
 
-	if (prev_space == NULL) {
-		space = UT_LIST_GET_FIRST(fil_system.rotation_list);
+    ++it;
 
-		/* We can trust that space is not NULL because we
-		checked list length above */
-	} else {
-		/* Move on to the next fil_space_t */
-		space->release();
+    while (it != fil_system.rotation_list.end() &&
+           (UT_LIST_GET_LEN(it->chain) == 0 || it->is_stopping()))
+      ++it;
 
-		space = UT_LIST_GET_NEXT(rotation_list, space);
+    if (remove)
+      fil_space_remove_from_keyrotation(prev_space);
+  }
 
-		while (space != NULL
-		       && (UT_LIST_GET_LEN(space->chain) == 0
-			   || space->is_stopping())) {
-			space = UT_LIST_GET_NEXT(rotation_list, space);
-		}
+  fil_space_t *space= it == fil_system.rotation_list.end() ? NULL : &*it;
 
-		if (remove) {
-			fil_space_remove_from_keyrotation(prev_space);
-		}
-	}
-
-	if (space != NULL) {
-		space->acquire();
-	}
+  if (space)
+    space->acquire();
 
-	mutex_exit(&fil_system.mutex);
-	return(space);
+  mutex_exit(&fil_system.mutex);
+  return space;
 }
 
 /** Determine the block size of the data file.
@@ -5363,18 +5345,21 @@ fil_space_set_punch_hole(
 
 /** Checks that this tablespace in a list of unflushed tablespaces.
 @return true if in a list */
-bool fil_space_t::is_in_unflushed_spaces() const {
-	ut_ad(mutex_own(&fil_system.mutex));
+bool fil_space_t::is_in_unflushed_spaces() const
+{
+  ut_ad(mutex_own(&fil_system.mutex));
 
-	return fil_system.unflushed_spaces.start == this
-	       || unflushed_spaces.next || unflushed_spaces.prev;
+  return static_cast<const intrusive::list_node<unflushed_spaces_tag_t> *>(
+             this)
+      ->next;
 }
 
 /** Checks that this tablespace needs key rotation.
 @return true if in a rotation list */
-bool fil_space_t::is_in_rotation_list() const {
-	ut_ad(mutex_own(&fil_system.mutex));
+bool fil_space_t::is_in_rotation_list() const
+{
+  ut_ad(mutex_own(&fil_system.mutex));
 
-	return fil_system.rotation_list.start == this || rotation_list.next
-	       || rotation_list.prev;
+  return static_cast<const intrusive::list_node<rotation_list_tag_t> *>(this)
+      ->next;
 }
diff --git a/storage/innobase/fts/fts0fts.cc b/storage/innobase/fts/fts0fts.cc
index 3ca539c5f22..6b324354527 100644
--- a/storage/innobase/fts/fts0fts.cc
+++ b/storage/innobase/fts/fts0fts.cc
@@ -3202,7 +3202,7 @@ fts_fetch_doc_from_rec(
 	dict_index_t*	clust_index,	/*!< in: cluster index */
 	btr_pcur_t*	pcur,		/*!< in: cursor whose position
 					has been stored */
-	ulint*		offsets,	/*!< in: offsets */
+	offset_t*	offsets,	/*!< in: offsets */
 	fts_doc_t*	doc)		/*!< out: fts doc to hold parsed
 					documents */
 {
@@ -3486,7 +3486,7 @@ fts_add_doc_by_id(
 		btr_pcur_t*	doc_pcur;
 		const rec_t*	clust_rec;
 		btr_pcur_t	clust_pcur;
-		ulint*		offsets = NULL;
+		offset_t*	offsets = NULL;
 		ulint		num_idx = ib_vector_size(cache->get_docs);
 
 		rec = btr_pcur_get_rec(&pcur);
@@ -3677,8 +3677,8 @@ fts_get_max_doc_id(
 
 	if (!page_is_empty(btr_pcur_get_page(&pcur))) {
 		const rec_t*    rec = NULL;
-		ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-		ulint*		offsets = offsets_;
+		offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+		offset_t*	offsets = offsets_;
 		mem_heap_t*	heap = NULL;
 		ulint		len;
 		const void*	data;
@@ -5186,8 +5186,8 @@ fts_get_doc_id_from_rec(
 	const byte*	data;
 	ulint		col_no;
 	doc_id_t	doc_id = 0;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets = offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets = offsets_;
 	mem_heap_t*	my_heap = heap;
 
 	ut_a(table->fts->doc_col != ULINT_UNDEFINED);
diff --git a/storage/innobase/fts/fts0opt.cc b/storage/innobase/fts/fts0opt.cc
index 06cb70ed575..33b4c5d1bb5 100644
--- a/storage/innobase/fts/fts0opt.cc
+++ b/storage/innobase/fts/fts0opt.cc
@@ -2645,8 +2645,6 @@ fts_optimize_request_sync_table(
 
 	ib_wqueue_add(fts_optimize_wq, msg, msg->heap, true);
 
-	table->fts->in_queue = true;
-
 	mutex_exit(&fts_optimize_wq->mutex);
 }
 
diff --git a/storage/innobase/gis/gis0geo.cc b/storage/innobase/gis/gis0geo.cc
index d60a304f2f3..dad40d19da7 100644
--- a/storage/innobase/gis/gis0geo.cc
+++ b/storage/innobase/gis/gis0geo.cc
@@ -434,26 +434,6 @@ pick_seeds(
 	}
 }
 
-/*********************************************************//**
-Generates a random iboolean value.
-@return the random value */
-static
-ibool
-ut_rnd_gen_ibool(void)
-/*=================*/
-{
-	ulint    x;
-
-	x = ut_rnd_gen_ulint();
-
-	if (((x >> 20) + (x >> 15)) & 1) {
-
-		return(TRUE);
-	}
-
-	return(FALSE);
-}
-
 /*************************************************************//**
 Select next node and group where to add. */
 static
@@ -490,8 +470,7 @@ pick_next(
 			/* Introduce some randomness if the record
 			is identical */
 			if (diff == 0) {
-				diff = static_cast<double>(
-					ut_rnd_gen_ibool());
+				diff = static_cast<double>(ut_rnd_gen() & 1);
 			}
 
 			*n_group = 1 + (diff > 0);
@@ -791,35 +770,3 @@ rtree_area_overlapping(
 
 	return(area);
 }
-
-/** Get the wkb of default POINT value, which represents POINT(0 0)
-if it's of dimension 2, etc.
-@param[in]	n_dims		dimensions
-@param[out]	wkb		wkb buffer for default POINT
-@param[in]	len		length of wkb buffer
-@return non-0 indicate the length of wkb of the default POINT,
-0 if the buffer is too small */
-uint
-get_wkb_of_default_point(
-	uint	n_dims,
-	uchar*	wkb,
-	uint	len)
-{
-  // JAN: TODO: MYSQL 5.7 GIS
-  #define GEOM_HEADER_SIZE 16
-	if (len < GEOM_HEADER_SIZE + sizeof(double) * n_dims) {
-		return(0);
-	}
-
-	/** POINT wkb comprises SRID, wkb header(byte order and type)
-	and coordinates of the POINT */
-	len = GEOM_HEADER_SIZE + sizeof(double) * n_dims;
-	/** We always use 0 as default coordinate */
-	memset(wkb, 0, len);
-	/** We don't need to write SRID, write 0x01 for Byte Order */
-	mach_write_to_n_little_endian(wkb + SRID_SIZE, 1, 0x01);
-	/** Write wkbType::wkbPoint for the POINT type */
-	mach_write_to_n_little_endian(wkb + SRID_SIZE + 1, 4, wkbPoint);
-
-	return(len);
-}
diff --git a/storage/innobase/gis/gis0rtree.cc b/storage/innobase/gis/gis0rtree.cc
index 94256abfe71..5a80d394d77 100644
--- a/storage/innobase/gis/gis0rtree.cc
+++ b/storage/innobase/gis/gis0rtree.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2018, 2019, MariaDB Corporation.
+Copyright (c) 2018, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -51,7 +51,7 @@ rtr_page_split_initialize_nodes(
 	btr_cur_t*	cursor,	/*!< in: cursor at which to insert; when the
 				function returns, the cursor is positioned
 				on the predecessor of the inserted record */
-	ulint**		offsets,/*!< in: offsets on inserted record */
+	offset_t**	offsets,/*!< in: offsets on inserted record */
 	const dtuple_t*	tuple,	/*!< in: tuple to insert */
 	double**	buf_pos)/*!< in/out: current buffer position */
 {
@@ -192,7 +192,7 @@ rtr_update_mbr_field_in_place(
 /*==========================*/
 	dict_index_t*	index,		/*!< in: spatial index. */
 	rec_t*		rec,		/*!< in/out: rec to be modified.*/
-	ulint*		offsets,	/*!< in/out: offsets on rec. */
+	offset_t*	offsets,	/*!< in/out: offsets on rec. */
 	rtr_mbr_t*	mbr,		/*!< in: the new mbr. */
 	mtr_t*		mtr)		/*!< in: mtr */
 {
@@ -266,7 +266,7 @@ bool
 rtr_update_mbr_field(
 /*=================*/
 	btr_cur_t*	cursor,		/*!< in/out: cursor pointed to rec.*/
-	ulint*		offsets,	/*!< in/out: offsets on rec. */
+	offset_t*	offsets,	/*!< in/out: offsets on rec. */
 	btr_cur_t*	cursor2,	/*!< in/out: cursor pointed to rec
 					that should be deleted.
 					this cursor is for btr_compress to
@@ -295,7 +295,7 @@ rtr_update_mbr_field(
 	bool		ins_suc = true;
 	ulint		cur2_pos = 0;
 	ulint		del_page_no = 0;
-	ulint*		offsets2;
+	offset_t*	offsets2;
 
 	rec = btr_cur_get_rec(cursor);
 	page = page_align(rec);
@@ -382,7 +382,7 @@ rtr_update_mbr_field(
 		}
 
 		if (cursor2) {
-			ulint* offsets2;
+			offset_t* offsets2;
 
 			if (page_zip) {
 				cursor2->page_cur.rec
@@ -404,7 +404,7 @@ rtr_update_mbr_field(
 
 		page_cur_t		page_cur;
 		rec_t*			insert_rec;
-		ulint*			insert_offsets = NULL;
+		offset_t*		insert_offsets = NULL;
 		ulint			old_pos;
 		rec_t*			old_rec;
 
@@ -436,7 +436,7 @@ update_mbr:
 		/* When there're not only 1 rec in the page, we do delete/insert
 		to avoid page split. */
 		rec_t*			insert_rec;
-		ulint*			insert_offsets = NULL;
+		offset_t*		insert_offsets = NULL;
 		rec_t*			next_rec;
 
 		/* Delete the rec which cursor point to. */
@@ -636,7 +636,7 @@ rtr_adjust_upper_level(
 	page_zip_des_t*	new_page_zip;
 	dict_index_t*	index = sea_cur->index;
 	btr_cur_t	cursor;
-	ulint*		offsets;
+	offset_t*	offsets;
 	mem_heap_t*	heap;
 	ulint		level;
 	dtuple_t*	node_ptr_upper;
@@ -799,8 +799,8 @@ rtr_split_page_move_rec_list(
 	page_cur_t		new_page_cursor;
 	page_t*			page;
 	page_t*			new_page;
-	ulint			offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*			offsets		= offsets_;
+	offset_t		offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*		offsets		= offsets_;
 	page_zip_des_t*		new_page_zip
 		= buf_block_get_page_zip(new_block);
 	rec_t*			rec;
@@ -960,7 +960,7 @@ rtr_page_split_and_insert(
 	btr_cur_t*	cursor,	/*!< in/out: cursor at which to insert; when the
 				function returns, the cursor is positioned
 				on the predecessor of the inserted record */
-	ulint**		offsets,/*!< out: offsets on inserted record */
+	offset_t**	offsets,/*!< out: offsets on inserted record */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap, or NULL */
 	const dtuple_t*	tuple,	/*!< in: tuple to insert */
 	ulint		n_ext,	/*!< in: number of externally stored columns */
@@ -1309,7 +1309,7 @@ rtr_ins_enlarge_mbr(
 	mem_heap_t*		heap;
 	dict_index_t*		index = btr_cur->index;
 	page_cur_t*		page_cursor;
-	ulint*			offsets;
+	offset_t*		offsets;
 	node_visit_t*		node_visit;
 	btr_cur_t		cursor;
 	page_t*			page;
@@ -1393,10 +1393,10 @@ rtr_page_copy_rec_list_end_no_locks(
 	page_cur_t	page_cur;
 	page_cur_t	cur1;
 	rec_t*		cur_rec;
-	ulint		offsets_1[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets1 = offsets_1;
-	ulint		offsets_2[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets2 = offsets_2;
+	offset_t	offsets_1[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets1 = offsets_1;
+	offset_t	offsets_2[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets2 = offsets_2;
 	ulint		moved = 0;
 	bool		is_leaf = page_is_leaf(new_page);
 
@@ -1436,10 +1436,9 @@ rtr_page_copy_rec_list_end_no_locks(
 			offsets2 = rec_get_offsets(cur_rec, index, offsets2,
 						   is_leaf,
 						   ULINT_UNDEFINED, &heap);
-			cmp = cmp_rec_rec_with_match(cur1_rec, cur_rec,
-						     offsets1, offsets2,
-						     index, FALSE,
-						     &cur_matched_fields);
+			cmp = cmp_rec_rec(cur1_rec, cur_rec,
+					  offsets1, offsets2, index, false,
+					  &cur_matched_fields);
 			if (cmp < 0) {
 				page_cur_move_to_prev(&page_cur);
 				break;
@@ -1520,10 +1519,10 @@ rtr_page_copy_rec_list_start_no_locks(
 {
 	page_cur_t	cur1;
 	rec_t*		cur_rec;
-	ulint		offsets_1[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets1 = offsets_1;
-	ulint		offsets_2[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets2 = offsets_2;
+	offset_t	offsets_1[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets1 = offsets_1;
+	offset_t	offsets_2[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets2 = offsets_2;
 	page_cur_t	page_cur;
 	ulint		moved = 0;
 	bool		is_leaf = page_is_leaf(buf_block_get_frame(block));
@@ -1551,15 +1550,13 @@ rtr_page_copy_rec_list_start_no_locks(
 
 		while (!page_rec_is_supremum(cur_rec)) {
 			ulint		cur_matched_fields = 0;
-			int		cmp;
 
 			offsets2 = rec_get_offsets(cur_rec, index, offsets2,
 						   is_leaf,
 						   ULINT_UNDEFINED, &heap);
-			cmp = cmp_rec_rec_with_match(cur1_rec, cur_rec,
-						     offsets1, offsets2,
-						     index, FALSE,
-						     &cur_matched_fields);
+			int cmp = cmp_rec_rec(cur1_rec, cur_rec,
+					      offsets1, offsets2, index, false,
+					      &cur_matched_fields);
 			if (cmp < 0) {
 				page_cur_move_to_prev(&page_cur);
 				cur_rec = page_cur_get_rec(&page_cur);
@@ -1632,8 +1629,8 @@ rtr_merge_mbr_changed(
 /*==================*/
 	btr_cur_t*		cursor,		/*!< in/out: cursor */
 	btr_cur_t*		cursor2,	/*!< in: the other cursor */
-	ulint*			offsets,	/*!< in: rec offsets */
-	ulint*			offsets2,	/*!< in: rec offsets */
+	offset_t*		offsets,	/*!< in: rec offsets */
+	offset_t*		offsets2,	/*!< in: rec offsets */
 	rtr_mbr_t*		new_mbr)	/*!< out: MBR to update */
 {
 	double*		mbr;
@@ -1676,8 +1673,8 @@ rtr_merge_and_update_mbr(
 /*=====================*/
 	btr_cur_t*		cursor,		/*!< in/out: cursor */
 	btr_cur_t*		cursor2,	/*!< in: the other cursor */
-	ulint*			offsets,	/*!< in: rec offsets */
-	ulint*			offsets2,	/*!< in: rec offsets */
+	offset_t*		offsets,	/*!< in: rec offsets */
+	offset_t*		offsets2,	/*!< in: rec offsets */
 	page_t*			child_page,	/*!< in: the page. */
 	mtr_t*			mtr)		/*!< in: mtr */
 {
@@ -1740,7 +1737,7 @@ rtr_check_same_block(
 
 {
 	ulint		page_no = childb->page.id.page_no();
-	ulint*		offsets;
+	offset_t*	offsets;
 	rec_t*		rec = page_rec_get_next(page_get_infimum_rec(
 				buf_block_get_frame(parentb)));
 
@@ -1771,7 +1768,7 @@ rtr_rec_cal_increase(
 				dtuple in some of the common fields, or which
 				has an equal number or more fields than
 				dtuple */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	double*		area)	/*!< out: increased area */
 {
 	const dfield_t*	dtuple_field;
diff --git a/storage/innobase/gis/gis0sea.cc b/storage/innobase/gis/gis0sea.cc
index 3b3de0b2514..c73e7e6dde8 100644
--- a/storage/innobase/gis/gis0sea.cc
+++ b/storage/innobase/gis/gis0sea.cc
@@ -526,7 +526,7 @@ rtr_compare_cursor_rec(
 	mem_heap_t**	heap)		/*!< in: memory heap */
 {
 	const rec_t*	rec;
-	ulint*		offsets;
+	offset_t*	offsets;
 
 	rec = btr_cur_get_rec(cursor);
 
@@ -668,7 +668,7 @@ rtr_page_get_father(
 {
 	mem_heap_t*	heap = mem_heap_create(100);
 #ifdef UNIV_DEBUG
-	ulint*		offsets;
+	offset_t*	offsets;
 
 	offsets = rtr_page_get_father_block(
 		NULL, heap, index, block, mtr, sea_cur, cursor);
@@ -689,9 +689,9 @@ rtr_page_get_father(
 that mtr holds an SX-latch or X-latch on the tree.
 @return	rec_get_offsets() of the node pointer record */
 static
-ulint*
+offset_t*
 rtr_page_get_father_node_ptr(
-	ulint*		offsets,/*!< in: work area for the return value */
+	offset_t*	offsets,/*!< in: work area for the return value */
 	mem_heap_t*	heap,	/*!< in: memory heap to use */
 	btr_cur_t*	sea_cur,/*!< in: search cursor */
 	btr_cur_t*	cursor,	/*!< in: cursor pointing to user record,
@@ -784,10 +784,10 @@ rtr_page_get_father_node_ptr(
 Returns the father block to a page. It is assumed that mtr holds
 an X or SX latch on the tree.
 @return rec_get_offsets() of the node pointer record */
-ulint*
+offset_t*
 rtr_page_get_father_block(
 /*======================*/
-	ulint*		offsets,/*!< in: work area for the return value */
+	offset_t*	offsets,/*!< in: work area for the return value */
 	mem_heap_t*	heap,	/*!< in: memory heap to use */
 	dict_index_t*	index,	/*!< in: b-tree index */
 	buf_block_t*	block,	/*!< in: child page in the index */
@@ -1302,8 +1302,8 @@ rtr_cur_restore_position(
 #ifdef UNIV_DEBUG
 		do {
 			const rec_t*	rec;
-			const ulint*	offsets1;
-			const ulint*	offsets2;
+			const offset_t*	offsets1;
+			const offset_t*	offsets2;
 			ulint		comp;
 
 			rec = btr_pcur_get_rec(r_cursor);
@@ -1375,8 +1375,8 @@ search_again:
 
 	if (low_match == r_cursor->old_n_fields) {
 		const rec_t*	rec;
-		const ulint*	offsets1;
-		const ulint*	offsets2;
+		const offset_t*	offsets1;
+		const offset_t*	offsets2;
 		ulint		comp;
 
 		rec = btr_pcur_get_rec(r_cursor);
@@ -1422,7 +1422,7 @@ rtr_leaf_push_match_rec(
 /*====================*/
 	const rec_t*	rec,		/*!< in: record to copy */
 	rtr_info_t*	rtr_info,	/*!< in/out: search stack */
-	ulint*		offsets,	/*!< in: offsets */
+	offset_t*	offsets,	/*!< in: offsets */
 	bool		is_comp)	/*!< in: is compact format */
 {
 	byte*		buf;
@@ -1608,7 +1608,7 @@ void
 rtr_get_mbr_from_rec(
 /*=================*/
 	const rec_t*	rec,	/*!< in: data tuple */
-	const ulint*	offsets,/*!< in: offsets array */
+	const offset_t*	offsets,/*!< in: offsets array */
 	rtr_mbr_t*	mbr)	/*!< out MBR */
 {
 	ulint		rec_f_len;
@@ -1655,8 +1655,8 @@ rtr_cur_search_with_match(
 	const page_t*	page;
 	const rec_t*	rec;
 	const rec_t*	last_rec;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	mem_heap_t*	heap = NULL;
 	int		cmp = 1;
 	double		least_inc = DBL_MAX;
@@ -1939,8 +1939,8 @@ rtr_cur_search_with_match(
 
 			test_rec = match_rec->matched_recs->back();
 #ifdef UNIV_DEBUG
-			ulint		offsets_2[REC_OFFS_NORMAL_SIZE];
-			ulint*		offsets2	= offsets_2;
+			offset_t	offsets_2[REC_OFFS_NORMAL_SIZE];
+			offset_t*	offsets2	= offsets_2;
 			rec_offs_init(offsets_2);
 
 			ut_ad(found);
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index eecc72ad1f6..79051b9c247 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -4,7 +4,7 @@ Copyright (c) 2000, 2019, Oracle and/or its affiliates. All Rights Reserved.
 Copyright (c) 2008, 2009 Google Inc.
 Copyright (c) 2009, Percona Inc.
 Copyright (c) 2012, Facebook Inc.
-Copyright (c) 2013, 2019, MariaDB Corporation.
+Copyright (c) 2013, 2020, MariaDB Corporation.
 
 Portions of this file contain modifications contributed and copyrighted by
 Google, Inc. Those modifications are gratefully acknowledged and are described
@@ -3429,17 +3429,6 @@ trx_is_interrupted(
 	return(trx && trx->mysql_thd && thd_kill_level(trx->mysql_thd));
 }
 
-/**********************************************************************//**
-Determines if the currently running transaction is in strict mode.
-@return TRUE if strict */
-ibool
-trx_is_strict(
-/*==========*/
-	trx_t*	trx)	/*!< in: transaction */
-{
-	return(trx && trx->mysql_thd && THDVAR(trx->mysql_thd, strict_mode));
-}
-
 /**************************************************************//**
 Resets some fields of a m_prebuilt struct. The template is used in fast
 retrieval of just those column values MySQL needs in its processing. */
@@ -10905,6 +10894,9 @@ create_table_info_t::create_table_def()
 
 	heap = mem_heap_create(1000);
 
+	ut_d(bool have_vers_start = false);
+	ut_d(bool have_vers_end = false);
+
 	for (ulint i = 0, j = 0; j < n_cols; i++) {
 		Field*	field = m_form->field[i];
 		ulint vers_row = 0;
@@ -10912,8 +10904,10 @@ create_table_info_t::create_table_def()
 		if (m_form->versioned()) {
 			if (i == m_form->s->row_start_field) {
 				vers_row = DATA_VERS_START;
+				ut_d(have_vers_start = true);
 			} else if (i == m_form->s->row_end_field) {
 				vers_row = DATA_VERS_END;
+				ut_d(have_vers_end = true);
 			} else if (!(field->flags
 				     & VERS_UPDATE_UNVERSIONED_FLAG)) {
 				vers_row = DATA_VERSIONED;
@@ -11034,6 +11028,10 @@ err_col:
 		j++;
 	}
 
+	ut_ad(have_vers_start == have_vers_end);
+	ut_ad(table->versioned() == have_vers_start);
+	ut_ad(!table->versioned() || table->vers_start != table->vers_end);
+
 	if (num_v) {
 		for (ulint i = 0, j = 0; i < n_cols; i++) {
 			dict_v_col_t*	v_col;
@@ -12493,7 +12491,9 @@ int create_table_info_t::create_table(bool create_fk)
 		}
 	}
 
-	if (!row_size_is_acceptable(*m_table)) {
+	/* In TRUNCATE TABLE, we will merely warn about the maximum
+	row size being too large. */
+	if (!row_size_is_acceptable(*m_table, create_fk)) {
 		DBUG_RETURN(convert_error_code_to_mysql(
 			    DB_TOO_BIG_RECORD, m_flags, NULL));
 	}
@@ -12502,18 +12502,12 @@ int create_table_info_t::create_table(bool create_fk)
 }
 
 bool create_table_info_t::row_size_is_acceptable(
-    const dict_table_t &table) const
+  const dict_table_t &table, bool strict) const
 {
   for (dict_index_t *index= dict_table_get_first_index(&table); index;
        index= dict_table_get_next_index(index))
-  {
-
-    if (!row_size_is_acceptable(*index))
-    {
+    if (!row_size_is_acceptable(*index, strict))
       return false;
-    }
-  }
-
   return true;
 }
 
@@ -12692,7 +12686,7 @@ static void ib_warn_row_too_big(THD *thd, const dict_table_t *table)
 }
 
 bool create_table_info_t::row_size_is_acceptable(
-    const dict_index_t &index) const
+    const dict_index_t &index, bool strict) const
 {
   if ((index.type & DICT_FTS) || index.table->is_system_db)
   {
@@ -12701,7 +12695,7 @@ bool create_table_info_t::row_size_is_acceptable(
     return true;
   }
 
-  const bool strict= THDVAR(m_thd, strict_mode);
+  const bool innodb_strict_mode= THDVAR(m_thd, strict_mode);
   dict_index_t::record_size_info_t info= index.record_size_info();
 
   if (info.row_is_too_big())
@@ -12712,18 +12706,19 @@ bool create_table_info_t::row_size_is_acceptable(
     const size_t idx= info.get_first_overrun_field_index();
     const dict_field_t *field= dict_index_get_nth_field(&index, idx);
 
-    ib::error_or_warn(strict)
-        << "Cannot add field " << field->name << " in table "
-        << index.table->name << " because after adding it, the row size is "
-        << info.get_overrun_size()
-        << " which is greater than maximum allowed size ("
-        << info.max_leaf_size << " bytes) for a record on index leaf page.";
-
-    if (strict)
+    if (innodb_strict_mode || global_system_variables.log_warnings > 2)
     {
-      return false;
+      ib::error_or_warn(strict && innodb_strict_mode)
+          << "Cannot add field " << field->name << " in table "
+          << index.table->name << " because after adding it, the row size is "
+          << info.get_overrun_size()
+          << " which is greater than maximum allowed size ("
+          << info.max_leaf_size << " bytes) for a record on index leaf page.";
     }
 
+    if (strict && innodb_strict_mode)
+      return false;
+
     ib_warn_row_too_big(m_thd, index.table);
   }
 
diff --git a/storage/innobase/handler/ha_innodb.h b/storage/innobase/handler/ha_innodb.h
index d4390374cd2..8e513ddd692 100644
--- a/storage/innobase/handler/ha_innodb.h
+++ b/storage/innobase/handler/ha_innodb.h
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2000, 2017, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2013, 2019, MariaDB Corporation.
+Copyright (c) 2013, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -690,9 +690,11 @@ public:
 	void allocate_trx();
 
 	/** Checks that every index have sane size. Depends on strict mode */
-	bool row_size_is_acceptable(const dict_table_t& table) const;
+	bool row_size_is_acceptable(const dict_table_t& table,
+				    bool strict) const;
 	/** Checks that given index have sane size. Depends on strict mode */
-	bool row_size_is_acceptable(const dict_index_t& index) const;
+	bool row_size_is_acceptable(const dict_index_t& index,
+				    bool strict) const;
 
 	/** Determines InnoDB table flags.
 	If strict_mode=OFF, this will adjust the flags to what should be assumed.
diff --git a/storage/innobase/handler/handler0alter.cc b/storage/innobase/handler/handler0alter.cc
index 785c8a970d4..a2839d1a7ec 100644
--- a/storage/innobase/handler/handler0alter.cc
+++ b/storage/innobase/handler/handler0alter.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2005, 2019, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2013, 2019, MariaDB Corporation.
+Copyright (c) 2013, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -122,6 +122,15 @@ static const alter_table_operations INNOBASE_ALTER_NOCREATE
 	= ALTER_DROP_NON_UNIQUE_NON_PRIM_INDEX
 	| ALTER_DROP_UNIQUE_INDEX;
 
+/** Operations that InnoDB cares about and can perform without validation */
+static const alter_table_operations INNOBASE_ALTER_NOVALIDATE
+	= INNOBASE_ALTER_NOCREATE
+	| ALTER_VIRTUAL_COLUMN_ORDER
+	| ALTER_COLUMN_NAME
+	| INNOBASE_FOREIGN_OPERATIONS
+	| ALTER_COLUMN_UNVERSIONED
+	| ALTER_DROP_VIRTUAL_COLUMN;
+
 /** Operations that InnoDB cares about and can perform without rebuild */
 static const alter_table_operations INNOBASE_ALTER_NOREBUILD
 	= INNOBASE_ONLINE_CREATE
@@ -2162,7 +2171,7 @@ innobase_rec_to_mysql(
 	struct TABLE*		table,	/*!< in/out: MySQL table */
 	const rec_t*		rec,	/*!< in: record */
 	const dict_index_t*	index,	/*!< in: index */
-	const ulint*		offsets)/*!< in: rec_get_offsets(
+	const offset_t*		offsets)/*!< in: rec_get_offsets(
 					rec, index, ...) */
 {
 	uint	n_fields	= table->s->fields;
@@ -4401,7 +4410,7 @@ innobase_add_instant_try(
 			uf->field_no = f;
 			uf->new_val = entry->fields[f];
 		}
-		ulint* offsets = NULL;
+		offset_t* offsets = NULL;
 		mem_heap_t* offsets_heap = NULL;
 		big_rec_t* big_rec;
 		err = btr_cur_pessimistic_update(
@@ -5541,6 +5550,7 @@ new_table_failed:
 				if (index) {
 					dict_mem_index_free(index);
 				}
+error_handling_drop_uncached_1:
 				while (++a < ctx->num_to_add_index) {
 					dict_mem_index_free(ctx->add_index[a]);
 				}
@@ -5550,9 +5560,17 @@ new_table_failed:
 			}
 
 			ctx->add_index[a] = index;
-			if (!info.row_size_is_acceptable(*index)) {
+			/* For ALTER TABLE...FORCE or OPTIMIZE TABLE,
+			we may only issue warnings, because there will
+			be no schema change from the user perspective. */
+			if (!info.row_size_is_acceptable(
+				    *index,
+				    !!(ha_alter_info->handler_flags
+				       & ~(INNOBASE_INPLACE_IGNORE
+					   | INNOBASE_ALTER_NOVALIDATE
+					   | ALTER_RECREATE_TABLE)))) {
 				error = DB_TOO_BIG_RECORD;
-				goto error_handling;
+				goto error_handling_drop_uncached_1;
 			}
 			index->parser = index_defs[a].parser;
 			index->has_new_v_col = has_new_v_col;
@@ -5652,7 +5670,7 @@ error_handling_drop_uncached:
 				DBUG_ASSERT(index != ctx->add_index[a]);
 			}
 			ctx->add_index[a]= index;
-			if (!info.row_size_is_acceptable(*index)) {
+			if (!info.row_size_is_acceptable(*index, true)) {
 				error = DB_TOO_BIG_RECORD;
 				goto error_handling_drop_uncached;
 			}
@@ -5705,7 +5723,7 @@ error_handling_drop_uncached:
 			}
 		}
 	} else if (ctx->is_instant()
-		   && !info.row_size_is_acceptable(*user_table)) {
+		   && !info.row_size_is_acceptable(*user_table, true)) {
 		error = DB_TOO_BIG_RECORD;
 		goto error_handling;
 	}
diff --git a/storage/innobase/handler/i_s.cc b/storage/innobase/handler/i_s.cc
index 61703f947e2..4ee027290fd 100644
--- a/storage/innobase/handler/i_s.cc
+++ b/storage/innobase/handler/i_s.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2007, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2014, 2019, MariaDB Corporation.
+Copyright (c) 2014, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -9050,6 +9050,8 @@ i_s_innodb_mutexes_fill_table(
 			~Locking() { mutex_exit(&rw_lock_list_mutex); }
 		} locking;
 
+		char lock_name[sizeof "buf0dump.cc:12345"];
+
 		for (lock = UT_LIST_GET_FIRST(rw_lock_list); lock != NULL;
 		     lock = UT_LIST_GET_NEXT(list, lock)) {
 			if (lock->count_os_wait == 0) {
@@ -9062,11 +9064,16 @@ i_s_innodb_mutexes_fill_table(
 				continue;
 			}
 
-			//OK(field_store_string(fields[MUTEXES_NAME],
-			//			lock->lock_name));
-			OK(field_store_string(
-				   fields[MUTEXES_CREATE_FILE],
-				   innobase_basename(lock->cfile_name)));
+			const char* basename = innobase_basename(
+				lock->cfile_name);
+
+			snprintf(lock_name, sizeof lock_name, "%s:%u",
+				 basename, lock->cline);
+
+			OK(field_store_string(fields[MUTEXES_NAME],
+					      lock_name));
+			OK(field_store_string(fields[MUTEXES_CREATE_FILE],
+					      basename));
 			OK(fields[MUTEXES_CREATE_LINE]->store(lock->cline,
 							      true));
 			fields[MUTEXES_CREATE_LINE]->set_notnull();
@@ -9082,8 +9089,8 @@ i_s_innodb_mutexes_fill_table(
 			snprintf(buf1, sizeof buf1, "combined %s",
 				 innobase_basename(block_lock->cfile_name));
 
-			//OK(field_store_string(fields[MUTEXES_NAME],
-			//			block_lock->lock_name));
+			OK(field_store_string(fields[MUTEXES_NAME],
+					      "buf_block_t::lock"));
 			OK(field_store_string(fields[MUTEXES_CREATE_FILE],
 					      buf1));
 			OK(fields[MUTEXES_CREATE_LINE]->store(block_lock->cline,
diff --git a/storage/innobase/ibuf/ibuf0ibuf.cc b/storage/innobase/ibuf/ibuf0ibuf.cc
index ae8b8cd4a8a..38814da0c8d 100644
--- a/storage/innobase/ibuf/ibuf0ibuf.cc
+++ b/storage/innobase/ibuf/ibuf0ibuf.cc
@@ -3310,7 +3310,7 @@ ibuf_insert_low(
 	dtuple_t*	ibuf_entry;
 	mem_heap_t*	offsets_heap	= NULL;
 	mem_heap_t*	heap;
-	ulint*		offsets		= NULL;
+	offset_t*	offsets		= NULL;
 	ulint		buffered;
 	lint		min_n_recs;
 	rec_t*		ins_rec;
@@ -3770,7 +3770,7 @@ ibuf_insert_to_index_page_low(
 	buf_block_t*	block,	/*!< in/out: index page where the buffered
 				entry should be placed */
 	dict_index_t*	index,	/*!< in: record descriptor */
-	ulint**		offsets,/*!< out: offsets on *rec */
+	offset_t**	offsets,/*!< out: offsets on *rec */
 	mem_heap_t*	heap,	/*!< in/out: memory heap */
 	mtr_t*		mtr,	/*!< in/out: mtr */
 	page_cur_t*	page_cur)/*!< in/out: cursor positioned on the record
@@ -3850,7 +3850,7 @@ ibuf_insert_to_index_page(
 	ulint		low_match;
 	page_t*		page		= buf_block_get_frame(block);
 	rec_t*		rec;
-	ulint*		offsets;
+	offset_t*	offsets;
 	mem_heap_t*	heap;
 
 	DBUG_ENTER("ibuf_insert_to_index_page");
@@ -4107,8 +4107,8 @@ ibuf_delete(
 		/* TODO: the below should probably be a separate function,
 		it's a bastardized version of btr_cur_optimistic_delete. */
 
-		ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-		ulint*		offsets	= offsets_;
+		offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+		offset_t*	offsets	= offsets_;
 		mem_heap_t*	heap = NULL;
 		ulint		max_ins_size = 0;
 
@@ -4559,7 +4559,7 @@ loop:
 	}
 
 	if (!btr_pcur_is_on_user_rec(&pcur)) {
-		ut_ad(btr_pcur_is_after_last_in_tree(&pcur));
+		ut_ad(btr_pcur_is_after_last_on_page(&pcur));
 		goto reset_bit;
 	}
 
@@ -4792,7 +4792,7 @@ loop:
 		&pcur, &mtr);
 
 	if (!btr_pcur_is_on_user_rec(&pcur)) {
-		ut_ad(btr_pcur_is_after_last_in_tree(&pcur));
+		ut_ad(btr_pcur_is_after_last_on_page(&pcur));
 		goto leave_loop;
 	}
 
diff --git a/storage/innobase/include/btr0btr.h b/storage/innobase/include/btr0btr.h
index d68b02eda4d..698343bf371 100644
--- a/storage/innobase/include/btr0btr.h
+++ b/storage/innobase/include/btr0btr.h
@@ -30,6 +30,7 @@ Created 6/2/1994 Heikki Tuuri
 
 #include "dict0dict.h"
 #include "data0data.h"
+#include "rem0types.h"
 #include "page0cur.h"
 #include "btr0types.h"
 #include "gis0type.h"
@@ -319,7 +320,7 @@ ulint
 btr_node_ptr_get_child_page_no(
 /*===========================*/
 	const rec_t*	rec,	/*!< in: node pointer record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 	MY_ATTRIBUTE((warn_unused_result));
 
 /** Create the root node for a new index tree.
@@ -404,7 +405,7 @@ btr_root_raise_and_insert(
 				on the root page; when the function returns,
 				the cursor is positioned on the predecessor
 				of the inserted record */
-	ulint**		offsets,/*!< out: offsets on inserted record */
+	offset_t**	offsets,/*!< out: offsets on inserted record */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap
 				that can be emptied, or NULL */
 	const dtuple_t*	tuple,	/*!< in: tuple to insert */
@@ -487,7 +488,7 @@ btr_page_split_and_insert(
 	btr_cur_t*	cursor,	/*!< in: cursor at which to insert; when the
 				function returns, the cursor is positioned
 				on the predecessor of the inserted record */
-	ulint**		offsets,/*!< out: offsets on inserted record */
+	offset_t**	offsets,/*!< out: offsets on inserted record */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap
 				that can be emptied, or NULL */
 	const dtuple_t*	tuple,	/*!< in: tuple to insert */
diff --git a/storage/innobase/include/btr0btr.ic b/storage/innobase/include/btr0btr.ic
index c3f0d5e305e..5bb7318fefb 100644
--- a/storage/innobase/include/btr0btr.ic
+++ b/storage/innobase/include/btr0btr.ic
@@ -192,7 +192,7 @@ ulint
 btr_node_ptr_get_child_page_no(
 /*===========================*/
 	const rec_t*	rec,	/*!< in: node pointer record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	const byte*	field;
 	ulint		len;
diff --git a/storage/innobase/include/btr0bulk.h b/storage/innobase/include/btr0bulk.h
index 2a434c673cb..9384cb578ed 100644
--- a/storage/innobase/include/btr0bulk.h
+++ b/storage/innobase/include/btr0bulk.h
@@ -28,6 +28,7 @@ Created 03/11/2014 Shaohua Wang
 #define btr0bulk_h
 
 #include "dict0dict.h"
+#include "rem0types.h"
 #include "page0cur.h"
 
 #include <vector>
@@ -103,7 +104,7 @@ public:
 	/** Insert a record in the page.
 	@param[in]	rec		record
 	@param[in]	offsets		record offsets */
-	void insert(const rec_t* rec, ulint* offsets);
+	void insert(const rec_t* rec, offset_t* offsets);
 
 	/** Mark end of insertion to the page. Scan all records to set page
 	dirs, and set page header members. */
@@ -127,7 +128,7 @@ public:
 	@param[in]	big_rec		external recrod
 	@param[in]	offsets		record offsets
 	@return	error code */
-	dberr_t storeExt(const big_rec_t* big_rec, ulint* offsets);
+	dberr_t storeExt(const big_rec_t* big_rec, offset_t* offsets);
 
 	/** Get node pointer
 	@return node pointer */
diff --git a/storage/innobase/include/btr0cur.h b/storage/innobase/include/btr0cur.h
index c748b4fbc41..13a420fd912 100644
--- a/storage/innobase/include/btr0cur.h
+++ b/storage/innobase/include/btr0cur.h
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
-Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, 2019, MariaDB Corporation.
+Copyright (c) 1994, 2019, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -30,6 +30,7 @@ Created 10/16/1994 Heikki Tuuri
 #include "dict0dict.h"
 #include "page0cur.h"
 #include "btr0types.h"
+#include "rem0types.h"
 #include "gis0type.h"
 #include "my_base.h"
 
@@ -271,7 +272,7 @@ btr_cur_optimistic_insert(
 				specified */
 	btr_cur_t*	cursor,	/*!< in: cursor on page after which to insert;
 				cursor stays valid */
-	ulint**		offsets,/*!< out: offsets on *rec */
+	offset_t**	offsets,/*!< out: offsets on *rec */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap */
 	dtuple_t*	entry,	/*!< in/out: entry to insert */
 	rec_t**		rec,	/*!< out: pointer to inserted record if
@@ -307,7 +308,7 @@ btr_cur_pessimistic_insert(
 				insertion will certainly succeed */
 	btr_cur_t*	cursor,	/*!< in: cursor after which to insert;
 				cursor stays valid */
-	ulint**		offsets,/*!< out: offsets on *rec */
+	offset_t**	offsets,/*!< out: offsets on *rec */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap
 				that can be emptied */
 	dtuple_t*	entry,	/*!< in/out: entry to insert */
@@ -341,7 +342,7 @@ btr_cur_update_alloc_zip_func(
 	page_cur_t*	cursor,	/*!< in/out: B-tree page cursor */
 	dict_index_t*	index,	/*!< in: the index corresponding to cursor */
 #ifdef UNIV_DEBUG
-	ulint*		offsets,/*!< in/out: offsets of the cursor record */
+	offset_t*	offsets,/*!< in/out: offsets of the cursor record */
 #endif /* UNIV_DEBUG */
 	ulint		length,	/*!< in: size needed */
 	bool		create,	/*!< in: true=delete-and-insert,
@@ -368,7 +369,7 @@ btr_cur_update_in_place(
 	btr_cur_t*	cursor,	/*!< in: cursor on the record to update;
 				cursor stays valid and positioned on the
 				same record */
-	ulint*		offsets,/*!< in/out: offsets on cursor->page_cur.rec */
+	offset_t*	offsets,/*!< in/out: offsets on cursor->page_cur.rec */
 	const upd_t*	update,	/*!< in: update vector */
 	ulint		cmpl_info,/*!< in: compiler info on secondary index
 				updates */
@@ -410,7 +411,7 @@ btr_cur_optimistic_update(
 	btr_cur_t*	cursor,	/*!< in: cursor on the record to update;
 				cursor stays valid and positioned on the
 				same record */
-	ulint**		offsets,/*!< out: offsets on cursor->page_cur.rec */
+	offset_t**	offsets,/*!< out: offsets on cursor->page_cur.rec */
 	mem_heap_t**	heap,	/*!< in/out: pointer to NULL or memory heap */
 	const upd_t*	update,	/*!< in: update vector; this must also
 				contain trx id and roll ptr fields */
@@ -437,7 +438,7 @@ btr_cur_pessimistic_update(
 	btr_cur_t*	cursor,	/*!< in/out: cursor on the record to update;
 				cursor may become invalid if *big_rec == NULL
 				|| !(flags & BTR_KEEP_POS_FLAG) */
-	ulint**		offsets,/*!< out: offsets on cursor->page_cur.rec */
+	offset_t**	offsets,/*!< out: offsets on cursor->page_cur.rec */
 	mem_heap_t**	offsets_heap,
 				/*!< in/out: pointer to memory heap
 				that can be emptied */
@@ -469,7 +470,7 @@ btr_cur_del_mark_set_clust_rec(
 	buf_block_t*	block,	/*!< in/out: buffer block of the record */
 	rec_t*		rec,	/*!< in/out: record */
 	dict_index_t*	index,	/*!< in: clustered index of the record */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec) */
 	que_thr_t*	thr,	/*!< in: query thread */
 	const dtuple_t*	entry,	/*!< in: dtuple for the deleting record */
 	mtr_t*		mtr)	/*!< in/out: mini-transaction */
@@ -636,7 +637,7 @@ btr_estimate_number_of_different_key_vals(
 ulint
 btr_rec_get_externally_stored_len(
 	const rec_t*	rec,
-	const ulint*	offsets);
+	const offset_t*	offsets);
 
 /*******************************************************************//**
 Marks non-updated off-page fields as disowned by this record. The ownership
@@ -650,7 +651,7 @@ btr_cur_disown_inherited_fields(
 				part will be updated, or NULL */
 	rec_t*		rec,	/*!< in/out: record in a clustered index */
 	dict_index_t*	index,	/*!< in: index of the page */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	const upd_t*	update,	/*!< in: update vector */
 	mtr_t*		mtr)	/*!< in/out: mini-transaction */
 	MY_ATTRIBUTE((nonnull(2,3,4,5,6)));
@@ -689,7 +690,7 @@ btr_store_big_rec_extern_fields(
 	btr_pcur_t*	pcur,		/*!< in/out: a persistent cursor. if
 					btr_mtr is restarted, then this can
 					be repositioned. */
-	ulint*		offsets,	/*!< in/out: rec_get_offsets() on
+	offset_t*	offsets,	/*!< in/out: rec_get_offsets() on
 					pcur. the "external storage" flags
 					in offsets will correctly correspond
 					to rec when this function returns */
@@ -720,7 +721,7 @@ btr_free_externally_stored_field(
 	byte*		field_ref,	/*!< in/out: field reference */
 	const rec_t*	rec,		/*!< in: record containing field_ref, for
 					page_zip_write_blob_ptr(), or NULL */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec, index),
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec, index),
 					or NULL */
 	page_zip_des_t*	page_zip,	/*!< in: compressed page corresponding
 					to rec, or NULL if rec == NULL */
@@ -777,24 +778,12 @@ protected by a lock or a page latch
 byte*
 btr_rec_copy_externally_stored_field(
 	const rec_t*		rec,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	const page_size_t&	page_size,
 	ulint			no,
 	ulint*			len,
 	mem_heap_t*		heap);
 
-/*******************************************************************//**
-Flags the data tuple fields that are marked as extern storage in the
-update vector.  We use this function to remember which fields we must
-mark as extern storage in a record inserted for an update.
-@return number of flagged external columns */
-ulint
-btr_push_update_extern_fields(
-/*==========================*/
-	dtuple_t*	tuple,	/*!< in/out: data tuple */
-	const upd_t*	update,	/*!< in: update vector */
-	mem_heap_t*	heap)	/*!< in: memory heap */
-	MY_ATTRIBUTE((nonnull));
 /***********************************************************//**
 Sets a secondary index record's delete mark to the given value. This
 function is only used by the insert buffer merge mechanism. */
diff --git a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h
index f04d3fe038f..c9529ee4b73 100644
--- a/storage/innobase/include/buf0buf.h
+++ b/storage/innobase/include/buf0buf.h
@@ -706,6 +706,27 @@ buf_page_is_corrupted(
 #endif
 	MY_ATTRIBUTE((warn_unused_result));
 
+inline void *aligned_malloc(size_t size, size_t align)
+{
+#ifdef _MSC_VER
+  return _aligned_malloc(size, align);
+#else
+  void *result;
+  if (posix_memalign(&result, align, size))
+    result= NULL;
+  return result;
+#endif
+}
+
+inline void aligned_free(void *ptr)
+{
+#ifdef _MSC_VER
+  _aligned_free(ptr);
+#else
+  free(ptr);
+#endif
+}
+
 #ifndef UNIV_INNOCHECKSUM
 /**********************************************************************//**
 Gets the space id, page offset, and byte offset within page of a
diff --git a/storage/innobase/include/buf0buf.ic b/storage/innobase/include/buf0buf.ic
index df364401172..79ec1e5d80b 100644
--- a/storage/innobase/include/buf0buf.ic
+++ b/storage/innobase/include/buf0buf.ic
@@ -113,7 +113,17 @@ ulint
 buf_pool_get_n_pages(void)
 /*======================*/
 {
-	return buf_pool_get_curr_size() >> srv_page_size_shift;
+  if (!buf_pool_ptr)
+    return buf_pool_get_curr_size() >> srv_page_size_shift;
+
+  ulint chunk_size= 0;
+  for (uint i= 0; i < srv_buf_pool_instances; i++)
+  {
+    buf_pool_t* buf_pool = buf_pool_from_array(i);
+    for (uint j= 0; j < buf_pool->n_chunks; j++)
+      chunk_size+= buf_pool->chunks[j].size;
+  }
+  return chunk_size;
 }
 
 /********************************************************************//**
diff --git a/storage/innobase/include/dict0crea.h b/storage/innobase/include/dict0crea.h
index 2a302dabae8..8ab987cd39a 100644
--- a/storage/innobase/include/dict0crea.h
+++ b/storage/innobase/include/dict0crea.h
@@ -224,16 +224,6 @@ dict_replace_tablespace_in_dictionary(
 	const char*	path,
 	trx_t*		trx);
 
-/** Delete records from SYS_TABLESPACES and SYS_DATAFILES associated
-with a particular tablespace ID.
-@param[in]	space	Tablespace ID
-@param[in,out]	trx	Current transaction
-@return DB_SUCCESS if OK, dberr_t if the operation failed */
-dberr_t
-dict_delete_tablespace_and_datafiles(
-	ulint		space,
-	trx_t*		trx);
-
 /********************************************************************//**
 Add a foreign key definition to the data dictionary tables.
 @return error code or DB_SUCCESS */
diff --git a/storage/innobase/include/dict0mem.h b/storage/innobase/include/dict0mem.h
index df114b305c3..1a22470569e 100644
--- a/storage/innobase/include/dict0mem.h
+++ b/storage/innobase/include/dict0mem.h
@@ -832,10 +832,6 @@ a certain index.*/
 system clustered index when there is no primary key. */
 const char innobase_index_reserve_name[] = "GEN_CLUST_INDEX";
 
-/* Estimated number of offsets in records (based on columns)
-to start with. */
-#define OFFS_IN_REC_NORMAL_SIZE		100
-
 /** Data structure for an index.  Most fields will be
 initialized to 0, NULL or FALSE in dict_mem_index_create(). */
 struct dict_index_t{
@@ -1112,7 +1108,7 @@ struct dict_index_t{
 	@param[in]	offsets	offsets
 	@return true if row is historical */
 	bool
-	vers_history_row(const rec_t* rec, const ulint* offsets);
+	vers_history_row(const rec_t* rec, const offset_t* offsets);
 
 	/** Check if record in secondary index is historical row.
 	@param[in]	rec	record in a secondary index
@@ -1607,10 +1603,14 @@ struct dict_table_t {
 	/** Add the table definition to the data dictionary cache */
 	void add_to_cache();
 
+	/** @return whether the table is versioned.
+	It is assumed that both vers_start and vers_end set to 0
+	iff table is not versioned. In any other case,
+	these fields correspond to actual positions in cols[]. */
 	bool versioned() const { return vers_start || vers_end; }
 	bool versioned_by_id() const
 	{
-		return vers_start && cols[vers_start].mtype == DATA_INT;
+		return versioned() && cols[vers_start].mtype == DATA_INT;
 	}
 
 	void inc_fk_checks()
diff --git a/storage/innobase/include/dyn0buf.h b/storage/innobase/include/dyn0buf.h
index db809c908ae..f66c7e3d405 100644
--- a/storage/innobase/include/dyn0buf.h
+++ b/storage/innobase/include/dyn0buf.h
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2013, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2018, 2019, MariaDB Corporation.
+Copyright (c) 2018, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -29,7 +29,8 @@ Created 2013-03-16 Sunny Bains
 
 #include "mem0mem.h"
 #include "dyn0types.h"
-#include "ut0lst.h"
+#include "intrusive_list.h"
+
 
 /** Class that manages dynamic buffers. It uses a UT_LIST of
 mtr_buf_t::block_t instances. We don't use STL containers in
@@ -40,17 +41,11 @@ backend for the custom allocator because we would like the data in
 the blocks to be contiguous. */
 class mtr_buf_t {
 public:
-
-	class block_t;
-
-	typedef UT_LIST_NODE_T(block_t) block_node_t;
-	typedef UT_LIST_BASE_NODE_T(block_t) block_list_t;
-
 	/** SIZE - sizeof(m_node) + sizeof(m_used) */
 	enum { MAX_DATA_SIZE = DYN_ARRAY_DATA_SIZE
-	       - sizeof(block_node_t) + sizeof(ib_uint32_t) };
+	       - sizeof(intrusive::list_node<>) + sizeof(uint32_t) };
 
-	class block_t {
+	class block_t : public intrusive::list_node<> {
 	public:
 
 		block_t()
@@ -158,9 +153,6 @@ public:
 		/** Storage */
 		byte		m_data[MAX_DATA_SIZE];
 
-		/** Doubly linked list node. */
-		block_node_t	m_node;
-
 		/** number of data bytes used in this block;
 		DYN_BLOCK_FULL_FLAG is set when the block becomes full */
 		uint32_t	m_used;
@@ -168,13 +160,14 @@ public:
 		friend class mtr_buf_t;
 	};
 
+	typedef intrusive::list<block_t> list_t;
+
 	/** Default constructor */
 	mtr_buf_t()
 		:
 		m_heap(),
 		m_size()
 	{
-		UT_LIST_INIT(m_list, &block_t::m_node);
 		push_back(&m_first_block);
 	}
 
@@ -192,11 +185,11 @@ public:
 			m_heap = NULL;
 
 			/* Initialise the list and add the first block. */
-			UT_LIST_INIT(m_list, &block_t::m_node);
-			push_back(&m_first_block);
+			m_list.clear();
+			m_list.push_back(m_first_block);
 		} else {
 			m_first_block.init();
-			ut_ad(UT_LIST_GET_LEN(m_list) == 1);
+			ut_ad(m_list.size() == 1);
 		}
 
 		m_size = 0;
@@ -228,7 +221,7 @@ public:
 	@param ptr	end of used space */
 	void close(const byte* ptr)
 	{
-		ut_ad(UT_LIST_GET_LEN(m_list) > 0);
+		ut_ad(!m_list.empty());
 		block_t*	block = back();
 
 		m_size -= block->used();
@@ -310,11 +303,9 @@ public:
 #ifdef UNIV_DEBUG
 		ulint	total_size = 0;
 
-		for (const block_t* block = UT_LIST_GET_FIRST(m_list);
-		     block != NULL;
-		     block = UT_LIST_GET_NEXT(m_node, block)) {
-
-			total_size += block->used();
+		for (list_t::iterator it = m_list.begin(), end = m_list.end();
+		     it != end; ++it) {
+			total_size += it->used();
 		}
 
 		ut_ad(total_size == m_size);
@@ -328,12 +319,11 @@ public:
 	template <typename Functor>
 	bool for_each_block(Functor& functor) const
 	{
-		for (const block_t* block = UT_LIST_GET_FIRST(m_list);
-		     block != NULL;
-		     block = UT_LIST_GET_NEXT(m_node, block)) {
+		for (list_t::iterator it = m_list.begin(), end = m_list.end();
+		     it != end; ++it) {
 
-			if (!functor(block)) {
-				return(false);
+			if (!functor(&*it)) {
+				return false;
 			}
 		}
 
@@ -346,12 +336,12 @@ public:
 	template <typename Functor>
 	bool for_each_block_in_reverse(Functor& functor) const
 	{
-		for (block_t* block = UT_LIST_GET_LAST(m_list);
-		     block != NULL;
-		     block = UT_LIST_GET_PREV(m_node, block)) {
+		for (list_t::reverse_iterator it = m_list.rbegin(),
+					      end = m_list.rend();
+		     it != end; ++it) {
 
-			if (!functor(block)) {
-				return(false);
+			if (!functor(&*it)) {
+				return false;
 			}
 		}
 
@@ -364,12 +354,12 @@ public:
 	template <typename Functor>
 	bool for_each_block_in_reverse(const Functor& functor) const
 	{
-		for (block_t* block = UT_LIST_GET_LAST(m_list);
-		     block != NULL;
-		     block = UT_LIST_GET_PREV(m_node, block)) {
+		for (list_t::reverse_iterator it = m_list.rbegin(),
+					      end = m_list.rend();
+		     it != end; ++it) {
 
-			if (!functor(block)) {
-				return(false);
+			if (!functor(&*it)) {
+				return false;
 			}
 		}
 
@@ -381,8 +371,7 @@ public:
 	block_t* front()
 		MY_ATTRIBUTE((warn_unused_result))
 	{
-		ut_ad(UT_LIST_GET_LEN(m_list) > 0);
-		return(UT_LIST_GET_FIRST(m_list));
+		return &m_list.front();
 	}
 
 	/**
@@ -403,14 +392,13 @@ private:
 	void push_back(block_t* block)
 	{
 		block->init();
-
-		UT_LIST_ADD_LAST(m_list, block);
+		m_list.push_back(*block);
 	}
 
 	/** @return the last block in the list */
 	block_t* back() const
 	{
-		return(UT_LIST_GET_LAST(m_list));
+		return &const_cast<block_t&>(m_list.back());
 	}
 
 	/*
@@ -433,25 +421,21 @@ private:
 	@return the block containing the pos. */
 	block_t* find(ulint& pos)
 	{
-		block_t*	block;
+		ut_ad(!m_list.empty());
 
-		ut_ad(UT_LIST_GET_LEN(m_list) > 0);
+		for (list_t::iterator it = m_list.begin(), end = m_list.end();
+		     it != end; ++it) {
 
-		for (block = UT_LIST_GET_FIRST(m_list);
-		     block != NULL;
-		     block = UT_LIST_GET_NEXT(m_node, block)) {
+			if (pos < it->used()) {
+				ut_ad(it->used() >= pos);
 
-			if (pos < block->used()) {
-				break;
+				return &*it;
 			}
 
-			pos -= block->used();
+			pos -= it->used();
 		}
 
-		ut_ad(block != NULL);
-		ut_ad(block->used() >= pos);
-
-		return(block);
+		return NULL;
 	}
 
 	/**
@@ -477,7 +461,7 @@ private:
 	mem_heap_t*		m_heap;
 
 	/** Allocated blocks */
-	block_list_t		m_list;
+	list_t			m_list;
 
 	/** Total size used by all blocks */
 	ulint			m_size;
diff --git a/storage/innobase/include/fil0fil.h b/storage/innobase/include/fil0fil.h
index 0818d3f0ed1..d9840ea80f5 100644
--- a/storage/innobase/include/fil0fil.h
+++ b/storage/innobase/include/fil0fil.h
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1995, 2017, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2013, 2019, MariaDB Corporation.
+Copyright (c) 2013, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -32,6 +32,10 @@ Created 10/25/1995 Heikki Tuuri
 #include "log0recv.h"
 #include "dict0types.h"
 #include "page0size.h"
+#include "intrusive_list.h"
+
+struct unflushed_spaces_tag_t;
+struct rotation_list_tag_t;
 
 // Forward declaration
 extern my_bool srv_use_doublewrite_buf;
@@ -73,7 +77,9 @@ fil_type_is_data(
 struct fil_node_t;
 
 /** Tablespace or log data space */
-struct fil_space_t {
+struct fil_space_t : intrusive::list_node<unflushed_spaces_tag_t>,
+                     intrusive::list_node<rotation_list_tag_t>
+{
 	ulint		id;	/*!< space id */
 	hash_node_t	hash;	/*!< hash chain node */
 	char*		name;	/*!< Tablespace name */
@@ -151,9 +157,6 @@ struct fil_space_t {
 	ulint		n_pending_ios;
 	rw_lock_t	latch;	/*!< latch protecting the file space storage
 				allocation */
-	UT_LIST_NODE_T(fil_space_t) unflushed_spaces;
-				/*!< list of spaces with at least one unflushed
-				file we have written to */
 	UT_LIST_NODE_T(fil_space_t) named_spaces;
 				/*!< list of spaces for which MLOG_FILE_NAME
 				records have been issued */
@@ -162,8 +165,6 @@ struct fil_space_t {
 	bool is_in_unflushed_spaces() const;
 	UT_LIST_NODE_T(fil_space_t) space_list;
 				/*!< list of all spaces */
-	/** other tablespaces needing key rotation */
-	UT_LIST_NODE_T(fil_space_t) rotation_list;
 	/** Checks that this tablespace needs key rotation.
 	@return true if in a rotation list */
 	bool is_in_rotation_list() const;
@@ -350,7 +351,7 @@ struct fil_node_t {
 /** Value of fil_node_t::magic_n */
 #define	FIL_NODE_MAGIC_N	89389
 
-/** Common InnoDB file extentions */
+/** Common InnoDB file extensions */
 enum ib_extention {
 	NO_EXT = 0,
 	IBD = 1,
@@ -579,8 +580,6 @@ struct fil_system_t {
   {
     UT_LIST_INIT(LRU, &fil_node_t::LRU);
     UT_LIST_INIT(space_list, &fil_space_t::space_list);
-    UT_LIST_INIT(rotation_list, &fil_space_t::rotation_list);
-    UT_LIST_INIT(unflushed_spaces, &fil_space_t::unflushed_spaces);
     UT_LIST_INIT(named_spaces, &fil_space_t::named_spaces);
   }
 
@@ -616,8 +615,8 @@ public:
 					not put to this list: they are opened
 					after the startup, and kept open until
 					shutdown */
-	UT_LIST_BASE_NODE_T(fil_space_t) unflushed_spaces;
-					/*!< base node for the list of those
+	intrusive::list<fil_space_t, unflushed_spaces_tag_t> unflushed_spaces;
+					/*!< list of those
 					tablespaces whose files contain
 					unflushed writes; those spaces have
 					at least one file node where
@@ -637,7 +636,7 @@ public:
 					record has been written since
 					the latest redo log checkpoint.
 					Protected only by log_sys.mutex. */
-	UT_LIST_BASE_NODE_T(fil_space_t) rotation_list;
+	intrusive::list<fil_space_t, rotation_list_tag_t> rotation_list;
 					/*!< list of all file spaces needing
 					key rotation.*/
 
diff --git a/storage/innobase/include/fil0fil.ic b/storage/innobase/include/fil0fil.ic
index 457b5e1a03e..31466f38546 100644
--- a/storage/innobase/include/fil0fil.ic
+++ b/storage/innobase/include/fil0fil.ic
@@ -69,7 +69,7 @@ fil_get_page_type_name(
 	case FIL_PAGE_TYPE_ZBLOB2:
 		return "ZBLOB2";
 	case FIL_PAGE_TYPE_UNKNOWN:
-		return "OLD UNKOWN PAGE TYPE";
+		return "OLD UNKNOWN PAGE TYPE";
 	default:
 		return "PAGE TYPE CORRUPTED";
 	}
diff --git a/storage/innobase/include/gis0geo.h b/storage/innobase/include/gis0geo.h
index 3b71815d0fe..dea6d63f4e0 100644
--- a/storage/innobase/include/gis0geo.h
+++ b/storage/innobase/include/gis0geo.h
@@ -54,19 +54,6 @@ enum wkbByteOrder
   wkbNDR = 1     /* Little Endian */
 };
 
-/** Get the wkb of default POINT value, which represents POINT(0 0)
-if it's of dimension 2, etc.
-@param[in]	n_dims		dimensions
-@param[out]	wkb		wkb buffer for default POINT
-@param[in]	len		length of wkb buffer
-@return non-0 indicate the length of wkb of the default POINT,
-0 if the buffer is too small */
-uint
-get_wkb_of_default_point(
-	uint	n_dims,
-	uchar*	wkb,
-	uint	len);
-
 /*************************************************************//**
 Calculate minimal bounding rectangle (mbr) of the spatial object
 stored in "well-known binary representation" (wkb) format.
diff --git a/storage/innobase/include/gis0rtree.h b/storage/innobase/include/gis0rtree.h
index 126ca680c1d..b863f1cf3ef 100644
--- a/storage/innobase/include/gis0rtree.h
+++ b/storage/innobase/include/gis0rtree.h
@@ -28,6 +28,7 @@ Created 2013/03/27 Jimmy Yang and Allen Lai
 #define gis0rtree_h
 
 #include "btr0cur.h"
+#include "rem0types.h"
 
 /* Whether MBR 'a' contains 'b' */
 #define	MBR_CONTAIN_CMP(a, b)					\
@@ -88,7 +89,7 @@ rtr_page_split_and_insert(
 	btr_cur_t*	cursor,	/*!< in/out: cursor at which to insert; when the
 				function returns, the cursor is positioned
 				on the predecessor of the inserted record */
-	ulint**		offsets,/*!< out: offsets on inserted record */
+	offset_t**	offsets,/*!< out: offsets on inserted record */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap, or NULL */
 	const dtuple_t*	tuple,	/*!< in: tuple to insert */
 	ulint		n_ext,	/*!< in: number of externally stored columns */
@@ -150,7 +151,7 @@ rtr_rec_cal_increase(
 				dtuple in some of the common fields, or which
 				has an equal number or more fields than
 				dtuple */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	double*		area);	/*!< out: increased area */
 
 /****************************************************************//**
@@ -273,7 +274,7 @@ void
 rtr_get_mbr_from_rec(
 /*=================*/
 	const rec_t*	rec,	/*!< in: data tuple */
-	const ulint*	offsets,/*!< in: offsets array */
+	const offset_t*	offsets,/*!< in: offsets array */
 	rtr_mbr_t*	mbr);	/*!< out MBR */
 
 /****************************************************************//**
@@ -305,10 +306,10 @@ rtr_page_get_father(
 Returns the father block to a page. It is assumed that mtr holds
 an X or SX latch on the tree.
 @return rec_get_offsets() of the node pointer record */
-ulint*
+offset_t*
 rtr_page_get_father_block(
 /*======================*/
-	ulint*		offsets,/*!< in: work area for the return value */
+	offset_t*	offsets,/*!< in: work area for the return value */
 	mem_heap_t*	heap,	/*!< in: memory heap to use */
 	dict_index_t*	index,	/*!< in: b-tree index */
 	buf_block_t*	block,	/*!< in: child page in the index */
@@ -415,8 +416,8 @@ rtr_merge_and_update_mbr(
 /*=====================*/
 	btr_cur_t*		cursor,		/*!< in/out: cursor */
 	btr_cur_t*		cursor2,	/*!< in: the other cursor */
-	ulint*			offsets,	/*!< in: rec offsets */
-	ulint*			offsets2,	/*!< in: rec offsets */
+	offset_t*		offsets,	/*!< in: rec offsets */
+	offset_t*		offsets2,	/*!< in: rec offsets */
 	page_t*			child_page,	/*!< in: the child page. */
 	mtr_t*			mtr);		/*!< in: mtr */
 
@@ -436,8 +437,8 @@ rtr_merge_mbr_changed(
 /*==================*/
 	btr_cur_t*	cursor,		/*!< in: cursor */
 	btr_cur_t*	cursor2,	/*!< in: the other cursor */
-	ulint*		offsets,	/*!< in: rec offsets */
-	ulint*		offsets2,	/*!< in: rec offsets */
+	offset_t*	offsets,	/*!< in: rec offsets */
+	offset_t*	offsets2,	/*!< in: rec offsets */
 	rtr_mbr_t*	new_mbr);	/*!< out: MBR to update */
 
 
@@ -448,7 +449,7 @@ bool
 rtr_update_mbr_field(
 /*=================*/
 	btr_cur_t*	cursor,		/*!< in: cursor pointed to rec.*/
-	ulint*		offsets,	/*!< in: offsets on rec. */
+	offset_t*	offsets,	/*!< in: offsets on rec. */
 	btr_cur_t*	cursor2,	/*!< in/out: cursor pointed to rec
 					that should be deleted.
 					this cursor is for btr_compress to
diff --git a/storage/innobase/include/gis0rtree.ic b/storage/innobase/include/gis0rtree.ic
index d9309550a5f..03e23830e70 100644
--- a/storage/innobase/include/gis0rtree.ic
+++ b/storage/innobase/include/gis0rtree.ic
@@ -40,7 +40,7 @@ rtr_page_cal_mbr(
 	rec_t*		rec;
 	const byte*	field;
 	ulint		len;
-	ulint*		offsets = NULL;
+	offset_t*	offsets = NULL;
 	double		bmin, bmax;
 	double*		amin;
 	double*		amax;
diff --git a/storage/innobase/include/handler0alter.h b/storage/innobase/include/handler0alter.h
index 45811c591c9..9b70c607459 100644
--- a/storage/innobase/include/handler0alter.h
+++ b/storage/innobase/include/handler0alter.h
@@ -22,6 +22,8 @@ this program; if not, write to the Free Software Foundation, Inc.,
 Smart ALTER TABLE
 *******************************************************/
 
+#include "rem0types.h"
+
 /*************************************************************//**
 Copies an InnoDB record to table->record[0]. */
 void
@@ -30,7 +32,7 @@ innobase_rec_to_mysql(
 	struct TABLE*		table,	/*!< in/out: MySQL table */
 	const rec_t*		rec,	/*!< in: record */
 	const dict_index_t*	index,	/*!< in: index */
-	const ulint*		offsets)/*!< in: rec_get_offsets(
+	const offset_t*		offsets)/*!< in: rec_get_offsets(
 					rec, index, ...) */
 	MY_ATTRIBUTE((nonnull));
 
diff --git a/storage/innobase/include/hash0hash.h b/storage/innobase/include/hash0hash.h
index 5d317a23d4e..4f55b051d80 100644
--- a/storage/innobase/include/hash0hash.h
+++ b/storage/innobase/include/hash0hash.h
@@ -184,6 +184,18 @@ do {\
 	HASH_INVALIDATE(DATA, NAME);\
 } while (0)
 
+#define HASH_REPLACE(TYPE, NAME, TABLE, FOLD, DATA_OLD, DATA_NEW)             \
+	do {                                                                  \
+		(DATA_NEW)->NAME = (DATA_OLD)->NAME;                          \
+                                                                              \
+		hash_cell_t& cell3333                                         \
+			= TABLE->array[hash_calc_hash(FOLD, TABLE)];          \
+		TYPE** struct3333 = (TYPE**)&cell3333.node;                   \
+		while (*struct3333 != DATA_OLD) {                             \
+			struct3333 = &((*struct3333)->NAME);                  \
+		}                                                             \
+		*struct3333 = DATA_NEW;                                       \
+	} while (0)
 /*******************************************************************//**
 Gets the first struct in a hash chain, NULL if none. */
 
diff --git a/storage/innobase/include/lock0lock.h b/storage/innobase/include/lock0lock.h
index 8ae0b062729..11000620e8c 100644
--- a/storage/innobase/include/lock0lock.h
+++ b/storage/innobase/include/lock0lock.h
@@ -300,7 +300,7 @@ lock_clust_rec_modify_check_and_lock(
 	const rec_t*		rec,	/*!< in: record which should be
 					modified */
 	dict_index_t*		index,	/*!< in: clustered index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	que_thr_t*		thr)	/*!< in: query thread */
 	MY_ATTRIBUTE((warn_unused_result));
 /*********************************************************************//**
@@ -338,7 +338,7 @@ lock_sec_rec_read_check_and_lock(
 					be read or passed over by a
 					read cursor */
 	dict_index_t*		index,	/*!< in: secondary index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	lock_mode		mode,	/*!< in: mode of the lock which
 					the read cursor should set on
 					records: LOCK_S or LOCK_X; the
@@ -366,7 +366,7 @@ lock_clust_rec_read_check_and_lock(
 					be read or passed over by a
 					read cursor */
 	dict_index_t*		index,	/*!< in: clustered index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	lock_mode		mode,	/*!< in: mode of the lock which
 					the read cursor should set on
 					records: LOCK_S or LOCK_X; the
@@ -415,7 +415,7 @@ lock_clust_rec_cons_read_sees(
 	const rec_t*	rec,	/*!< in: user record which should be read or
 				passed over by a read cursor */
 	dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	ReadView*	view);	/*!< in: consistent read view */
 /*********************************************************************//**
 Checks that a non-clustered index record is seen in a consistent read.
@@ -547,7 +547,7 @@ lock_report_trx_id_insanity(
 	trx_id_t	trx_id,		/*!< in: trx id */
 	const rec_t*	rec,		/*!< in: user record */
 	dict_index_t*	index,		/*!< in: index */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec, index) */
 	trx_id_t	max_trx_id);	/*!< in: trx_sys.get_max_trx_id() */
 /*********************************************************************//**
 Prints info of locks for all transactions.
@@ -772,7 +772,7 @@ lock_check_trx_id_sanity(
 	trx_id_t	trx_id,		/*!< in: trx id */
 	const rec_t*	rec,		/*!< in: user record */
 	dict_index_t*	index,		/*!< in: index */
-	const ulint*	offsets);	/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets);	/*!< in: rec_get_offsets(rec, index) */
 #ifdef UNIV_DEBUG
 /*******************************************************************//**
 Check if the transaction holds any locks on the sys tables
diff --git a/storage/innobase/include/lock0priv.h b/storage/innobase/include/lock0priv.h
index 9b80f593e30..5e00e1bb6f1 100644
--- a/storage/innobase/include/lock0priv.h
+++ b/storage/innobase/include/lock0priv.h
@@ -35,6 +35,7 @@ those functions in lock/ */
 #endif
 
 #include "hash0hash.h"
+#include "rem0types.h"
 #include "trx0trx.h"
 
 #ifndef UINT32_MAX
@@ -468,7 +469,7 @@ lock_clust_rec_some_has_impl(
 /*=========================*/
 	const rec_t*		rec,	/*!< in: user record */
 	const dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*		offsets)/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets)/*!< in: rec_get_offsets(rec, index) */
 	MY_ATTRIBUTE((warn_unused_result));
 
 /*********************************************************************//**
diff --git a/storage/innobase/include/lock0priv.ic b/storage/innobase/include/lock0priv.ic
index 80a63271256..7062e3f7082 100644
--- a/storage/innobase/include/lock0priv.ic
+++ b/storage/innobase/include/lock0priv.ic
@@ -59,7 +59,7 @@ lock_clust_rec_some_has_impl(
 /*=========================*/
 	const rec_t*		rec,	/*!< in: user record */
 	const dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*		offsets)/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets)/*!< in: rec_get_offsets(rec, index) */
 {
 	ut_ad(dict_index_is_clust(index));
 	ut_ad(page_rec_is_user_rec(rec));
diff --git a/storage/innobase/include/log0recv.h b/storage/innobase/include/log0recv.h
index a4f8aab4e02..280f7840d50 100644
--- a/storage/innobase/include/log0recv.h
+++ b/storage/innobase/include/log0recv.h
@@ -119,14 +119,19 @@ bool recv_sys_add_to_parsing_buf(const byte* log_block, lsn_t scanned_lsn);
 
 /** Parse log records from a buffer and optionally store them to a
 hash table to wait merging to file pages.
-@param[in]	checkpoint_lsn	the LSN of the latest checkpoint
-@param[in]	store		whether to store page operations
-@param[in]	apply		whether to apply the records
+@param[in]	checkpoint_lsn		the LSN of the latest checkpoint
+@param[in]	store			whether to store page operations
+@param[in]	available_memory	memory to read the redo logs
+@param[in]	apply			whether to apply the records
 @return whether MLOG_CHECKPOINT record was seen the first time,
 or corruption was noticed */
-bool recv_parse_log_recs(lsn_t checkpoint_lsn, store_t store, bool apply);
+bool recv_parse_log_recs(
+	lsn_t		checkpoint_lsn,
+	store_t*	store,
+	ulint		available_memory,
+	bool		apply);
 
-/** Moves the parsing buffer data left to the buffer start. */
+/** Moves the parsing buffer data left to the buffer start */
 void recv_sys_justify_left_parsing_buf();
 
 /** Report optimized DDL operation (without redo log),
diff --git a/storage/innobase/include/mem0mem.h b/storage/innobase/include/mem0mem.h
index fa22b3d3086..18ae845955a 100644
--- a/storage/innobase/include/mem0mem.h
+++ b/storage/innobase/include/mem0mem.h
@@ -291,13 +291,6 @@ mem_heap_printf(
 	const char*	format,	/*!< in: format string */
 	...) MY_ATTRIBUTE ((format (printf, 2, 3)));
 
-/** Checks that an object is a memory heap (or a block of it)
-@param[in]	heap	Memory heap to check */
-UNIV_INLINE
-void
-mem_block_validate(
-	const mem_heap_t*	heap);
-
 #ifdef UNIV_DEBUG
 /** Validates the contents of a memory heap.
 Asserts that the memory heap is consistent
@@ -312,7 +305,6 @@ mem_heap_validate(
 
 /** The info structure stored at the beginning of a heap block */
 struct mem_block_info_t {
-	ulint	magic_n;/* magic number for debugging */
 #ifdef UNIV_DEBUG
 	char	file_name[8];/* file name where the mem heap was created */
 	unsigned line;	/*!< line number where the mem heap was created */
@@ -347,9 +339,6 @@ struct mem_block_info_t {
 			otherwise, this is NULL */
 };
 
-#define MEM_BLOCK_MAGIC_N	764741555
-#define MEM_FREED_BLOCK_MAGIC_N	547711122
-
 /* Header size for a memory heap block */
 #define MEM_BLOCK_HEADER_SIZE	UT_CALC_ALIGN(sizeof(mem_block_info_t),\
 					      UNIV_MEM_ALIGNMENT)
diff --git a/storage/innobase/include/mem0mem.ic b/storage/innobase/include/mem0mem.ic
index 3b4992a1a98..2a88c0f1065 100644
--- a/storage/innobase/include/mem0mem.ic
+++ b/storage/innobase/include/mem0mem.ic
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1994, 2014, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, MariaDB Corporation.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -144,16 +144,6 @@ mem_block_get_start(mem_block_t* block)
 	return(block->start);
 }
 
-/** Checks that an object is a memory heap block
-@param[in]	block	Memory block to check. */
-UNIV_INLINE
-void
-mem_block_validate(
-	const mem_block_t*	block)
-{
-	ut_a(block->magic_n == MEM_BLOCK_MAGIC_N);
-}
-
 /** Allocates and zero-fills n bytes of memory from a memory heap.
 @param[in]	heap	memory heap
 @param[in]	n	number of bytes; if the heap is allowed to grow into
@@ -186,8 +176,6 @@ mem_heap_alloc(
 	byte*		buf;
 	ulint		free;
 
-	ut_d(mem_block_validate(heap));
-
 	block = UT_LIST_GET_LAST(heap->base);
 
 	n += REDZONE_SIZE;
@@ -230,8 +218,6 @@ mem_heap_get_heap_top(
 	mem_block_t*	block;
 	byte*		buf;
 
-	ut_d(mem_block_validate(heap));
-
 	block = UT_LIST_GET_LAST(heap->base);
 
 	buf = (byte*) block + mem_block_get_free(block);
@@ -322,8 +308,6 @@ mem_heap_get_top(
 	mem_block_t*	block;
 	byte*		buf;
 
-	ut_d(mem_block_validate(heap));
-
 	block = UT_LIST_GET_LAST(heap->base);
 
 	buf = (byte*) block + mem_block_get_free(block) - MEM_SPACE_NEEDED(n);
@@ -343,8 +327,6 @@ mem_heap_free_top(
 {
 	mem_block_t*	block;
 
-	ut_d(mem_block_validate(heap));
-
 	n += REDZONE_SIZE;
 
 	block = UT_LIST_GET_LAST(heap->base);
@@ -420,8 +402,6 @@ mem_heap_free(
 	mem_block_t*	block;
 	mem_block_t*	prev_block;
 
-	ut_d(mem_block_validate(heap));
-
 	block = UT_LIST_GET_LAST(heap->base);
 
 	if (heap->free_block) {
@@ -448,11 +428,7 @@ mem_heap_get_size(
 /*==============*/
 	mem_heap_t*	heap)	/*!< in: heap */
 {
-	ulint		size	= 0;
-
-	ut_d(mem_block_validate(heap));
-
-	size = heap->total_size;
+	ulint size = heap->total_size;
 
 	if (heap->free_block) {
 		size += srv_page_size;
diff --git a/storage/innobase/include/mtr0log.h b/storage/innobase/include/mtr0log.h
index eaf2fad9e7f..dc76b40a3db 100644
--- a/storage/innobase/include/mtr0log.h
+++ b/storage/innobase/include/mtr0log.h
@@ -109,14 +109,6 @@ mlog_catenate_string(
 	const byte*	str,	/*!< in: string to write */
 	ulint		len);	/*!< in: string length */
 /********************************************************//**
-Catenates a compressed ulint to mlog. */
-UNIV_INLINE
-void
-mlog_catenate_ulint_compressed(
-/*===========================*/
-	mtr_t*		mtr,	/*!< in: mtr */
-	ulint		val);	/*!< in: value to write */
-/********************************************************//**
 Catenates a compressed 64-bit integer to mlog. */
 UNIV_INLINE
 void
diff --git a/storage/innobase/include/mtr0log.ic b/storage/innobase/include/mtr0log.ic
index b7ba92ff1a5..70bcaf43b9e 100644
--- a/storage/innobase/include/mtr0log.ic
+++ b/storage/innobase/include/mtr0log.ic
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, MariaDB Corporation.
+Copyright (c) 2017, 2019, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -118,30 +118,6 @@ mlog_catenate_ulint(
 }
 
 /********************************************************//**
-Catenates a compressed ulint to mlog. */
-UNIV_INLINE
-void
-mlog_catenate_ulint_compressed(
-/*===========================*/
-	mtr_t*	mtr,	/*!< in: mtr */
-	ulint	val)	/*!< in: value to write */
-{
-	byte*	log_ptr;
-
-	log_ptr = mlog_open(mtr, 10);
-
-	/* If no logging is requested, we may return now */
-	if (log_ptr == NULL) {
-
-		return;
-	}
-
-	log_ptr += mach_write_compressed(log_ptr, val);
-
-	mlog_close(mtr, log_ptr);
-}
-
-/********************************************************//**
 Catenates a compressed 64-bit integer to mlog. */
 UNIV_INLINE
 void
@@ -187,7 +163,6 @@ mlog_write_initial_log_record_low(
 	      || type == MLOG_FILE_CREATE2
 	      || type == MLOG_FILE_RENAME2
 	      || type == MLOG_INDEX_LOAD
-	      || type == MLOG_TRUNCATE
 	      || type == MLOG_FILE_WRITE_CRYPT_DATA
 	      || mtr->is_named_space(space_id));
 
diff --git a/storage/innobase/include/page0cur.h b/storage/innobase/include/page0cur.h
index f21506d0475..5accbcd76d5 100644
--- a/storage/innobase/include/page0cur.h
+++ b/storage/innobase/include/page0cur.h
@@ -29,6 +29,7 @@ Created 10/4/1994 Heikki Tuuri
 
 #include "buf0types.h"
 #include "page0page.h"
+#include "rem0types.h"
 #include "rem0rec.h"
 #include "data0data.h"
 #include "mtr0mtr.h"
@@ -151,7 +152,7 @@ page_cur_tuple_insert(
 	page_cur_t*	cursor,	/*!< in/out: a page cursor */
 	const dtuple_t*	tuple,	/*!< in: pointer to a data tuple */
 	dict_index_t*	index,	/*!< in: record descriptor */
-	ulint**		offsets,/*!< out: offsets on *rec */
+	offset_t**	offsets,/*!< out: offsets on *rec */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap, or NULL */
 	ulint		n_ext,	/*!< in: number of externally stored columns */
 	mtr_t*		mtr)	/*!< in: mini-transaction handle, or NULL */
@@ -175,7 +176,7 @@ page_cur_rec_insert(
 	page_cur_t*	cursor,	/*!< in/out: a page cursor */
 	const rec_t*	rec,	/*!< in: record to insert */
 	dict_index_t*	index,	/*!< in: record descriptor */
-	ulint*		offsets,/*!< in/out: rec_get_offsets(rec, index) */
+	offset_t*	offsets,/*!< in/out: rec_get_offsets(rec, index) */
 	mtr_t*		mtr);	/*!< in: mini-transaction handle, or NULL */
 /***********************************************************//**
 Inserts a record next to page cursor on an uncompressed page.
@@ -189,7 +190,7 @@ page_cur_insert_rec_low(
 				which the new record is inserted */
 	dict_index_t*	index,	/*!< in: record descriptor */
 	const rec_t*	rec,	/*!< in: pointer to a physical record */
-	ulint*		offsets,/*!< in/out: rec_get_offsets(rec, index) */
+	offset_t*	offsets,/*!< in/out: rec_get_offsets(rec, index) */
 	mtr_t*		mtr)	/*!< in: mini-transaction handle, or NULL */
 	MY_ATTRIBUTE((nonnull(1,2,3,4), warn_unused_result));
 
@@ -211,7 +212,7 @@ page_cur_insert_rec_zip(
 	page_cur_t*	cursor,	/*!< in/out: page cursor */
 	dict_index_t*	index,	/*!< in: record descriptor */
 	const rec_t*	rec,	/*!< in: pointer to a physical record */
-	ulint*		offsets,/*!< in/out: rec_get_offsets(rec, index) */
+	offset_t*	offsets,/*!< in/out: rec_get_offsets(rec, index) */
 	mtr_t*		mtr)	/*!< in: mini-transaction handle, or NULL */
 	MY_ATTRIBUTE((nonnull(1,2,3,4), warn_unused_result));
 /*************************************************************//**
@@ -237,7 +238,7 @@ page_cur_delete_rec(
 /*================*/
 	page_cur_t*		cursor,	/*!< in/out: a page cursor */
 	const dict_index_t*	index,	/*!< in: record descriptor */
-	const ulint*		offsets,/*!< in: rec_get_offsets(
+	const offset_t*		offsets,/*!< in: rec_get_offsets(
 					cursor->rec, index) */
 	mtr_t*			mtr);	/*!< in: mini-transaction handle */
 
@@ -385,14 +386,14 @@ page_delete_rec(
 	page_cur_t*		pcur,	/*!< in/out: page cursor on record
 					to delete */
 	page_zip_des_t*		page_zip,/*!< in: compressed page descriptor */
-	const ulint*		offsets);/*!< in: offsets for record */
+	const offset_t*		offsets);/*!< in: offsets for record */
 
 /** Index page cursor */
 
 struct page_cur_t{
 	const dict_index_t*	index;
 	rec_t*		rec;	/*!< pointer to a record on page */
-	ulint*		offsets;
+	offset_t*	offsets;
 	buf_block_t*	block;	/*!< pointer to the block containing rec */
 };
 
diff --git a/storage/innobase/include/page0cur.ic b/storage/innobase/include/page0cur.ic
index dff829089bb..1ccb7f9a80d 100644
--- a/storage/innobase/include/page0cur.ic
+++ b/storage/innobase/include/page0cur.ic
@@ -259,7 +259,7 @@ page_cur_tuple_insert(
 	page_cur_t*	cursor,	/*!< in/out: a page cursor */
 	const dtuple_t*	tuple,	/*!< in: pointer to a data tuple */
 	dict_index_t*	index,	/*!< in: record descriptor */
-	ulint**		offsets,/*!< out: offsets on *rec */
+	offset_t**	offsets,/*!< out: offsets on *rec */
 	mem_heap_t**	heap,	/*!< in/out: pointer to memory heap, or NULL */
 	ulint		n_ext,	/*!< in: number of externally stored columns */
 	mtr_t*		mtr)	/*!< in: mini-transaction handle, or NULL */
@@ -312,7 +312,7 @@ page_cur_rec_insert(
 	page_cur_t*	cursor,	/*!< in/out: a page cursor */
 	const rec_t*	rec,	/*!< in: record to insert */
 	dict_index_t*	index,	/*!< in: record descriptor */
-	ulint*		offsets,/*!< in/out: rec_get_offsets(rec, index) */
+	offset_t*	offsets,/*!< in/out: rec_get_offsets(rec, index) */
 	mtr_t*		mtr)	/*!< in: mini-transaction handle, or NULL */
 {
 	if (buf_block_get_page_zip(cursor->block)) {
diff --git a/storage/innobase/include/page0page.h b/storage/innobase/include/page0page.h
index e6df074e4a9..0876bc54aaf 100644
--- a/storage/innobase/include/page0page.h
+++ b/storage/innobase/include/page0page.h
@@ -1,6 +1,6 @@
 /*****************************************************************************
-Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2013, 2019, MariaDB Corporation.
+Copyright (c) 1994, 2019, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2013, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -32,6 +32,7 @@ Created 2/2/1994 Heikki Tuuri
 #include "buf0buf.h"
 #include "data0data.h"
 #include "dict0dict.h"
+#include "rem0types.h"
 #include "rem0rec.h"
 #endif /* !UNIV_INNOCHECKSUM*/
 #include "fsp0fsp.h"
@@ -857,6 +858,22 @@ page_rec_is_last(
 	MY_ATTRIBUTE((warn_unused_result));
 
 /************************************************************//**
+true if distance between the records (measured in number of times we have to
+move to the next record) is at most the specified value
+@param[in]	left_rec	lefter record
+@param[in]	right_rec	righter record
+@param[in]	val		specified value to compare
+@return true if the distance is smaller than the value */
+UNIV_INLINE
+bool
+page_rec_distance_is_at_most(
+/*=========================*/
+	const rec_t*	left_rec,
+	const rec_t*	right_rec,
+	ulint		val)
+	MY_ATTRIBUTE((warn_unused_result));
+
+/************************************************************//**
 true if the record is the second last user record on a page.
 @return true if the second last user record */
 UNIV_INLINE
@@ -963,7 +980,7 @@ page_mem_free(
 	rec_t*			rec,	/*!< in: pointer to the (origin of)
 					record */
 	const dict_index_t*	index,	/*!< in: index of rec */
-	const ulint*		offsets);/*!< in: array returned by
+	const offset_t*		offsets);/*!< in: array returned by
 					 rec_get_offsets() */
 
 /** Read the PAGE_DIRECTION field from a byte.
@@ -1223,7 +1240,7 @@ void
 page_rec_print(
 /*===========*/
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets);/*!< in: record descriptor */
+	const offset_t*	offsets);/*!< in: record descriptor */
 # ifdef UNIV_BTR_PRINT
 /***************************************************************//**
 This is used to print the contents of the directory for
@@ -1270,7 +1287,7 @@ ibool
 page_rec_validate(
 /*==============*/
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets);/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets);/*!< in: array returned by rec_get_offsets() */
 #ifdef UNIV_DEBUG
 /***************************************************************//**
 Checks that the first directory slot points to the infimum record and
diff --git a/storage/innobase/include/page0page.ic b/storage/innobase/include/page0page.ic
index e5368938531..94887a0925a 100644
--- a/storage/innobase/include/page0page.ic
+++ b/storage/innobase/include/page0page.ic
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
-Copyright (c) 1994, 2015, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2016, 2019, MariaDB Corporation.
+Copyright (c) 1994, 2019, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2016, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -359,6 +359,26 @@ page_rec_is_last(
 }
 
 /************************************************************//**
+true if distance between the records (measured in number of times we have to
+move to the next record) is at most the specified value */
+UNIV_INLINE
+bool
+page_rec_distance_is_at_most(
+/*=========================*/
+	const rec_t*	left_rec,
+	const rec_t*	right_rec,
+	ulint		val)
+{
+	for (ulint i = 0; i <= val; i++) {
+		if (left_rec == right_rec) {
+			return (true);
+		}
+		left_rec = page_rec_get_next_const(left_rec);
+	}
+	return (false);
+}
+
+/************************************************************//**
 true if the record is the second last user record on a page.
 @return true if the second last user record */
 UNIV_INLINE
@@ -660,6 +680,7 @@ page_rec_get_next_low(
 	}
 
 	ut_ad(page_rec_is_infimum(rec)
+	      || (!page_is_leaf(page) && !page_has_prev(page))
 	      || !(rec_get_info_bits(page + offs, comp)
 		   & REC_INFO_MIN_REC_FLAG));
 
@@ -1004,7 +1025,7 @@ page_mem_free(
 	rec_t*			rec,		/*!< in: pointer to the
 						(origin of) record */
 	const dict_index_t*	index,		/*!< in: index of rec */
-	const ulint*		offsets)	/*!< in: array returned by
+	const offset_t*		offsets)	/*!< in: array returned by
 						rec_get_offsets() */
 {
 	rec_t*		free;
diff --git a/storage/innobase/include/page0types.h b/storage/innobase/include/page0types.h
index 02d0cf29ec5..4debd639fa4 100644
--- a/storage/innobase/include/page0types.h
+++ b/storage/innobase/include/page0types.h
@@ -28,6 +28,7 @@ Created 2/2/1994 Heikki Tuuri
 
 #include "dict0types.h"
 #include "mtr0types.h"
+#include "rem0types.h"
 
 #include <map>
 
@@ -184,7 +185,7 @@ page_zip_dir_delete(
 	page_zip_des_t*	page_zip,/*!< in/out: compressed page */
 	byte*		rec,	/*!< in: deleted record */
 	dict_index_t*	index,	/*!< in: index of rec */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec) */
 	const byte*	free)	/*!< in: previous start of the free list */
 	MY_ATTRIBUTE((nonnull(1,2,3,4)));
 
diff --git a/storage/innobase/include/page0zip.h b/storage/innobase/include/page0zip.h
index 8672def36e6..899cc1aab22 100644
--- a/storage/innobase/include/page0zip.h
+++ b/storage/innobase/include/page0zip.h
@@ -47,6 +47,7 @@ Created June 2005 by Marko Makela
 #endif /* !UNIV_INNOCHECKSUM */
 
 #include "buf0types.h"
+#include "rem0types.h"
 
 #ifndef UNIV_INNOCHECKSUM
 #include "dict0types.h"
@@ -287,7 +288,7 @@ page_zip_write_rec(
 	page_zip_des_t*	page_zip,/*!< in/out: compressed page */
 	const byte*	rec,	/*!< in: record being written */
 	dict_index_t*	index,	/*!< in: the index the record belongs to */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	ulint		create)	/*!< in: nonzero=insert, zero=update */
 	MY_ATTRIBUTE((nonnull));
 
@@ -312,7 +313,7 @@ page_zip_write_blob_ptr(
 	const byte*	rec,	/*!< in/out: record whose data is being
 				written */
 	dict_index_t*	index,	/*!< in: index of the page */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	ulint		n,	/*!< in: column index */
 	mtr_t*		mtr);	/*!< in: mini-transaction handle,
 				or NULL if no logging is needed */
@@ -351,7 +352,7 @@ void
 page_zip_write_trx_id_and_roll_ptr(
 	page_zip_des_t*	page_zip,
 	byte*		rec,
-	const ulint*	offsets,
+	const offset_t*	offsets,
 	ulint		trx_id_col,
 	trx_id_t	trx_id,
 	roll_ptr_t	roll_ptr,
@@ -415,7 +416,7 @@ page_zip_dir_delete(
 	page_zip_des_t*		page_zip,	/*!< in/out: compressed page */
 	byte*			rec,		/*!< in: deleted record */
 	const dict_index_t*	index,		/*!< in: index of rec */
-	const ulint*		offsets,	/*!< in: rec_get_offsets(rec) */
+	const offset_t*		offsets,	/*!< in: rec_get_offsets(rec) */
 	const byte*		free)		/*!< in: previous start of
 						the free list */
 	MY_ATTRIBUTE((nonnull(1,2,3,4)));
diff --git a/storage/innobase/include/pars0grm.h b/storage/innobase/include/pars0grm.h
index 90a7468bc9a..58d424abfdc 100644
--- a/storage/innobase/include/pars0grm.h
+++ b/storage/innobase/include/pars0grm.h
@@ -1,8 +1,9 @@
-/* A Bison parser, made by GNU Bison 3.0.4.  */
+/* A Bison parser, made by GNU Bison 3.4.2.  */
 
 /* Bison interface for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
+   Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -30,6 +31,9 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
+/* Undocumented macros, especially those whose name start with YY_,
+   are private implementation details.  Do not rely on them.  */
+
 #ifndef YY_YY_PARS0GRM_TAB_H_INCLUDED
 # define YY_YY_PARS0GRM_TAB_H_INCLUDED
 /* Debug traces.  */
@@ -58,91 +62,71 @@ extern int yydebug;
     PARS_NE_TOKEN = 268,
     PARS_PROCEDURE_TOKEN = 269,
     PARS_IN_TOKEN = 270,
-    PARS_OUT_TOKEN = 271,
-    PARS_BINARY_TOKEN = 272,
-    PARS_BLOB_TOKEN = 273,
-    PARS_INT_TOKEN = 274,
-    PARS_FLOAT_TOKEN = 275,
-    PARS_CHAR_TOKEN = 276,
-    PARS_IS_TOKEN = 277,
-    PARS_BEGIN_TOKEN = 278,
-    PARS_END_TOKEN = 279,
-    PARS_IF_TOKEN = 280,
-    PARS_THEN_TOKEN = 281,
-    PARS_ELSE_TOKEN = 282,
-    PARS_ELSIF_TOKEN = 283,
-    PARS_LOOP_TOKEN = 284,
-    PARS_WHILE_TOKEN = 285,
-    PARS_RETURN_TOKEN = 286,
-    PARS_SELECT_TOKEN = 287,
-    PARS_SUM_TOKEN = 288,
-    PARS_COUNT_TOKEN = 289,
-    PARS_DISTINCT_TOKEN = 290,
-    PARS_FROM_TOKEN = 291,
-    PARS_WHERE_TOKEN = 292,
-    PARS_FOR_TOKEN = 293,
-    PARS_DDOT_TOKEN = 294,
-    PARS_READ_TOKEN = 295,
-    PARS_ORDER_TOKEN = 296,
-    PARS_BY_TOKEN = 297,
-    PARS_ASC_TOKEN = 298,
-    PARS_DESC_TOKEN = 299,
-    PARS_INSERT_TOKEN = 300,
-    PARS_INTO_TOKEN = 301,
-    PARS_VALUES_TOKEN = 302,
-    PARS_UPDATE_TOKEN = 303,
-    PARS_SET_TOKEN = 304,
-    PARS_DELETE_TOKEN = 305,
-    PARS_CURRENT_TOKEN = 306,
-    PARS_OF_TOKEN = 307,
-    PARS_CREATE_TOKEN = 308,
-    PARS_TABLE_TOKEN = 309,
-    PARS_INDEX_TOKEN = 310,
-    PARS_UNIQUE_TOKEN = 311,
-    PARS_CLUSTERED_TOKEN = 312,
-    PARS_ON_TOKEN = 313,
-    PARS_ASSIGN_TOKEN = 314,
-    PARS_DECLARE_TOKEN = 315,
-    PARS_CURSOR_TOKEN = 316,
-    PARS_SQL_TOKEN = 317,
-    PARS_OPEN_TOKEN = 318,
-    PARS_FETCH_TOKEN = 319,
-    PARS_CLOSE_TOKEN = 320,
-    PARS_NOTFOUND_TOKEN = 321,
-    PARS_TO_CHAR_TOKEN = 322,
-    PARS_TO_NUMBER_TOKEN = 323,
-    PARS_TO_BINARY_TOKEN = 324,
-    PARS_BINARY_TO_NUMBER_TOKEN = 325,
-    PARS_SUBSTR_TOKEN = 326,
-    PARS_REPLSTR_TOKEN = 327,
-    PARS_CONCAT_TOKEN = 328,
-    PARS_INSTR_TOKEN = 329,
-    PARS_LENGTH_TOKEN = 330,
-    PARS_SYSDATE_TOKEN = 331,
-    PARS_PRINTF_TOKEN = 332,
-    PARS_ASSERT_TOKEN = 333,
-    PARS_RND_TOKEN = 334,
-    PARS_RND_STR_TOKEN = 335,
-    PARS_ROW_PRINTF_TOKEN = 336,
-    PARS_COMMIT_TOKEN = 337,
-    PARS_ROLLBACK_TOKEN = 338,
-    PARS_WORK_TOKEN = 339,
-    PARS_UNSIGNED_TOKEN = 340,
-    PARS_EXIT_TOKEN = 341,
-    PARS_FUNCTION_TOKEN = 342,
-    PARS_LOCK_TOKEN = 343,
-    PARS_SHARE_TOKEN = 344,
-    PARS_MODE_TOKEN = 345,
-    PARS_LIKE_TOKEN = 346,
-    PARS_LIKE_TOKEN_EXACT = 347,
-    PARS_LIKE_TOKEN_PREFIX = 348,
-    PARS_LIKE_TOKEN_SUFFIX = 349,
-    PARS_LIKE_TOKEN_SUBSTR = 350,
-    PARS_TABLE_NAME_TOKEN = 351,
-    PARS_COMPACT_TOKEN = 352,
-    PARS_BLOCK_SIZE_TOKEN = 353,
-    PARS_BIGINT_TOKEN = 354,
-    NEG = 355
+    PARS_INT_TOKEN = 271,
+    PARS_CHAR_TOKEN = 272,
+    PARS_IS_TOKEN = 273,
+    PARS_BEGIN_TOKEN = 274,
+    PARS_END_TOKEN = 275,
+    PARS_IF_TOKEN = 276,
+    PARS_THEN_TOKEN = 277,
+    PARS_ELSE_TOKEN = 278,
+    PARS_ELSIF_TOKEN = 279,
+    PARS_LOOP_TOKEN = 280,
+    PARS_WHILE_TOKEN = 281,
+    PARS_RETURN_TOKEN = 282,
+    PARS_SELECT_TOKEN = 283,
+    PARS_COUNT_TOKEN = 284,
+    PARS_FROM_TOKEN = 285,
+    PARS_WHERE_TOKEN = 286,
+    PARS_FOR_TOKEN = 287,
+    PARS_DDOT_TOKEN = 288,
+    PARS_ORDER_TOKEN = 289,
+    PARS_BY_TOKEN = 290,
+    PARS_ASC_TOKEN = 291,
+    PARS_DESC_TOKEN = 292,
+    PARS_INSERT_TOKEN = 293,
+    PARS_INTO_TOKEN = 294,
+    PARS_VALUES_TOKEN = 295,
+    PARS_UPDATE_TOKEN = 296,
+    PARS_SET_TOKEN = 297,
+    PARS_DELETE_TOKEN = 298,
+    PARS_CURRENT_TOKEN = 299,
+    PARS_OF_TOKEN = 300,
+    PARS_CREATE_TOKEN = 301,
+    PARS_TABLE_TOKEN = 302,
+    PARS_INDEX_TOKEN = 303,
+    PARS_UNIQUE_TOKEN = 304,
+    PARS_CLUSTERED_TOKEN = 305,
+    PARS_ON_TOKEN = 306,
+    PARS_ASSIGN_TOKEN = 307,
+    PARS_DECLARE_TOKEN = 308,
+    PARS_CURSOR_TOKEN = 309,
+    PARS_SQL_TOKEN = 310,
+    PARS_OPEN_TOKEN = 311,
+    PARS_FETCH_TOKEN = 312,
+    PARS_CLOSE_TOKEN = 313,
+    PARS_NOTFOUND_TOKEN = 314,
+    PARS_TO_BINARY_TOKEN = 315,
+    PARS_SUBSTR_TOKEN = 316,
+    PARS_CONCAT_TOKEN = 317,
+    PARS_INSTR_TOKEN = 318,
+    PARS_LENGTH_TOKEN = 319,
+    PARS_COMMIT_TOKEN = 320,
+    PARS_ROLLBACK_TOKEN = 321,
+    PARS_WORK_TOKEN = 322,
+    PARS_EXIT_TOKEN = 323,
+    PARS_FUNCTION_TOKEN = 324,
+    PARS_LOCK_TOKEN = 325,
+    PARS_SHARE_TOKEN = 326,
+    PARS_MODE_TOKEN = 327,
+    PARS_LIKE_TOKEN = 328,
+    PARS_LIKE_TOKEN_EXACT = 329,
+    PARS_LIKE_TOKEN_PREFIX = 330,
+    PARS_LIKE_TOKEN_SUFFIX = 331,
+    PARS_LIKE_TOKEN_SUBSTR = 332,
+    PARS_TABLE_NAME_TOKEN = 333,
+    PARS_BIGINT_TOKEN = 334,
+    NEG = 335
   };
 #endif
 
diff --git a/storage/innobase/include/pars0pars.h b/storage/innobase/include/pars0pars.h
index 857c5c2742c..73a19dd24d8 100644
--- a/storage/innobase/include/pars0pars.h
+++ b/storage/innobase/include/pars0pars.h
@@ -48,29 +48,15 @@ extern int	yydebug;
 NOT re-entrant */
 extern sym_tab_t*	pars_sym_tab_global;
 
-extern pars_res_word_t	pars_to_char_token;
-extern pars_res_word_t	pars_to_number_token;
 extern pars_res_word_t	pars_to_binary_token;
-extern pars_res_word_t	pars_binary_to_number_token;
 extern pars_res_word_t	pars_substr_token;
-extern pars_res_word_t	pars_replstr_token;
 extern pars_res_word_t	pars_concat_token;
 extern pars_res_word_t	pars_length_token;
 extern pars_res_word_t	pars_instr_token;
-extern pars_res_word_t	pars_sysdate_token;
-extern pars_res_word_t	pars_printf_token;
-extern pars_res_word_t	pars_assert_token;
-extern pars_res_word_t	pars_rnd_token;
-extern pars_res_word_t	pars_rnd_str_token;
 extern pars_res_word_t	pars_count_token;
-extern pars_res_word_t	pars_sum_token;
-extern pars_res_word_t	pars_distinct_token;
-extern pars_res_word_t	pars_binary_token;
-extern pars_res_word_t	pars_blob_token;
 extern pars_res_word_t	pars_int_token;
 extern pars_res_word_t	pars_bigint_token;
 extern pars_res_word_t	pars_char_token;
-extern pars_res_word_t	pars_float_token;
 extern pars_res_word_t	pars_update_token;
 extern pars_res_word_t	pars_asc_token;
 extern pars_res_word_t	pars_desc_token;
@@ -236,17 +222,6 @@ pars_insert_statement(
 	que_node_t*	values_list,	/*!< in: value expression list or NULL */
 	sel_node_t*	select);	/*!< in: select condition or NULL */
 /*********************************************************************//**
-Parses a procedure parameter declaration.
-@return own: symbol table node of type SYM_VAR */
-sym_node_t*
-pars_parameter_declaration(
-/*=======================*/
-	sym_node_t*	node,	/*!< in: symbol table node allocated for the
-				id of the parameter */
-	ulint		param_type,
-				/*!< in: PARS_INPUT or PARS_OUTPUT */
-	pars_res_word_t* type);	/*!< in: pointer to a type token */
-/*********************************************************************//**
 Parses an elsif element.
 @return elsif node */
 elsif_node_t*
@@ -358,8 +333,6 @@ pars_column_def(
 	pars_res_word_t*	type,		/*!< in: data type */
 	sym_node_t*		len,		/*!< in: length of column, or
 						NULL */
-	void*			is_unsigned,	/*!< in: if not NULL, column
-						is of type UNSIGNED. */
 	void*			is_not_null);	/*!< in: if not NULL, column
 						is of type NOT NULL. */
 /*********************************************************************//**
@@ -370,9 +343,7 @@ pars_create_table(
 /*==============*/
 	sym_node_t*	table_sym,	/*!< in: table name node in the symbol
 					table */
-	sym_node_t*	column_defs,	/*!< in: list of column names */
-	sym_node_t*	compact,	/* in: non-NULL if COMPACT table. */
-	sym_node_t*	block_size);	/* in: block size (can be NULL) */
+	sym_node_t*	column_defs);	/*!< in: list of column names */
 /*********************************************************************//**
 Parses an index creation operation.
 @return index create subgraph */
@@ -394,7 +365,6 @@ pars_procedure_definition(
 /*======================*/
 	sym_node_t*	sym_node,	/*!< in: procedure id node in the symbol
 					table */
-	sym_node_t*	param_list,	/*!< in: parameter declaration list */
 	que_node_t*	stat_list);	/*!< in: statement list */
 
 /*************************************************************//**
@@ -672,7 +642,6 @@ struct proc_node_t{
 	que_common_t	common;		/*!< type: QUE_NODE_PROC */
 	sym_node_t*	proc_id;	/*!< procedure name symbol in the symbol
 					table of this same procedure */
-	sym_node_t*	param_list;	/*!< input and output parameters */
 	que_node_t*	stat_list;	/*!< statement list */
 	sym_tab_t*	sym_tab;	/*!< symbol table of this procedure */
 };
@@ -747,7 +716,7 @@ struct col_assign_node_t{
 #define	PARS_FUNC_LOGICAL	2	/*!< AND, OR, NOT */
 #define PARS_FUNC_CMP		3	/*!< comparison operators */
 #define	PARS_FUNC_PREDEFINED	4	/*!< TO_NUMBER, SUBSTR, ... */
-#define	PARS_FUNC_AGGREGATE	5	/*!< COUNT, DISTINCT, SUM */
+#define	PARS_FUNC_AGGREGATE	5	/*!< COUNT */
 #define	PARS_FUNC_OTHER		6	/*!< these are not real functions,
 					e.g., := */
 /* @} */
diff --git a/storage/innobase/include/rem0cmp.h b/storage/innobase/include/rem0cmp.h
index 9582b0df393..af1b145b0d9 100644
--- a/storage/innobase/include/rem0cmp.h
+++ b/storage/innobase/include/rem0cmp.h
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, MariaDB Corporation.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -80,7 +80,7 @@ cmp_dfield_dfield(
 
 /** Compare a GIS data tuple to a physical record.
 @param[in] dtuple data tuple
-@param[in] rec B-tree record
+@param[in] rec R-tree record
 @param[in] offsets rec_get_offsets(rec)
 @param[in] mode compare mode
 @retval negative if dtuple is less than rec */
@@ -89,7 +89,7 @@ cmp_dtuple_rec_with_gis(
 /*====================*/
 	const dtuple_t*	dtuple,
 	const rec_t*	rec,
-	const ulint*	offsets,
+	const offset_t*	offsets,
 	page_cur_mode_t	mode)
 	MY_ATTRIBUTE((nonnull));
 
@@ -105,7 +105,7 @@ int
 cmp_dtuple_rec_with_gis_internal(
 	const dtuple_t*	dtuple,
 	const rec_t*	rec,
-	const ulint*	offsets);
+	const offset_t*	offsets);
 
 /** Compare a data tuple to a physical record.
 @param[in] dtuple data tuple
@@ -121,7 +121,7 @@ int
 cmp_dtuple_rec_with_match_low(
 	const dtuple_t*	dtuple,
 	const rec_t*	rec,
-	const ulint*	offsets,
+	const offset_t*	offsets,
 	ulint		n_cmp,
 	ulint*		matched_fields)
 	MY_ATTRIBUTE((nonnull));
@@ -145,7 +145,7 @@ cmp_dtuple_rec_with_match_bytes(
 	const dtuple_t*		dtuple,
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	ulint*			matched_fields,
 	ulint*			matched_bytes)
 	MY_ATTRIBUTE((warn_unused_result));
@@ -162,7 +162,7 @@ int
 cmp_dtuple_rec(
 	const dtuple_t*	dtuple,
 	const rec_t*	rec,
-	const ulint*	offsets);
+	const offset_t*	offsets);
 /**************************************************************//**
 Checks if a dtuple is a prefix of a record. The last field in dtuple
 is allowed to be a prefix of the corresponding field in the record.
@@ -172,7 +172,7 @@ cmp_dtuple_is_prefix_of_rec(
 /*========================*/
 	const dtuple_t*	dtuple,	/*!< in: data tuple */
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets);/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets);/*!< in: array returned by rec_get_offsets() */
 /** Compare two physical records that contain the same number of columns,
 none of which are stored externally.
 @retval positive if rec1 (including non-ordering columns) is greater than rec2
@@ -183,58 +183,40 @@ cmp_rec_rec_simple(
 /*===============*/
 	const rec_t*		rec1,	/*!< in: physical record */
 	const rec_t*		rec2,	/*!< in: physical record */
-	const ulint*		offsets1,/*!< in: rec_get_offsets(rec1, ...) */
-	const ulint*		offsets2,/*!< in: rec_get_offsets(rec2, ...) */
+	const offset_t*		offsets1,/*!< in: rec_get_offsets(rec1, ...) */
+	const offset_t*		offsets2,/*!< in: rec_get_offsets(rec2, ...) */
 	const dict_index_t*	index,	/*!< in: data dictionary index */
 	struct TABLE*		table)	/*!< in: MySQL table, for reporting
 					duplicate key value if applicable,
 					or NULL */
 	MY_ATTRIBUTE((nonnull(1,2,3,4), warn_unused_result));
-/** Compare two B-tree records.
-@param[in] rec1 B-tree record
-@param[in] rec2 B-tree record
-@param[in] offsets1 rec_get_offsets(rec1, index)
-@param[in] offsets2 rec_get_offsets(rec2, index)
-@param[in] index B-tree index
-@param[in] nulls_unequal true if this is for index cardinality
-statistics estimation, and innodb_stats_method=nulls_unequal
-or innodb_stats_method=nulls_ignored
-@param[out] matched_fields number of completely matched fields
-within the first field not completely matched
-@return the comparison result
-@retval 0 if rec1 is equal to rec2
-@retval negative if rec1 is less than rec2
-@retval positive if rec2 is greater than rec2 */
-int
-cmp_rec_rec_with_match(
-	const rec_t*		rec1,
-	const rec_t*		rec2,
-	const ulint*		offsets1,
-	const ulint*		offsets2,
-	const dict_index_t*	index,
-	bool			nulls_unequal,
-	ulint*			matched_fields);
 
-/** Compare two B-tree records.
+/** Compare two B-tree or R-tree records.
 Only the common first fields are compared, and externally stored field
 are treated as equal.
-@param[in]	rec1		B-tree record
-@param[in]	rec2		B-tree record
+@param[in]	rec1		record (possibly not on an index page)
+@param[in]	rec2		B-tree or R-tree record in an index page
 @param[in]	offsets1	rec_get_offsets(rec1, index)
 @param[in]	offsets2	rec_get_offsets(rec2, index)
+@param[in]	nulls_unequal	true if this is for index cardinality
+				statistics estimation with
+				innodb_stats_method=nulls_unequal
+				or innodb_stats_method=nulls_ignored
 @param[out]	matched_fields	number of completely matched fields
 				within the first field not completely matched
-@return positive, 0, negative if rec1 is greater, equal, less, than rec2,
-respectively */
-UNIV_INLINE
+@retval 0 if rec1 is equal to rec2
+@retval negative if rec1 is less than rec2
+@retval positive if rec1 is greater than rec2 */
 int
 cmp_rec_rec(
 	const rec_t*		rec1,
 	const rec_t*		rec2,
-	const ulint*		offsets1,
-	const ulint*		offsets2,
+	const offset_t*		offsets1,
+	const offset_t*		offsets2,
 	const dict_index_t*	index,
-	ulint*			matched_fields = NULL);
+	bool			nulls_unequal = false,
+	ulint*			matched_fields = NULL)
+	MY_ATTRIBUTE((nonnull(1,2,3,4,5)));
 
 /** Compare two data fields.
 @param[in] dfield1 data field
diff --git a/storage/innobase/include/rem0cmp.ic b/storage/innobase/include/rem0cmp.ic
index 2412d22e8fa..4230543615a 100644
--- a/storage/innobase/include/rem0cmp.ic
+++ b/storage/innobase/include/rem0cmp.ic
@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1994, 2014, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -52,40 +53,6 @@ cmp_dfield_dfield(
 			     dfield_get_len(dfield2)));
 }
 
-/** Compare two B-tree records.
-Only the common first fields are compared, and externally stored field
-are treated as equal.
-@param[in]	rec1		B-tree record
-@param[in]	rec2		B-tree record
-@param[in]	offsets1	rec_get_offsets(rec1, index)
-@param[in]	offsets2	rec_get_offsets(rec2, index)
-@param[out]	matched_fields	number of completely matched fields
-				within the first field not completely matched
-@return positive, 0, negative if rec1 is greater, equal, less, than rec2,
-respectively */
-UNIV_INLINE
-int
-cmp_rec_rec(
-	const rec_t*		rec1,
-	const rec_t*		rec2,
-	const ulint*		offsets1,
-	const ulint*		offsets2,
-	const dict_index_t*	index,
-	ulint*			matched_fields)
-{
-	ulint	match_f;
-	int	ret;
-
-	ret = cmp_rec_rec_with_match(
-		rec1, rec2, offsets1, offsets2, index, false, &match_f);
-
-	if (matched_fields != NULL) {
-		*matched_fields = match_f;
-	}
-
-	return(ret);
-}
-
 /** Compare two data fields.
 @param[in] dfield1 data field
 @param[in] dfield2 data field
diff --git a/storage/innobase/include/rem0rec.h b/storage/innobase/include/rem0rec.h
index 0c49c223e10..4b7812e3bd6 100644
--- a/storage/innobase/include/rem0rec.h
+++ b/storage/innobase/include/rem0rec.h
@@ -90,45 +90,86 @@ The status is stored in the low-order bits. */
 /* Length of a B-tree node pointer, in bytes */
 #define REC_NODE_PTR_SIZE	4
 
+#ifndef UNIV_INNOCHECKSUM
 /** SQL null flag in a 1-byte offset of ROW_FORMAT=REDUNDANT records */
-#define REC_1BYTE_SQL_NULL_MASK	0x80UL
+static const offset_t REC_1BYTE_SQL_NULL_MASK= 0x80;
 /** SQL null flag in a 2-byte offset of ROW_FORMAT=REDUNDANT records */
-#define REC_2BYTE_SQL_NULL_MASK	0x8000UL
+static const offset_t REC_2BYTE_SQL_NULL_MASK= 0x8000;
 
 /** In a 2-byte offset of ROW_FORMAT=REDUNDANT records, the second most
 significant bit denotes that the tail of a field is stored off-page. */
-#define REC_2BYTE_EXTERN_MASK	0x4000UL
+static const offset_t REC_2BYTE_EXTERN_MASK= 0x4000;
+
+static const size_t RECORD_OFFSET= 2;
+static const size_t INDEX_OFFSET=
+    RECORD_OFFSET + sizeof(rec_t *) / sizeof(offset_t);
+#endif /* UNIV_INNOCHECKSUM */
 
-#ifdef UNIV_DEBUG
-/* Length of the rec_get_offsets() header */
-# define REC_OFFS_HEADER_SIZE	4
-#else /* UNIV_DEBUG */
 /* Length of the rec_get_offsets() header */
-# define REC_OFFS_HEADER_SIZE	2
+static const size_t REC_OFFS_HEADER_SIZE=
+#ifdef UNIV_DEBUG
+#ifndef UNIV_INNOCHECKSUM
+    sizeof(rec_t *) / sizeof(offset_t) +
+    sizeof(dict_index_t *) / sizeof(offset_t) +
+#endif /* UNIV_INNOCHECKSUM */
 #endif /* UNIV_DEBUG */
+    2;
 
 /* Number of elements that should be initially allocated for the
 offsets[] array, first passed to rec_get_offsets() */
-#define REC_OFFS_NORMAL_SIZE	OFFS_IN_REC_NORMAL_SIZE
-#define REC_OFFS_SMALL_SIZE	10
+static const size_t REC_OFFS_NORMAL_SIZE= 300;
+static const size_t REC_OFFS_SMALL_SIZE= 18;
+static const size_t REC_OFFS_SEC_INDEX_SIZE=
+    /* PK max key parts */ 16 + /* sec idx max key parts */ 16 +
+    /* child page number for non-leaf pages */ 1;
 
 /** Get the base address of offsets.  The extra_size is stored at
 this position, and following positions hold the end offsets of
 the fields. */
 #define rec_offs_base(offsets) (offsets + REC_OFFS_HEADER_SIZE)
 
+#ifndef UNIV_INNOCHECKSUM
+/* Offset consists of two parts: 2 upper bits is type and all other bits is
+value */
+
+/** Only 4 different values is possible! */
+enum field_type_t
+{
+  /** normal field */
+  STORED_IN_RECORD= 0 << 14,
+  /** this field is stored off-page */
+  STORED_OFFPAGE= 1 << 14,
+  /** just an SQL NULL */
+  SQL_NULL= 2 << 14,
+  /** instantly added field */
+  DEFAULT= 3 << 14,
+};
+
+/** without 2 upper bits */
+static const offset_t DATA_MASK= 0x3fff;
+/** 2 upper bits */
+static const offset_t TYPE_MASK= ~DATA_MASK;
+inline field_type_t get_type(offset_t n)
+{
+  return static_cast<field_type_t>(n & TYPE_MASK);
+}
+inline void set_type(offset_t &n, field_type_t type)
+{
+  n= (n & DATA_MASK) | static_cast<offset_t>(type);
+}
+inline offset_t get_value(offset_t n) { return n & DATA_MASK; }
+inline offset_t combine(offset_t value, field_type_t type)
+{
+  return get_value(value) | static_cast<offset_t>(type);
+}
+
 /** Compact flag ORed to the extra size returned by rec_get_offsets() */
-const ulint REC_OFFS_COMPACT = ~(ulint(~0) >> 1);
-/** SQL NULL flag in offsets returned by rec_get_offsets() */
-const ulint REC_OFFS_SQL_NULL = REC_OFFS_COMPACT;
+const offset_t REC_OFFS_COMPACT= ~(offset_t(~0) >> 1);
 /** External flag in offsets returned by rec_get_offsets() */
-const ulint REC_OFFS_EXTERNAL = REC_OFFS_COMPACT >> 1;
+const offset_t REC_OFFS_EXTERNAL= REC_OFFS_COMPACT >> 1;
 /** Default value flag in offsets returned by rec_get_offsets() */
-const ulint REC_OFFS_DEFAULT = REC_OFFS_COMPACT >> 2;
-/** Mask for offsets returned by rec_get_offsets() */
-const ulint REC_OFFS_MASK = REC_OFFS_DEFAULT - 1;
-
-#ifndef UNIV_INNOCHECKSUM
+const offset_t REC_OFFS_DEFAULT= REC_OFFS_COMPACT >> 2;
+const offset_t REC_OFFS_MASK= REC_OFFS_DEFAULT - 1;
 /******************************************************//**
 The following function is used to get the pointer of the next chained record
 on the same page.
@@ -463,7 +504,7 @@ offsets form. If the field is SQL null, the flag is ORed in the returned
 value.
 @return offset of the start of the field, SQL null flag ORed */
 UNIV_INLINE
-ulint
+uint8_t
 rec_1_get_field_end_info(
 /*=====================*/
 	const rec_t*	rec,	/*!< in: record */
@@ -477,7 +518,7 @@ value.
 @return offset of the start of the field, SQL null flag and extern
 storage flag ORed */
 UNIV_INLINE
-ulint
+uint16_t
 rec_2_get_field_end_info(
 /*=====================*/
 	const rec_t*	rec,	/*!< in: record */
@@ -518,11 +559,11 @@ rec_get_n_extern_new(
 				(ULINT_UNDEFINED to compute all offsets)
 @param[in,out]	heap		memory heap
 @return the new offsets */
-ulint*
+offset_t*
 rec_get_offsets_func(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	ulint*			offsets,
+	offset_t*		offsets,
 	bool			leaf,
 	ulint			n_fields,
 #ifdef UNIV_DEBUG
@@ -557,7 +598,7 @@ rec_get_offsets_reverse(
 	const dict_index_t*	index,	/*!< in: record descriptor */
 	ulint			node_ptr,/*!< in: nonzero=node pointer,
 					0=leaf node */
-	ulint*			offsets)/*!< in/out: array consisting of
+	offset_t*		offsets)/*!< in/out: array consisting of
 					offsets[0] allocated elements */
 	MY_ATTRIBUTE((nonnull));
 #ifdef UNIV_DEBUG
@@ -570,7 +611,7 @@ bool
 rec_offs_validate(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	const ulint*		offsets)
+	const offset_t*		offsets)
 	MY_ATTRIBUTE((nonnull(3), warn_unused_result));
 /** Update debug data in offsets, in order to tame rec_offs_validate().
 @param[in]	rec	record
@@ -582,7 +623,7 @@ rec_offs_make_valid(
 	const rec_t*		rec,
 	const dict_index_t*	index,
 	bool			leaf,
-	ulint*			offsets)
+	offset_t*		offsets)
 	MY_ATTRIBUTE((nonnull));
 #else
 # define rec_offs_make_valid(rec, index, leaf, offsets)
@@ -619,17 +660,16 @@ The following function is used to get an offset to the nth
 data field in a record.
 @return offset from the origin of rec */
 UNIV_INLINE
-ulint
+offset_t
 rec_get_nth_field_offs(
 /*===================*/
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		n,	/*!< in: index of the field */
 	ulint*		len)	/*!< out: length of the field; UNIV_SQL_NULL
 				if SQL null */
 	MY_ATTRIBUTE((nonnull));
 #define rec_get_nth_field(rec, offsets, n, len) \
 ((rec) + rec_get_nth_field_offs(offsets, n, len))
-
 /******************************************************//**
 Determine if the offsets are for a record containing null BLOB pointers.
 @return first field containing a null BLOB pointer, or NULL if none found */
@@ -638,7 +678,7 @@ const byte*
 rec_offs_any_null_extern(
 /*=====================*/
 	const rec_t*	rec,		/*!< in: record */
-	const ulint*	offsets)	/*!< in: rec_get_offsets(rec) */
+	const offset_t*	offsets)	/*!< in: rec_get_offsets(rec) */
 	MY_ATTRIBUTE((warn_unused_result));
 
 /** Mark the nth field as externally stored.
@@ -646,7 +686,7 @@ rec_offs_any_null_extern(
 @param[in]	n		nth field */
 void
 rec_offs_make_nth_extern(
-        ulint*		offsets,
+        offset_t*	offsets,
         const ulint     n);
 
 /** Determine the number of allocated elements for an array of offsets.
@@ -654,7 +694,7 @@ rec_offs_make_nth_extern(
 @return number of elements */
 inline
 ulint
-rec_offs_get_n_alloc(const ulint* offsets)
+rec_offs_get_n_alloc(const offset_t* offsets)
 {
 	ulint	n_alloc;
 	ut_ad(offsets);
@@ -669,7 +709,7 @@ rec_offs_get_n_alloc(const ulint* offsets)
 @return number of fields */
 inline
 ulint
-rec_offs_n_fields(const ulint* offsets)
+rec_offs_n_fields(const offset_t* offsets)
 {
 	ulint	n_fields;
 	ut_ad(offsets);
@@ -685,19 +725,12 @@ rec_offs_n_fields(const ulint* offsets)
 @param[in]	offsets	rec_get_offsets()
 @param[in]	n	nth field
 @param[in]	flag	flag to extract
-@return	the flag of the record field */
-inline
-ulint
-rec_offs_nth_flag(const ulint* offsets, ulint n, ulint flag)
+@return	type of the record field */
+inline field_type_t rec_offs_nth_type(const offset_t *offsets, ulint n)
 {
-	ut_ad(rec_offs_validate(NULL, NULL, offsets));
-	ut_ad(n < rec_offs_n_fields(offsets));
-	/* The DEFAULT, NULL, EXTERNAL flags are mutually exclusive. */
-	ut_ad(ut_is_2pow(rec_offs_base(offsets)[1 + n]
-			 & (REC_OFFS_DEFAULT
-			    | REC_OFFS_SQL_NULL
-			    | REC_OFFS_EXTERNAL)));
-	return rec_offs_base(offsets)[1 + n] & flag;
+  ut_ad(rec_offs_validate(NULL, NULL, offsets));
+  ut_ad(n < rec_offs_n_fields(offsets));
+  return get_type(rec_offs_base(offsets)[1 + n]);
 }
 
 /** Determine if a record field is missing
@@ -705,11 +738,9 @@ rec_offs_nth_flag(const ulint* offsets, ulint n, ulint flag)
 @param[in]	offsets	rec_get_offsets()
 @param[in]	n	nth field
 @return	nonzero if default bit is set */
-inline
-ulint
-rec_offs_nth_default(const ulint* offsets, ulint n)
+inline ulint rec_offs_nth_default(const offset_t *offsets, ulint n)
 {
-	return rec_offs_nth_flag(offsets, n, REC_OFFS_DEFAULT);
+  return rec_offs_nth_type(offsets, n) == DEFAULT;
 }
 
 /** Determine if a record field is SQL NULL
@@ -717,11 +748,9 @@ rec_offs_nth_default(const ulint* offsets, ulint n)
 @param[in]	offsets	rec_get_offsets()
 @param[in]	n	nth field
 @return	nonzero if SQL NULL set */
-inline
-ulint
-rec_offs_nth_sql_null(const ulint* offsets, ulint n)
+inline ulint rec_offs_nth_sql_null(const offset_t *offsets, ulint n)
 {
-	return rec_offs_nth_flag(offsets, n, REC_OFFS_SQL_NULL);
+  return rec_offs_nth_type(offsets, n) == SQL_NULL;
 }
 
 /** Determine if a record field is stored off-page.
@@ -729,54 +758,46 @@ rec_offs_nth_sql_null(const ulint* offsets, ulint n)
 @param[in]	n	nth field
 Returns nonzero if the extern bit is set in nth field of rec.
 @return nonzero if externally stored */
-inline
-ulint
-rec_offs_nth_extern(const ulint* offsets, ulint n)
+inline ulint rec_offs_nth_extern(const offset_t *offsets, ulint n)
 {
-	return rec_offs_nth_flag(offsets, n, REC_OFFS_EXTERNAL);
+  return rec_offs_nth_type(offsets, n) == STORED_OFFPAGE;
 }
 
 /** Get a global flag of a record.
 @param[in]	offsets	rec_get_offsets()
 @param[in]	flag	flag to extract
 @return	the flag of the record field */
-inline
-ulint
-rec_offs_any_flag(const ulint* offsets, ulint flag)
+inline ulint rec_offs_any_flag(const offset_t *offsets, ulint flag)
 {
-	ut_ad(rec_offs_validate(NULL, NULL, offsets));
-	return *rec_offs_base(offsets) & flag;
+  ut_ad(rec_offs_validate(NULL, NULL, offsets));
+  return *rec_offs_base(offsets) & flag;
 }
 
 /** Determine if the offsets are for a record containing off-page columns.
 @param[in]	offsets	rec_get_offsets()
 @return nonzero if any off-page columns exist */
-inline bool rec_offs_any_extern(const ulint* offsets)
+inline bool rec_offs_any_extern(const offset_t *offsets)
 {
-	return rec_offs_any_flag(offsets, REC_OFFS_EXTERNAL);
+  return rec_offs_any_flag(offsets, REC_OFFS_EXTERNAL);
 }
 
 /** Determine if the offsets are for a record that is missing fields.
 @param[in]	offsets	rec_get_offsets()
 @return nonzero if any fields need to be replaced with
 		dict_index_t::instant_field_value() */
-inline
-ulint
-rec_offs_any_default(const ulint* offsets)
+inline ulint rec_offs_any_default(const offset_t *offsets)
 {
-	return rec_offs_any_flag(offsets, REC_OFFS_DEFAULT);
+  return rec_offs_any_flag(offsets, REC_OFFS_DEFAULT);
 }
 
 /** Determine if the offsets are for other than ROW_FORMAT=REDUNDANT.
 @param[in]	offsets	rec_get_offsets()
 @return	nonzero	if ROW_FORMAT is COMPACT,DYNAMIC or COMPRESSED
 @retval	0	if ROW_FORMAT=REDUNDANT */
-inline
-ulint
-rec_offs_comp(const ulint* offsets)
+inline ulint rec_offs_comp(const offset_t *offsets)
 {
-	ut_ad(rec_offs_validate(NULL, NULL, offsets));
-	return(*rec_offs_base(offsets) & REC_OFFS_COMPACT);
+  ut_ad(rec_offs_validate(NULL, NULL, offsets));
+  return (*rec_offs_base(offsets) & REC_OFFS_COMPACT);
 }
 
 /** Determine if the record is the metadata pseudo-record
@@ -806,7 +827,7 @@ const byte*
 rec_get_nth_cfield(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	ulint			n,
 	ulint*			len)
 {
@@ -824,7 +845,7 @@ UNIV_INLINE
 ulint
 rec_offs_nth_size(
 /*==============*/
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		n)	/*!< in: nth field */
 	MY_ATTRIBUTE((warn_unused_result));
 
@@ -835,7 +856,7 @@ UNIV_INLINE
 ulint
 rec_offs_n_extern(
 /*==============*/
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 	MY_ATTRIBUTE((warn_unused_result));
 /***********************************************************//**
 This is used to modify the value of an already existing field in a record.
@@ -848,7 +869,7 @@ void
 rec_set_nth_field(
 /*==============*/
 	rec_t*		rec,	/*!< in: record */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		n,	/*!< in: index number of the field */
 	const void*	data,	/*!< in: pointer to the data if not SQL null */
 	ulint		len)	/*!< in: length of the data or UNIV_SQL_NULL.
@@ -876,7 +897,7 @@ UNIV_INLINE
 void
 rec_offs_set_n_alloc(
 /*=================*/
-	ulint*	offsets,	/*!< out: array for rec_get_offsets(),
+	offset_t*offsets,	/*!< out: array for rec_get_offsets(),
 				must be allocated */
 	ulint	n_alloc)	/*!< in: number of elements */
 	MY_ATTRIBUTE((nonnull));
@@ -892,7 +913,7 @@ UNIV_INLINE
 ulint
 rec_offs_data_size(
 /*===============*/
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 	MY_ATTRIBUTE((warn_unused_result));
 /**********************************************************//**
 Returns the total size of record minus data size of record.
@@ -903,7 +924,7 @@ UNIV_INLINE
 ulint
 rec_offs_extra_size(
 /*================*/
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 	MY_ATTRIBUTE((warn_unused_result));
 /**********************************************************//**
 Returns the total size of a physical record.
@@ -912,7 +933,7 @@ UNIV_INLINE
 ulint
 rec_offs_size(
 /*==========*/
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 	MY_ATTRIBUTE((warn_unused_result));
 #ifdef UNIV_DEBUG
 /**********************************************************//**
@@ -923,7 +944,7 @@ byte*
 rec_get_start(
 /*==========*/
 	const rec_t*	rec,	/*!< in: pointer to record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 	MY_ATTRIBUTE((warn_unused_result));
 /**********************************************************//**
 Returns a pointer to the end of the record.
@@ -933,7 +954,7 @@ byte*
 rec_get_end(
 /*========*/
 	const rec_t*	rec,	/*!< in: pointer to record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 	MY_ATTRIBUTE((warn_unused_result));
 #else /* UNIV_DEBUG */
 # define rec_get_start(rec, offsets) ((rec) - rec_offs_extra_size(offsets))
@@ -950,7 +971,7 @@ rec_t*
 rec_copy(
 	void*		buf,
 	const rec_t*	rec,
-	const ulint*	offsets);
+	const offset_t*	offsets);
 
 /** Determine the size of a data tuple prefix in a temporary file.
 @param[in]	index		clustered or secondary index
@@ -979,7 +1000,7 @@ void
 rec_init_offsets_temp(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	ulint*			offsets,
+	offset_t*		offsets,
 	ulint			n_core,
 	const dict_col_t::def_t*def_val,
 	rec_comp_status_t	status = REC_STATUS_ORDINARY)
@@ -993,7 +1014,7 @@ void
 rec_init_offsets_temp(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	ulint*			offsets)
+	offset_t*		offsets)
 	MY_ATTRIBUTE((nonnull));
 
 /** Convert a data tuple prefix to the temporary file format.
@@ -1115,7 +1136,7 @@ ibool
 rec_validate(
 /*=========*/
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 	MY_ATTRIBUTE((nonnull));
 /***************************************************************//**
 Prints an old-style physical record. */
@@ -1132,7 +1153,7 @@ rec_print_mbr_rec(
 /*==========*/
 	FILE*		file,	/*!< in: file where to print */
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 	MY_ATTRIBUTE((nonnull));
 /***************************************************************//**
 Prints a physical record. */
@@ -1141,7 +1162,7 @@ rec_print_new(
 /*==========*/
 	FILE*		file,	/*!< in: file where to print */
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 	MY_ATTRIBUTE((nonnull));
 /***************************************************************//**
 Prints a physical record. */
@@ -1163,7 +1184,7 @@ rec_print(
 	std::ostream&	o,
 	const rec_t*	rec,
 	ulint		info,
-	const ulint*	offsets);
+	const offset_t*	offsets);
 
 /** Wrapper for pretty-printing a record */
 struct rec_index_print
@@ -1190,14 +1211,14 @@ operator<<(std::ostream& o, const rec_index_print& r);
 struct rec_offsets_print
 {
 	/** Constructor */
-	rec_offsets_print(const rec_t* rec, const ulint* offsets) :
+	rec_offsets_print(const rec_t* rec, const offset_t* offsets) :
 		m_rec(rec), m_offsets(offsets)
 	{}
 
 	/** Record */
 	const rec_t*		m_rec;
 	/** Offsets to each field */
-	const ulint*		m_offsets;
+	const offset_t*		m_offsets;
 };
 
 /** Display a record.
@@ -1214,7 +1235,7 @@ public:
 	/** Construct a pretty-printed record.
 	@param rec	record with header
 	@param offsets	rec_get_offsets(rec, ...) */
-	rec_printer(const rec_t* rec, const ulint* offsets)
+	rec_printer(const rec_t* rec, const offset_t* offsets)
 		:
 		std::ostringstream ()
 	{
@@ -1227,7 +1248,7 @@ public:
 	@param rec record, possibly lacking header
 	@param info rec_get_info_bits(rec)
 	@param offsets rec_get_offsets(rec, ...) */
-	rec_printer(const rec_t* rec, ulint info, const ulint* offsets)
+	rec_printer(const rec_t* rec, ulint info, const offset_t* offsets)
 		:
 		std::ostringstream ()
 	{
diff --git a/storage/innobase/include/rem0rec.ic b/storage/innobase/include/rem0rec.ic
index 17dd8aa3d7a..1564bdfdcc0 100644
--- a/storage/innobase/include/rem0rec.ic
+++ b/storage/innobase/include/rem0rec.ic
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
-Copyright (c) 1994, 2015, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, 2019, MariaDB Corporation.
+Copyright (c) 1994, 2019, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -816,7 +816,7 @@ offsets form. If the field is SQL null, the flag is ORed in the returned
 value.
 @return offset of the start of the field, SQL null flag ORed */
 UNIV_INLINE
-ulint
+uint8_t
 rec_1_get_field_end_info(
 /*=====================*/
 	const rec_t*	rec,	/*!< in: record */
@@ -835,7 +835,7 @@ value.
 @return offset of the start of the field, SQL null flag and extern
 storage flag ORed */
 UNIV_INLINE
-ulint
+uint16_t
 rec_2_get_field_end_info(
 /*=====================*/
 	const rec_t*	rec,	/*!< in: record */
@@ -868,13 +868,13 @@ UNIV_INLINE
 void
 rec_offs_set_n_alloc(
 /*=================*/
-	ulint*	offsets,	/*!< out: array for rec_get_offsets(),
+	offset_t*offsets,	/*!< out: array for rec_get_offsets(),
 				must be allocated */
 	ulint	n_alloc)	/*!< in: number of elements */
 {
 	ut_ad(n_alloc > REC_OFFS_HEADER_SIZE);
 	UNIV_MEM_ALLOC(offsets, n_alloc * sizeof *offsets);
-	offsets[0] = n_alloc;
+	offsets[0] = static_cast<offset_t>(n_alloc);
 }
 
 /************************************************************//**
@@ -882,36 +882,27 @@ The following function is used to get an offset to the nth
 data field in a record.
 @return offset from the origin of rec */
 UNIV_INLINE
-ulint
+offset_t
 rec_get_nth_field_offs(
 /*===================*/
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		n,	/*!< in: index of the field */
 	ulint*		len)	/*!< out: length of the field; UNIV_SQL_NULL
 				if SQL null; UNIV_SQL_DEFAULT is default value */
 {
-	ulint	offs;
-	ulint	length;
 	ut_ad(n < rec_offs_n_fields(offsets));
 
-	if (n == 0) {
-		offs = 0;
-	} else {
-		offs = rec_offs_base(offsets)[n] & REC_OFFS_MASK;
-	}
-
-	length = rec_offs_base(offsets)[1 + n];
+	offset_t offs = n == 0 ? 0 : get_value(rec_offs_base(offsets)[n]);
+	offset_t next_offs = rec_offs_base(offsets)[1 + n];
 
-	if (length & REC_OFFS_SQL_NULL) {
-		length = UNIV_SQL_NULL;
-	} else if (length & REC_OFFS_DEFAULT) {
-		length = UNIV_SQL_DEFAULT;
+	if (get_type(next_offs) == SQL_NULL) {
+		*len = UNIV_SQL_NULL;
+	} else if (get_type(next_offs) == DEFAULT) {
+		*len = UNIV_SQL_DEFAULT;
 	} else {
-		length &= REC_OFFS_MASK;
-		length -= offs;
+		*len = get_value(next_offs) - offs;
 	}
 
-	*len = length;
 	return(offs);
 }
 
@@ -923,7 +914,7 @@ const byte*
 rec_offs_any_null_extern(
 /*=====================*/
 	const rec_t*	rec,		/*!< in: record */
-	const ulint*	offsets)	/*!< in: rec_get_offsets(rec) */
+	const offset_t*	offsets)	/*!< in: rec_get_offsets(rec) */
 {
 	ulint	i;
 	ut_ad(rec_offs_validate(rec, NULL, offsets));
@@ -958,16 +949,16 @@ UNIV_INLINE
 ulint
 rec_offs_nth_size(
 /*==============*/
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		n)	/*!< in: nth field */
 {
 	ut_ad(rec_offs_validate(NULL, NULL, offsets));
 	ut_ad(n < rec_offs_n_fields(offsets));
 	if (!n) {
-		return(rec_offs_base(offsets)[1 + n] & REC_OFFS_MASK);
+		return get_value(rec_offs_base(offsets)[1 + n]);
 	}
-	return((rec_offs_base(offsets)[1 + n] - rec_offs_base(offsets)[n])
-	       & REC_OFFS_MASK);
+	return get_value((rec_offs_base(offsets)[1 + n]))
+	       - get_value(rec_offs_base(offsets)[n]);
 }
 
 /******************************************************//**
@@ -977,7 +968,7 @@ UNIV_INLINE
 ulint
 rec_offs_n_extern(
 /*==============*/
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ulint	n = 0;
 
@@ -1175,7 +1166,7 @@ void
 rec_set_nth_field(
 /*==============*/
 	rec_t*		rec,	/*!< in: record */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		n,	/*!< in: index number of the field */
 	const void*	data,	/*!< in: pointer to the data
 				if not SQL null */
@@ -1231,16 +1222,16 @@ UNIV_INLINE
 void
 rec_offs_set_n_fields(
 /*==================*/
-	ulint*	offsets,	/*!< in/out: array returned by
+	offset_t*	offsets,	/*!< in/out: array returned by
 				rec_get_offsets() */
-	ulint	n_fields)	/*!< in: number of fields */
+	ulint		n_fields)	/*!< in: number of fields */
 {
 	ut_ad(offsets);
 	ut_ad(n_fields > 0);
 	ut_ad(n_fields <= REC_MAX_N_FIELDS);
 	ut_ad(n_fields + REC_OFFS_HEADER_SIZE
 	      <= rec_offs_get_n_alloc(offsets));
-	offsets[1] = n_fields;
+	offsets[1] = static_cast<offset_t>(n_fields);
 }
 
 /**********************************************************//**
@@ -1253,13 +1244,12 @@ UNIV_INLINE
 ulint
 rec_offs_data_size(
 /*===============*/
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ulint	size;
 
 	ut_ad(rec_offs_validate(NULL, NULL, offsets));
-	size = rec_offs_base(offsets)[rec_offs_n_fields(offsets)]
-		& REC_OFFS_MASK;
+	size = get_value(rec_offs_base(offsets)[rec_offs_n_fields(offsets)]);
 	ut_ad(size < srv_page_size);
 	return(size);
 }
@@ -1273,7 +1263,7 @@ UNIV_INLINE
 ulint
 rec_offs_extra_size(
 /*================*/
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ulint	size;
 	ut_ad(rec_offs_validate(NULL, NULL, offsets));
@@ -1289,7 +1279,7 @@ UNIV_INLINE
 ulint
 rec_offs_size(
 /*==========*/
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	return(rec_offs_data_size(offsets) + rec_offs_extra_size(offsets));
 }
@@ -1303,7 +1293,7 @@ byte*
 rec_get_end(
 /*========*/
 	const rec_t*	rec,	/*!< in: pointer to record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ut_ad(rec_offs_validate(rec, NULL, offsets));
 	return(const_cast<rec_t*>(rec + rec_offs_data_size(offsets)));
@@ -1317,7 +1307,7 @@ byte*
 rec_get_start(
 /*==========*/
 	const rec_t*	rec,	/*!< in: pointer to record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ut_ad(rec_offs_validate(rec, NULL, offsets));
 	return(const_cast<rec_t*>(rec - rec_offs_extra_size(offsets)));
@@ -1334,7 +1324,7 @@ rec_t*
 rec_copy(
 	void*		buf,
 	const rec_t*	rec,
-	const ulint*	offsets)
+	const offset_t*	offsets)
 {
 	ulint	extra_len;
 	ulint	data_len;
@@ -1420,6 +1410,11 @@ rec_get_converted_size(
 
 	data_size = dtuple_get_data_size(dtuple, 0);
 
+	/* If primary key is being updated then the new record inherits
+	externally stored fields from the delete-marked old record.
+	In that case, n_ext may be less value than
+	dtuple_get_n_ext(tuple). */
+	ut_ad(n_ext <= dtuple_get_n_ext(dtuple));
 	extra_size = rec_get_converted_extra_size(
 		data_size, dtuple_get_n_fields(dtuple), n_ext);
 
diff --git a/storage/innobase/include/rem0types.h b/storage/innobase/include/rem0types.h
index 38a5ba66f76..754781d62d1 100644
--- a/storage/innobase/include/rem0types.h
+++ b/storage/innobase/include/rem0types.h
@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1994, 2015, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2019, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -29,6 +30,9 @@ Created 5/30/1994 Heikki Tuuri
 /* We define the physical record simply as an array of bytes */
 typedef byte	rec_t;
 
+/** This type represents a field offset in a rec_t* */
+typedef unsigned short int offset_t;
+
 /* Maximum values for various fields (for non-blob tuples) */
 #define REC_MAX_N_FIELDS	(1024 - 1)
 #define REC_MAX_HEAP_NO		(2 * 8192 - 1)
diff --git a/storage/innobase/include/row0ftsort.h b/storage/innobase/include/row0ftsort.h
index b735576fbbb..9e5360625f4 100644
--- a/storage/innobase/include/row0ftsort.h
+++ b/storage/innobase/include/row0ftsort.h
@@ -30,6 +30,7 @@ Created 10/13/2010 Jimmy Yang
 #include "data0data.h"
 #include "fts0fts.h"
 #include "fts0priv.h"
+#include "rem0types.h"
 #include "row0merge.h"
 #include "btr0bulk.h"
 
@@ -250,7 +251,7 @@ row_merge_fts_sel_propagate(
 	int*		sel_tree,	/*<! in: selection tree */
 	ulint		level,		/*<! in: selection tree level */
 	const mrec_t**	 mrec,		/*<! in: sort record */
-	ulint**		offsets,	/*<! in: record offsets */
+	offset_t**	offsets,	/*<! in: record offsets */
 	dict_index_t*	index);		/*<! in: FTS index */
 /********************************************************************//**
 Read sorted file containing index data tuples and insert these data
diff --git a/storage/innobase/include/row0log.h b/storage/innobase/include/row0log.h
index d6350705d55..e6f60345703 100644
--- a/storage/innobase/include/row0log.h
+++ b/storage/innobase/include/row0log.h
@@ -136,7 +136,7 @@ row_log_table_delete(
 				page X-latched */
 	dict_index_t*	index,	/*!< in/out: clustered index, S-latched
 				or X-latched */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec,index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec,index) */
 	const byte*	sys)	/*!< in: DB_TRX_ID,DB_ROLL_PTR that should
 				be logged, or NULL to use those in rec */
 	ATTRIBUTE_COLD __attribute__((nonnull(1,2,3)));
@@ -151,7 +151,7 @@ row_log_table_update(
 				page X-latched */
 	dict_index_t*	index,	/*!< in/out: clustered index, S-latched
 				or X-latched */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec,index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec,index) */
 	const dtuple_t*	old_pk);/*!< in: row_log_table_get_pk()
 				before the update */
 
@@ -167,7 +167,7 @@ row_log_table_get_pk(
 				page X-latched */
 	dict_index_t*	index,	/*!< in/out: clustered index, S-latched
 				or X-latched */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec,index),
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec,index),
 				or NULL */
 	byte*		sys,	/*!< out: DB_TRX_ID,DB_ROLL_PTR for
 				row_log_table_delete(), or NULL */
@@ -184,7 +184,7 @@ row_log_table_insert(
 				page X-latched */
 	dict_index_t*	index,	/*!< in/out: clustered index, S-latched
 				or X-latched */
-	const ulint*	offsets);/*!< in: rec_get_offsets(rec,index) */
+	const offset_t*	offsets);/*!< in: rec_get_offsets(rec,index) */
 /******************************************************//**
 Notes that a BLOB is being freed during online ALTER TABLE. */
 void
diff --git a/storage/innobase/include/row0merge.h b/storage/innobase/include/row0merge.h
index 27bd19252ac..fd9050d0a48 100644
--- a/storage/innobase/include/row0merge.h
+++ b/storage/innobase/include/row0merge.h
@@ -489,7 +489,7 @@ row_merge_read_rec(
 	const mrec_t**		mrec,	/*!< out: pointer to merge record,
 					or NULL on end of list
 					(non-NULL on I/O error) */
-	ulint*			offsets,/*!< out: offsets of mrec */
+	offset_t*		offsets,/*!< out: offsets of mrec */
 	row_merge_block_t*	crypt_block, /*!< in: crypt buf or NULL */
 	ulint			space)	   /*!< in: space id */
 	MY_ATTRIBUTE((warn_unused_result));
diff --git a/storage/innobase/include/row0row.h b/storage/innobase/include/row0row.h
index afcae89a0ab..d4d979cdad5 100644
--- a/storage/innobase/include/row0row.h
+++ b/storage/innobase/include/row0row.h
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2016, 2017, MariaDB Corporation.
+Copyright (c) 2016, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -44,7 +44,7 @@ ulint
 row_get_trx_id_offset(
 /*==================*/
 	const dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*		offsets)/*!< in: record offsets */
+	const offset_t*		offsets)/*!< in: record offsets */
 	MY_ATTRIBUTE((nonnull, warn_unused_result));
 /*********************************************************************//**
 Reads the trx id field from a clustered index record.
@@ -55,7 +55,7 @@ row_get_rec_trx_id(
 /*===============*/
 	const rec_t*		rec,	/*!< in: record */
 	const dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*		offsets)/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets)/*!< in: rec_get_offsets(rec, index) */
 	MY_ATTRIBUTE((nonnull, warn_unused_result));
 /*********************************************************************//**
 Reads the roll pointer field from a clustered index record.
@@ -66,7 +66,7 @@ row_get_rec_roll_ptr(
 /*=================*/
 	const rec_t*		rec,	/*!< in: record */
 	const dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*		offsets)/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets)/*!< in: rec_get_offsets(rec, index) */
 	MY_ATTRIBUTE((nonnull, warn_unused_result));
 
 /* Flags for row build type. */
@@ -138,7 +138,7 @@ row_build(
 					this record must be at least
 					s-latched and the latch held
 					as long as the row dtuple is used! */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec,index)
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec,index)
 					or NULL, in which case this function
 					will invoke rec_get_offsets() */
 	const dict_table_t*	col_table,
@@ -189,7 +189,7 @@ row_build_w_add_vcol(
 	ulint			type,
 	const dict_index_t*	index,
 	const rec_t*		rec,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	const dict_table_t*	col_table,
 	const dtuple_t*		defaults,
 	const dict_add_v_col_t*	add_v,
@@ -206,9 +206,7 @@ row_rec_to_index_entry_low(
 /*=======================*/
 	const rec_t*		rec,	/*!< in: record in the index */
 	const dict_index_t*	index,	/*!< in: index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
-	ulint*			n_ext,	/*!< out: number of externally
-					stored columns */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	mem_heap_t*		heap)	/*!< in: memory heap from which
 					the memory needed is allocated */
 	MY_ATTRIBUTE((warn_unused_result));
@@ -221,9 +219,7 @@ row_rec_to_index_entry(
 /*===================*/
 	const rec_t*		rec,	/*!< in: record in the index */
 	const dict_index_t*	index,	/*!< in: index */
-	const ulint*		offsets,/*!< in/out: rec_get_offsets(rec) */
-	ulint*			n_ext,	/*!< out: number of externally
-					stored columns */
+	const offset_t*		offsets,/*!< in/out: rec_get_offsets(rec) */
 	mem_heap_t*		heap)	/*!< in: memory heap from which
 					the memory needed is allocated */
 	MY_ATTRIBUTE((warn_unused_result));
@@ -266,7 +262,7 @@ row_build_row_ref_in_tuple(
 					held as long as the row
 					reference is used! */
 	const dict_index_t*	index,	/*!< in: secondary index */
-	ulint*			offsets)/*!< in: rec_get_offsets(rec, index)
+	offset_t*		offsets)/*!< in: rec_get_offsets(rec, index)
 					or NULL */
 	MY_ATTRIBUTE((nonnull(1,2,3)));
 /*******************************************************************//**
@@ -284,7 +280,7 @@ row_build_row_ref_fast(
 	const rec_t*	rec,	/*!< in: secondary index record;
 				must be preserved while ref is used, as we do
 				not copy field values to heap */
-	const ulint*	offsets);/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets);/*!< in: array returned by rec_get_offsets() */
 /***************************************************************//**
 Searches the clustered index record for a row, if we have the row
 reference.
diff --git a/storage/innobase/include/row0row.ic b/storage/innobase/include/row0row.ic
index 4e3cf58cfc5..14f9f47ba7e 100644
--- a/storage/innobase/include/row0row.ic
+++ b/storage/innobase/include/row0row.ic
@@ -37,7 +37,7 @@ ulint
 row_get_trx_id_offset(
 /*==================*/
 	const dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*		offsets)/*!< in: record offsets */
+	const offset_t*		offsets)/*!< in: record offsets */
 {
 	ulint	pos;
 	ulint	offset;
@@ -64,7 +64,7 @@ row_get_rec_trx_id(
 /*===============*/
 	const rec_t*		rec,	/*!< in: record */
 	const dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*		offsets)/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets)/*!< in: rec_get_offsets(rec, index) */
 {
 	ulint	offset;
 
@@ -89,7 +89,7 @@ row_get_rec_roll_ptr(
 /*=================*/
 	const rec_t*		rec,	/*!< in: record */
 	const dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*		offsets)/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets)/*!< in: rec_get_offsets(rec, index) */
 {
 	ulint	offset;
 
@@ -148,7 +148,7 @@ row_build_row_ref_fast(
 	const rec_t*	rec,	/*!< in: secondary index record;
 				must be preserved while ref is used, as we do
 				not copy field values to heap */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	dfield_t*	dfield;
 	const byte*	field;
diff --git a/storage/innobase/include/row0upd.h b/storage/innobase/include/row0upd.h
index 7d716f960c5..51ed7a7f006 100644
--- a/storage/innobase/include/row0upd.h
+++ b/storage/innobase/include/row0upd.h
@@ -28,6 +28,7 @@ Created 12/27/1996 Heikki Tuuri
 #define row0upd_h
 
 #include "data0data.h"
+#include "rem0types.h"
 #include "row0types.h"
 #include "btr0types.h"
 #include "trx0types.h"
@@ -123,7 +124,7 @@ row_upd_rec_sys_fields(
 	page_zip_des_t*	page_zip,/*!< in/out: compressed page whose
 				uncompressed part will be updated, or NULL */
 	dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	const trx_t*	trx,	/*!< in: transaction */
 	roll_ptr_t	roll_ptr);/*!< in: DB_ROLL_PTR to the undo log */
 /*********************************************************************//**
@@ -165,7 +166,7 @@ ibool
 row_upd_changes_field_size_or_external(
 /*===================================*/
 	dict_index_t*	index,	/*!< in: index */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	const upd_t*	update);/*!< in: update vector */
 /***********************************************************//**
 Returns true if row update contains disowned external fields.
@@ -186,7 +187,7 @@ row_upd_rec_in_place(
 /*=================*/
 	rec_t*		rec,	/*!< in/out: record where replaced */
 	dict_index_t*	index,	/*!< in: the index the record belongs to */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	const upd_t*	update,	/*!< in: update vector */
 	page_zip_des_t*	page_zip);/*!< in: compressed page with enough space
 				available, or NULL */
@@ -201,7 +202,7 @@ row_upd_build_sec_rec_difference_binary(
 /*====================================*/
 	const rec_t*	rec,	/*!< in: secondary index record */
 	dict_index_t*	index,	/*!< in: index */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	const dtuple_t*	entry,	/*!< in: entry to insert */
 	mem_heap_t*	heap)	/*!< in: memory heap from which allocated */
 	MY_ATTRIBUTE((warn_unused_result, nonnull));
@@ -227,7 +228,7 @@ row_upd_build_difference_binary(
 	dict_index_t*	index,
 	const dtuple_t*	entry,
 	const rec_t*	rec,
-	const ulint*	offsets,
+	const offset_t*	offsets,
 	bool		no_sys,
 	trx_t*		trx,
 	mem_heap_t*	heap,
@@ -399,7 +400,7 @@ row_upd_rec_sys_fields_in_recovery(
 /*===============================*/
 	rec_t*		rec,	/*!< in/out: record */
 	page_zip_des_t*	page_zip,/*!< in/out: compressed page, or NULL */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		pos,	/*!< in: TRX_ID position in rec */
 	trx_id_t	trx_id,	/*!< in: transaction id */
 	roll_ptr_t	roll_ptr);/*!< in: roll ptr of the undo log record */
diff --git a/storage/innobase/include/row0upd.ic b/storage/innobase/include/row0upd.ic
index 0a6c33653a0..c8e72f45491 100644
--- a/storage/innobase/include/row0upd.ic
+++ b/storage/innobase/include/row0upd.ic
@@ -163,7 +163,7 @@ row_upd_rec_sys_fields(
 	page_zip_des_t*	page_zip,/*!< in/out: compressed page whose
 				uncompressed part will be updated, or NULL */
 	dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	const trx_t*	trx,	/*!< in: transaction */
 	roll_ptr_t	roll_ptr)/*!< in: DB_ROLL_PTR to the undo log */
 {
diff --git a/storage/innobase/include/row0vers.h b/storage/innobase/include/row0vers.h
index 948804beafc..0603f7c894c 100644
--- a/storage/innobase/include/row0vers.h
+++ b/storage/innobase/include/row0vers.h
@@ -52,7 +52,7 @@ row_vers_impl_x_locked(
 	trx_t*		caller_trx,
 	const rec_t*	rec,
 	dict_index_t*	index,
-	const ulint*	offsets);
+	const offset_t*	offsets);
 
 /** Finds out if a version of the record, where the version >= the current
 purge view, should have ientry as its secondary index entry. We check
@@ -98,7 +98,7 @@ row_vers_build_for_consistent_read(
 	mtr_t*		mtr,	/*!< in: mtr holding the latch on rec; it will
 				also hold the latch on purge_view */
 	dict_index_t*	index,	/*!< in: the clustered index */
-	ulint**		offsets,/*!< in/out: offsets returned by
+	offset_t**	offsets,/*!< in/out: offsets returned by
 				rec_get_offsets(rec, index) */
 	ReadView*	view,	/*!< in: the consistent read view */
 	mem_heap_t**	offset_heap,/*!< in/out: memory heap from which
@@ -126,7 +126,7 @@ row_vers_build_for_semi_consistent_read(
 				of this records */
 	mtr_t*		mtr,	/*!< in: mtr holding the latch on rec */
 	dict_index_t*	index,	/*!< in: the clustered index */
-	ulint**		offsets,/*!< in/out: offsets returned by
+	offset_t**	offsets,/*!< in/out: offsets returned by
 				rec_get_offsets(rec, index) */
 	mem_heap_t**	offset_heap,/*!< in/out: memory heap from which
 				the offsets are allocated */
diff --git a/storage/innobase/include/trx0rec.h b/storage/innobase/include/trx0rec.h
index f169dd8871e..e2c2fbd8204 100644
--- a/storage/innobase/include/trx0rec.h
+++ b/storage/innobase/include/trx0rec.h
@@ -191,7 +191,7 @@ trx_undo_report_row_operation(
 	const rec_t*	rec,		/*!< in: case of an update or delete
 					marking, the record in the clustered
 					index; NULL if insert */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec) */
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec) */
 	roll_ptr_t*	roll_ptr)	/*!< out: DB_ROLL_PTR to the
 					undo log record */
 	MY_ATTRIBUTE((nonnull(1,2,8), warn_unused_result));
@@ -224,7 +224,7 @@ trx_undo_prev_version_build(
 				index_rec page and purge_view */
 	const rec_t*	rec,	/*!< in: version of a clustered index record */
 	dict_index_t*	index,	/*!< in: clustered index */
-	ulint*		offsets,/*!< in/out: rec_get_offsets(rec, index) */
+	offset_t*	offsets,/*!< in/out: rec_get_offsets(rec, index) */
 	mem_heap_t*	heap,	/*!< in: memory heap from which the memory
 				needed is allocated */
 	rec_t**		old_vers,/*!< out, own: previous version, or NULL if
diff --git a/storage/innobase/include/trx0trx.h b/storage/innobase/include/trx0trx.h
index da690a3c65e..8cd4d2018c6 100644
--- a/storage/innobase/include/trx0trx.h
+++ b/storage/innobase/include/trx0trx.h
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2015, 2019, MariaDB Corporation.
+Copyright (c) 2015, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -342,13 +342,6 @@ bool
 trx_is_interrupted(
 /*===============*/
 	const trx_t*	trx);	/*!< in: transaction */
-/**********************************************************************//**
-Determines if the currently running transaction is in strict mode.
-@return TRUE if strict */
-ibool
-trx_is_strict(
-/*==========*/
-	trx_t*	trx);	/*!< in: transaction */
 
 /*******************************************************************//**
 Calculates the "weight" of a transaction. The weight of one transaction
diff --git a/storage/innobase/include/univ.i b/storage/innobase/include/univ.i
index 19a03009ad5..ab30024116e 100644
--- a/storage/innobase/include/univ.i
+++ b/storage/innobase/include/univ.i
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2013, 2019, MariaDB Corporation.
+Copyright (c) 2013, 2020, MariaDB Corporation.
 Copyright (c) 2008, Google Inc.
 
 Portions of this file contain modifications contributed and copyrighted by
diff --git a/storage/innobase/include/ut0rnd.h b/storage/innobase/include/ut0rnd.h
index e8604ffa1c3..9af8687bfd0 100644
--- a/storage/innobase/include/ut0rnd.h
+++ b/storage/innobase/include/ut0rnd.h
@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2019, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -27,37 +28,49 @@ Created 1/20/1994 Heikki Tuuri
 #define ut0rnd_h
 
 #include "ut0byte.h"
+#include <my_sys.h>
 
 #ifndef UNIV_INNOCHECKSUM
-/** The 'character code' for end of field or string (used
-in folding records */
-#define UT_END_OF_FIELD		257
+/** Seed value of ut_rnd_gen() */
+extern int32 ut_rnd_current;
+
+/** @return a pseudo-random 32-bit number */
+inline uint32_t ut_rnd_gen()
+{
+  /* This is a Galois linear-feedback shift register.
+  https://en.wikipedia.org/wiki/Linear-feedback_shift_register#Galois_LFSRs
+  The generating primitive Galois Field polynomial is the Castagnoli
+  polynomial that was made popular by CRC-32C:
+  x^32+x^28+x^27+x^26+x^25+x^23+x^22+x^20+
+  x^19+x^18+x^14+x^13+x^11+x^10+x^9+x^8+x^6+1 */
+  const uint32_t crc32c= 0x1edc6f41;
+
+  uint32_t rnd= my_atomic_load32_explicit(&ut_rnd_current,
+                                          MY_MEMORY_ORDER_RELAXED);
+
+  if (UNIV_UNLIKELY(rnd == 0))
+  {
+    rnd= static_cast<uint32_t>(my_interval_timer());
+    if (!rnd) rnd= 1;
+  }
+  else
+  {
+    bool lsb= rnd & 1;
+    rnd>>= 1;
+    if (lsb)
+      rnd^= crc32c;
+  }
+
+  my_atomic_store32_explicit(&ut_rnd_current, rnd, MY_MEMORY_ORDER_RELAXED);
+  return rnd;
+}
+
+/** @return a random number between 0 and n-1, inclusive */
+inline ulint ut_rnd_interval(ulint n)
+{
+  return n > 1 ? static_cast<ulint>(ut_rnd_gen() % n) : 0;
+}
 
-/********************************************************//**
-This is used to set the random number seed. */
-UNIV_INLINE
-void
-ut_rnd_set_seed(
-/*============*/
-	ulint	 seed);		 /*!< in: seed */
-/********************************************************//**
-The following function generates a series of 'random' ulint integers.
-@return the next 'random' number */
-UNIV_INLINE
-ulint
-ut_rnd_gen_next_ulint(
-/*==================*/
-	ulint	rnd);	/*!< in: the previous random number value */
-/*********************************************************//**
-The following function generates 'random' ulint integers which
-enumerate the value space (let there be N of them) of ulint integers
-in a pseudo-random fashion. Note that the same integer is repeated
-always after N calls to the generator.
-@return the 'random' number */
-UNIV_INLINE
-ulint
-ut_rnd_gen_ulint(void);
-/*==================*/
 /*******************************************************//**
 The following function generates a hash value for a ulint integer
 to a hash table of size table_size, which should be a prime or some
diff --git a/storage/innobase/include/ut0rnd.ic b/storage/innobase/include/ut0rnd.ic
index 2516d20f296..c0105160a42 100644
--- a/storage/innobase/include/ut0rnd.ic
+++ b/storage/innobase/include/ut0rnd.ic
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, MariaDB Corporation.
+Copyright (c) 2017, 2019, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -29,74 +29,6 @@ Created 5/30/1994 Heikki Tuuri
 
 #ifndef UNIV_INNOCHECKSUM
 
-#define UT_RND1			151117737
-#define UT_RND2			119785373
-#define UT_RND3			 85689495
-#define UT_RND4			 76595339
-#define UT_SUM_RND2		 98781234
-#define UT_SUM_RND3		126792457
-#define UT_SUM_RND4		 63498502
-#define UT_XOR_RND1		187678878
-#define UT_XOR_RND2		143537923
-
-/** Seed value of ut_rnd_gen_ulint() */
-extern	ulint	 ut_rnd_ulint_counter;
-
-/********************************************************//**
-This is used to set the random number seed. */
-UNIV_INLINE
-void
-ut_rnd_set_seed(
-/*============*/
-	ulint	 seed)		 /*!< in: seed */
-{
-	ut_rnd_ulint_counter = seed;
-}
-
-/********************************************************//**
-The following function generates a series of 'random' ulint integers.
-@return the next 'random' number */
-UNIV_INLINE
-ulint
-ut_rnd_gen_next_ulint(
-/*==================*/
-	ulint	rnd)	/*!< in: the previous random number value */
-{
-	ulint	n_bits;
-
-	n_bits = 8 * sizeof(ulint);
-
-	rnd = UT_RND2 * rnd + UT_SUM_RND3;
-	rnd = UT_XOR_RND1 ^ rnd;
-	rnd = (rnd << 20) + (rnd >> (n_bits - 20));
-	rnd = UT_RND3 * rnd + UT_SUM_RND4;
-	rnd = UT_XOR_RND2 ^ rnd;
-	rnd = (rnd << 20) + (rnd >> (n_bits - 20));
-	rnd = UT_RND1 * rnd + UT_SUM_RND2;
-
-	return(rnd);
-}
-
-/********************************************************//**
-The following function generates 'random' ulint integers which
-enumerate the value space of ulint integers in a pseudo random
-fashion. Note that the same integer is repeated always after
-2 to power 32 calls to the generator (if ulint is 32-bit).
-@return the 'random' number */
-UNIV_INLINE
-ulint
-ut_rnd_gen_ulint(void)
-/*==================*/
-{
-	ulint	rnd;
-
-	ut_rnd_ulint_counter = UT_RND1 * ut_rnd_ulint_counter + UT_RND2;
-
-	rnd = ut_rnd_gen_next_ulint(ut_rnd_ulint_counter);
-
-	return(rnd);
-}
-
 /*******************************************************//**
 The following function generates a hash value for a ulint integer
 to a hash table of size table_size, which should be a prime
diff --git a/storage/innobase/innodb.cmake b/storage/innobase/innodb.cmake
index c3698df4c11..8bfca3a614b 100644
--- a/storage/innobase/innodb.cmake
+++ b/storage/innobase/innodb.cmake
@@ -96,7 +96,8 @@ IF(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 #SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wconversion")
 
   IF (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" OR
-      CMAKE_SYSTEM_PROCESSOR MATCHES "i386")
+      CMAKE_SYSTEM_PROCESSOR MATCHES "i386" AND
+      CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
     INCLUDE(CheckCXXCompilerFlag)
     CHECK_CXX_COMPILER_FLAG("-fno-builtin-memcmp" HAVE_NO_BUILTIN_MEMCMP)
     IF (HAVE_NO_BUILTIN_MEMCMP)
@@ -152,11 +153,6 @@ IF(NOT MSVC)
     SET_SOURCE_FILES_PROPERTIES(trx/trx0rec.cc PROPERTIES COMPILE_FLAGS -O1)
   ENDIF()
 
-  CHECK_FUNCTION_EXISTS(posix_memalign HAVE_POSIX_MEMALIGN)
-  IF(HAVE_POSIX_MEMALIGN)
-    ADD_DEFINITIONS(-DHAVE_POSIX_MEMALIGN)
-  ENDIF()
-
 # Only use futexes on Linux if GCC atomics are available
 IF(NOT MSVC AND NOT CMAKE_CROSSCOMPILING)
   CHECK_C_SOURCE_RUNS(
diff --git a/storage/innobase/lock/lock0lock.cc b/storage/innobase/lock/lock0lock.cc
index 28055676f74..9ff787282c2 100644
--- a/storage/innobase/lock/lock0lock.cc
+++ b/storage/innobase/lock/lock0lock.cc
@@ -324,7 +324,7 @@ lock_report_trx_id_insanity(
 	trx_id_t	trx_id,		/*!< in: trx id */
 	const rec_t*	rec,		/*!< in: user record */
 	dict_index_t*	index,		/*!< in: index */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec, index) */
 	trx_id_t	max_trx_id)	/*!< in: trx_sys.get_max_trx_id() */
 {
 	ut_ad(rec_offs_validate(rec, index, offsets));
@@ -348,7 +348,7 @@ lock_check_trx_id_sanity(
 	trx_id_t	trx_id,		/*!< in: trx id */
 	const rec_t*	rec,		/*!< in: user record */
 	dict_index_t*	index,		/*!< in: index */
-	const ulint*	offsets)	/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets)	/*!< in: rec_get_offsets(rec, index) */
 {
 	ut_ad(rec_offs_validate(rec, index, offsets));
 	ut_ad(!rec_is_metadata(rec, index));
@@ -374,7 +374,7 @@ lock_clust_rec_cons_read_sees(
 	const rec_t*	rec,	/*!< in: user record which should be read or
 				passed over by a read cursor */
 	dict_index_t*	index,	/*!< in: clustered index */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	ReadView*	view)	/*!< in: consistent read view */
 {
 	ut_ad(dict_index_is_clust(index));
@@ -1205,7 +1205,7 @@ lock_sec_rec_some_has_impl(
 	trx_t*		caller_trx,/*!<in/out: trx of current thread */
 	const rec_t*	rec,	/*!< in: user record */
 	dict_index_t*	index,	/*!< in: secondary index */
-	const ulint*	offsets)/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets)/*!< in: rec_get_offsets(rec, index) */
 {
 	trx_t*		trx;
 	trx_id_t	max_trx_id;
@@ -4470,8 +4470,8 @@ static void lock_rec_print(FILE* file, const lock_t* lock, mtr_t& mtr)
 	putc('\n', file);
 
 	mem_heap_t*		heap		= NULL;
-	ulint			offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*			offsets		= offsets_;
+	offset_t		offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*		offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	mtr.start();
@@ -4819,7 +4819,7 @@ lock_rec_queue_validate(
 	const buf_block_t*	block,	/*!< in: buffer block containing rec */
 	const rec_t*		rec,	/*!< in: record to look at */
 	const dict_index_t*	index,	/*!< in: index, or NULL if not known */
-	const ulint*		offsets)/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets)/*!< in: rec_get_offsets(rec, index) */
 {
 	const lock_t*	lock;
 	ulint		heap_no;
@@ -4986,8 +4986,8 @@ lock_rec_validate_page(
 	ulint		nth_bit		= 0;
 	ulint		i;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(!lock_mutex_own());
@@ -5356,8 +5356,8 @@ lock_rec_insert_check_and_lock(
 #ifdef UNIV_DEBUG
 	{
 		mem_heap_t*	heap		= NULL;
-		ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-		const ulint*	offsets;
+		offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+		const offset_t*	offsets;
 		rec_offs_init(offsets_);
 
 		offsets = rec_get_offsets(next_rec, index, offsets_, true,
@@ -5516,7 +5516,7 @@ lock_rec_convert_impl_to_expl(
 	const buf_block_t*	block,
 	const rec_t*		rec,
 	dict_index_t*		index,
-	const ulint*		offsets)
+	const offset_t*		offsets)
 {
 	trx_t*		trx;
 
@@ -5587,7 +5587,7 @@ lock_clust_rec_modify_check_and_lock(
 	const rec_t*		rec,	/*!< in: record which should be
 					modified */
 	dict_index_t*		index,	/*!< in: clustered index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	que_thr_t*		thr)	/*!< in: query thread */
 {
 	dberr_t	err;
@@ -5679,8 +5679,8 @@ lock_sec_rec_modify_check_and_lock(
 #ifdef UNIV_DEBUG
 	{
 		mem_heap_t*	heap		= NULL;
-		ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-		const ulint*	offsets;
+		offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+		const offset_t*	offsets;
 		rec_offs_init(offsets_);
 
 		offsets = rec_get_offsets(rec, index, offsets_, true,
@@ -5724,7 +5724,7 @@ lock_sec_rec_read_check_and_lock(
 					be read or passed over by a
 					read cursor */
 	dict_index_t*		index,	/*!< in: secondary index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	lock_mode		mode,	/*!< in: mode of the lock which
 					the read cursor should set on
 					records: LOCK_S or LOCK_X; the
@@ -5794,7 +5794,7 @@ lock_clust_rec_read_check_and_lock(
 					be read or passed over by a
 					read cursor */
 	dict_index_t*		index,	/*!< in: clustered index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	lock_mode		mode,	/*!< in: mode of the lock which
 					the read cursor should set on
 					records: LOCK_S or LOCK_X; the
@@ -5872,8 +5872,8 @@ lock_clust_rec_read_check_and_lock_alt(
 	que_thr_t*		thr)	/*!< in: query thread */
 {
 	mem_heap_t*	tmp_heap	= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	dberr_t		err;
 	rec_offs_init(offsets_);
 
diff --git a/storage/innobase/log/log0recv.cc b/storage/innobase/log/log0recv.cc
index e8a890de406..862c5636c53 100644
--- a/storage/innobase/log/log0recv.cc
+++ b/storage/innobase/log/log0recv.cc
@@ -763,7 +763,6 @@ recv_sys_var_init(void)
 	recv_previous_parsed_rec_type = MLOG_SINGLE_REC_FLAG;
 	recv_previous_parsed_rec_offset	= 0;
 	recv_previous_parsed_rec_is_multi = 0;
-	recv_n_pool_free_frames	= 256;
 	recv_max_page_lsn = 0;
 }
 
@@ -843,18 +842,14 @@ recv_sys_init()
 		recv_sys->flush_end = os_event_create(0);
 	}
 
-	ulint size = buf_pool_get_curr_size();
-	/* Set appropriate value of recv_n_pool_free_frames. */
-	if (size >= 10 << 20) {
-		/* Buffer pool of size greater than 10 MB. */
-		recv_n_pool_free_frames = 512;
-	}
+	recv_n_pool_free_frames =
+		buf_pool_get_n_pages() / 3;
 
 	recv_sys->buf = static_cast<byte*>(
 		ut_malloc_dontdump(RECV_PARSING_BUF_SIZE));
 	recv_sys->buf_size = RECV_PARSING_BUF_SIZE;
 
-	recv_sys->addr_hash = hash_create(size / 512);
+	recv_sys->addr_hash = hash_create(buf_pool_get_curr_size() / 512);
 	recv_sys->progress_time = time(NULL);
 	recv_max_page_lsn = 0;
 
@@ -2719,14 +2714,40 @@ recv_mlog_index_load(ulint space_id, ulint page_no, lsn_t lsn)
 	}
 }
 
+/** Check whether read redo log memory exceeds the available memory
+of buffer pool. Store last_stored_lsn if it is not in last phase
+@param[in]	store		whether to store page operations
+@param[in]	available_mem	Available memory in buffer pool to
+				read redo logs. */
+static bool recv_sys_heap_check(store_t* store, ulint available_mem)
+{
+  if (*store != STORE_NO
+      && mem_heap_get_size(recv_sys->heap) >= available_mem)
+  {
+    if (*store == STORE_YES)
+      recv_sys->last_stored_lsn= recv_sys->recovered_lsn;
+
+    *store= STORE_NO;
+    DBUG_PRINT("ib_log",("Ran out of memory and last "
+			 "stored lsn " LSN_PF " last stored offset "
+			 ULINTPF "\n",recv_sys->recovered_lsn,
+			 recv_sys->recovered_offset));
+    return true;
+  }
+
+  return false;
+}
+
 /** Parse log records from a buffer and optionally store them to a
 hash table to wait merging to file pages.
-@param[in]	checkpoint_lsn	the LSN of the latest checkpoint
-@param[in]	store		whether to store page operations
-@param[in]	apply		whether to apply the records
+@param[in]	checkpoint_lsn		the LSN of the latest checkpoint
+@param[in]	store			whether to store page operations
+@param[in]	available_mem		memory to read the redo logs
+@param[in]	apply			whether to apply the records
 @return whether MLOG_CHECKPOINT record was seen the first time,
 or corruption was noticed */
-bool recv_parse_log_recs(lsn_t checkpoint_lsn, store_t store, bool apply)
+bool recv_parse_log_recs(lsn_t checkpoint_lsn, store_t* store,
+			 ulint available_mem, bool apply)
 {
 	byte*		ptr;
 	byte*		end_ptr;
@@ -2738,6 +2759,7 @@ bool recv_parse_log_recs(lsn_t checkpoint_lsn, store_t store, bool apply)
 	ulint		space;
 	ulint		page_no;
 	byte*		body;
+	const bool	last_phase = (*store == STORE_IF_EXISTS);
 
 	ut_ad(log_mutex_own());
 	ut_ad(mutex_own(&recv_sys->mutex));
@@ -2752,6 +2774,12 @@ loop:
 		return(false);
 	}
 
+	/* Check for memory overflow and ignore the parsing of remaining
+	redo log records if InnoDB ran out of memory */
+	if (recv_sys_heap_check(store, available_mem) && last_phase) {
+		return false;
+	}
+
 	switch (*ptr) {
 	case MLOG_CHECKPOINT:
 #ifdef UNIV_LOG_LSN_DEBUG
@@ -2852,7 +2880,7 @@ loop:
 			break;
 #endif /* UNIV_LOG_LSN_DEBUG */
 		default:
-			switch (store) {
+			switch (*store) {
 			case STORE_NO:
 				break;
 			case STORE_IF_EXISTS:
@@ -3036,7 +3064,7 @@ corrupted_log:
 				recv_parse_or_apply_log_rec_body(). */
 				break;
 			default:
-				switch (store) {
+				switch (*store) {
 				case STORE_NO:
 					break;
 				case STORE_IF_EXISTS:
@@ -3079,7 +3107,6 @@ bool recv_sys_add_to_parsing_buf(const byte* log_block, lsn_t scanned_lsn)
 	if (!recv_sys->parse_start_lsn) {
 		/* Cannot start parsing yet because no start point for
 		it found */
-
 		return(false);
 	}
 
@@ -3100,7 +3127,6 @@ bool recv_sys_add_to_parsing_buf(const byte* log_block, lsn_t scanned_lsn)
 	}
 
 	if (more_len == 0) {
-
 		return(false);
 	}
 
@@ -3135,8 +3161,9 @@ bool recv_sys_add_to_parsing_buf(const byte* log_block, lsn_t scanned_lsn)
 /** Moves the parsing buffer data left to the buffer start. */
 void recv_sys_justify_left_parsing_buf()
 {
-	ut_memmove(recv_sys->buf, recv_sys->buf + recv_sys->recovered_offset,
-		   recv_sys->len - recv_sys->recovered_offset);
+	memmove(recv_sys->buf,
+		recv_sys->buf + recv_sys->recovered_offset,
+		recv_sys->len - recv_sys->recovered_offset);
 
 	recv_sys->len -= recv_sys->recovered_offset;
 
@@ -3146,26 +3173,30 @@ void recv_sys_justify_left_parsing_buf()
 /** Scan redo log from a buffer and stores new log data to the parsing buffer.
 Parse and hash the log records if new data found.
 Apply log records automatically when the hash table becomes full.
+@param[in]	available_mem		we let the hash table of recs to
+					grow to this size, at the maximum
+@param[in,out]	store_to_hash		whether the records should be
+					stored to the hash table; this is
+					reset if just debug checking is
+					needed, or when the available_mem
+					runs out
+@param[in]	log_block		log segment
+@param[in]	checkpoint_lsn		latest checkpoint LSN
+@param[in]	start_lsn		buffer start LSN
+@param[in]	end_lsn			buffer end LSN
+@param[in,out]	contiguous_lsn		it is known that all groups contain
+					contiguous log data upto this lsn
+@param[out]	group_scanned_lsn	scanning succeeded upto this lsn
 @return true if not able to scan any more in this log group */
-static
-bool
-recv_scan_log_recs(
-/*===============*/
-	ulint		available_memory,/*!< in: we let the hash table of recs
-					to grow to this size, at the maximum */
-	store_t*	store_to_hash,	/*!< in,out: whether the records should be
-					stored to the hash table; this is reset
-					if just debug checking is needed, or
-					when the available_memory runs out */
-	const byte*	log_block,	/*!< in: log segment */
-	lsn_t		checkpoint_lsn,	/*!< in: latest checkpoint LSN */
-	lsn_t		start_lsn,	/*!< in: buffer start LSN */
-	lsn_t		end_lsn,	/*!< in: buffer end LSN */
-	lsn_t*		contiguous_lsn,	/*!< in/out: it is known that all log
-					groups contain contiguous log data up
-					to this lsn */
-	lsn_t*		group_scanned_lsn)/*!< out: scanning succeeded up to
-					this lsn */
+static bool recv_scan_log_recs(
+	ulint		available_mem,
+	store_t*	store_to_hash,
+	const byte*	log_block,
+	lsn_t		checkpoint_lsn,
+	lsn_t		start_lsn,
+	lsn_t		end_lsn,
+	lsn_t*		contiguous_lsn,
+	lsn_t*		group_scanned_lsn)
 {
 	lsn_t		scanned_lsn	= start_lsn;
 	bool		finished	= false;
@@ -3173,14 +3204,13 @@ recv_scan_log_recs(
 	bool		more_data	= false;
 	bool		apply		= recv_sys->mlog_checkpoint_lsn != 0;
 	ulint		recv_parsing_buf_size = RECV_PARSING_BUF_SIZE;
-
+	const bool	last_phase = (*store_to_hash == STORE_IF_EXISTS);
 	ut_ad(start_lsn % OS_FILE_LOG_BLOCK_SIZE == 0);
 	ut_ad(end_lsn % OS_FILE_LOG_BLOCK_SIZE == 0);
 	ut_ad(end_lsn >= start_lsn + OS_FILE_LOG_BLOCK_SIZE);
 
 	const byte* const	log_end = log_block
 		+ ulint(end_lsn - start_lsn);
-
 	do {
 		ut_ad(!finished);
 
@@ -3291,6 +3321,13 @@ recv_scan_log_recs(
 				= log_block_get_checkpoint_no(log_block);
 		}
 
+		/* During last phase of scanning, there can be redo logs
+		left in recv_sys->buf to parse & store it in recv_sys->heap */
+		if (last_phase
+		    && recv_sys->recovered_lsn < recv_sys->scanned_lsn) {
+			more_data = true;
+		}
+
 		if (data_len < OS_FILE_LOG_BLOCK_SIZE) {
 			/* Log data for this group ends here */
 			finished = true;
@@ -3308,7 +3345,8 @@ recv_scan_log_recs(
 		/* Try to parse more log records */
 
 		if (recv_parse_log_recs(checkpoint_lsn,
-					*store_to_hash, apply)) {
+					store_to_hash, available_mem,
+					apply)) {
 			ut_ad(recv_sys->found_corrupt_log
 			      || recv_sys->found_corrupt_fs
 			      || recv_sys->mlog_checkpoint_lsn
@@ -3317,22 +3355,18 @@ recv_scan_log_recs(
 			goto func_exit;
 		}
 
-		if (*store_to_hash != STORE_NO
-		    && mem_heap_get_size(recv_sys->heap) > available_memory) {
-
-			DBUG_PRINT("ib_log", ("Ran out of memory and last "
-					      "stored lsn " LSN_PF,
-					      recv_sys->recovered_lsn));
-
-			recv_sys->last_stored_lsn = recv_sys->recovered_lsn;
-			*store_to_hash = STORE_NO;
-		}
+		recv_sys_heap_check(store_to_hash, available_mem);
 
 		if (recv_sys->recovered_offset > recv_parsing_buf_size / 4) {
 			/* Move parsing buffer data to the buffer start */
-
 			recv_sys_justify_left_parsing_buf();
 		}
+
+		/* Need to re-parse the redo log which're stored
+		in recv_sys->buf */
+		if (last_phase && *store_to_hash == STORE_NO) {
+			finished = false;
+		}
 	}
 
 func_exit:
@@ -3394,6 +3428,8 @@ recv_group_scan_log_recs(
 			redo log records before we have
 			finished the redo log scan. */
 			recv_apply_hashed_log_recs(false);
+			/* Rescan the redo logs from last stored lsn */
+			end_lsn = recv_sys->recovered_lsn;
 		}
 
 		start_lsn = ut_uint64_align_down(end_lsn,
diff --git a/storage/innobase/mem/mem0mem.cc b/storage/innobase/mem/mem0mem.cc
index a298a7c0b2f..15dee37cc1f 100644
--- a/storage/innobase/mem/mem0mem.cc
+++ b/storage/innobase/mem/mem0mem.cc
@@ -210,8 +210,6 @@ mem_heap_validate(
 		block != NULL;
 		block = UT_LIST_GET_NEXT(list, block)) {
 
-		mem_block_validate(block);
-
 		switch (block->type) {
 		case MEM_HEAP_DYNAMIC:
 			break;
@@ -266,7 +264,6 @@ mem_heap_create_block_func(
 	      || (type == MEM_HEAP_BUFFER + MEM_HEAP_BTR_SEARCH));
 
 	if (heap != NULL) {
-		mem_block_validate(heap);
 		ut_d(mem_heap_validate(heap));
 	}
 
@@ -308,7 +305,6 @@ mem_heap_create_block_func(
 	block->buf_block = buf_block;
 	block->free_block = NULL;
 
-	block->magic_n = MEM_BLOCK_MAGIC_N;
 	ut_d(ut_strlcpy_rev(block->file_name, file_name,
 			    sizeof(block->file_name)));
 	ut_d(block->line = line);
@@ -356,8 +352,6 @@ mem_heap_add_block(
 	mem_block_t*	new_block;
 	ulint		new_size;
 
-	ut_d(mem_block_validate(heap));
-
 	block = UT_LIST_GET_LAST(heap->base);
 
 	/* We have to allocate a new block. The size is always at least
@@ -410,8 +404,6 @@ mem_heap_block_free(
 
 	buf_block = static_cast<buf_block_t*>(block->buf_block);
 
-	mem_block_validate(block);
-
 	UT_LIST_REMOVE(heap->base, block);
 
 	ut_ad(heap->total_size >= block->len);
@@ -419,7 +411,6 @@ mem_heap_block_free(
 
 	type = heap->type;
 	len = block->len;
-	block->magic_n = MEM_FREED_BLOCK_MAGIC_N;
 
 	if (type == MEM_HEAP_DYNAMIC || len < srv_page_size / 2) {
 		ut_ad(!buf_block);
diff --git a/storage/innobase/os/os0file.cc b/storage/innobase/os/os0file.cc
index 0f6c56a4a03..9a1276ef364 100644
--- a/storage/innobase/os/os0file.cc
+++ b/storage/innobase/os/os0file.cc
@@ -1,8 +1,8 @@
 /***********************************************************************
 
-Copyright (c) 1995, 2017, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 1995, 2019, Oracle and/or its affiliates. All Rights Reserved.
 Copyright (c) 2009, Percona Inc.
-Copyright (c) 2013, 2019, MariaDB Corporation.
+Copyright (c) 2013, 2020, MariaDB Corporation.
 
 Portions of this file contain modifications contributed and copyrighted
 by Percona Inc.. Those modifications are
@@ -413,7 +413,7 @@ public:
 	/** Accessor for the AIO context
 	@param[in]	segment	Segment for which to get the context
 	@return the AIO context for the segment */
-	io_context* io_ctx(ulint segment)
+	io_context_t io_ctx(ulint segment)
 		MY_ATTRIBUTE((warn_unused_result))
 	{
 		ut_ad(segment < get_n_segments());
@@ -421,11 +421,11 @@ public:
 		return(m_aio_ctx[segment]);
 	}
 
-	/** Creates an io_context for native linux AIO.
+	/** Creates an io_context_t for native linux AIO.
 	@param[in]	max_events	number of events
 	@param[out]	io_ctx		io_ctx to initialize.
 	@return true on success. */
-	static bool linux_create_io_ctx(unsigned max_events, io_context_t* io_ctx)
+	static bool linux_create_io_ctx(unsigned max_events, io_context_t& io_ctx)
 		MY_ATTRIBUTE((warn_unused_result));
 
 	/** Checks if the system supports native linux aio. On some kernel
@@ -622,7 +622,7 @@ private:
 
 	/** completion queue for IO. There is one such queue per
 	segment. Each thread will work on one ctx exclusively. */
-	io_context_t*		m_aio_ctx;
+	std::vector<io_context_t>		m_aio_ctx;
 
 	/** The array to collect completed IOs. There is one such
 	event for each possible pending IO. The size of the array
@@ -1470,6 +1470,12 @@ os_file_get_parent_dir(
 		return(NULL);
 	}
 
+	if (last_slash - path < 0) {
+		/* Sanity check, it prevents gcc from trying to handle this case which
+		 * results in warnings for some optimized builds */
+		return (NULL);
+	}
+
 	/* Non-trivial directory component */
 
 	return(mem_strdupl(path, ulint(last_slash - path)));
@@ -1788,10 +1794,14 @@ LinuxAIOHandler::resubmit(Slot* slot)
 
 	iocb->data = slot;
 
+	ut_a(reinterpret_cast<size_t>(iocb->u.c.buf) % OS_FILE_LOG_BLOCK_SIZE
+	     == 0);
+
 	/* Resubmit an I/O request */
 	int	ret = io_submit(m_array->io_ctx(m_segment), 1, &iocb);
+	ut_a(ret != -EINVAL);
 
-	if (ret < -1)  {
+	if (ret < 0)  {
 		errno = -ret;
 	}
 
@@ -1892,8 +1902,8 @@ LinuxAIOHandler::collect()
 	ut_ad(m_array != NULL);
 	ut_ad(m_segment < m_array->get_n_segments());
 
-	/* Which io_context we are going to use. */
-	io_context*	io_ctx = m_array->io_ctx(m_segment);
+	/* Which io_context_t we are going to use. */
+	io_context_t	io_ctx = m_array->io_ctx(m_segment);
 
 	/* Starting point of the m_segment we will be working on. */
 	ulint	start_pos = m_segment * m_n_slots;
@@ -1920,6 +1930,8 @@ LinuxAIOHandler::collect()
 		int	ret;
 
 		ret = io_getevents(io_ctx, 1, m_n_slots, events, &timeout);
+		ut_a(ret != -EINVAL);
+		ut_ad(ret != -EFAULT);
 
 		for (int i = 0; i < ret; ++i) {
 
@@ -2146,14 +2158,18 @@ AIO::linux_dispatch(Slot* slot)
 
 	/* Find out what we are going to work with.
 	The iocb struct is directly in the slot.
-	The io_context is one per segment. */
+	The io_context_t is one per segment. */
 
 	ulint		io_ctx_index;
 	struct iocb*	iocb = &slot->control;
 
 	io_ctx_index = (slot->pos * m_n_segments) / m_slots.size();
 
-	int	ret = io_submit(m_aio_ctx[io_ctx_index], 1, &iocb);
+	ut_a(reinterpret_cast<size_t>(iocb->u.c.buf) % OS_FILE_LOG_BLOCK_SIZE
+	     == 0);
+
+	int	ret = io_submit(io_ctx(io_ctx_index), 1, &iocb);
+	ut_a(ret != -EINVAL);
 
 	/* io_submit() returns number of successfully queued requests
 	or -errno. */
@@ -2165,25 +2181,26 @@ AIO::linux_dispatch(Slot* slot)
 	return(ret == 1);
 }
 
-/** Creates an io_context for native linux AIO.
+/** Creates an io_context_t for native linux AIO.
 @param[in]	max_events	number of events
 @param[out]	io_ctx		io_ctx to initialize.
 @return true on success. */
 bool
 AIO::linux_create_io_ctx(
 	unsigned	max_events,
-	io_context_t*	io_ctx)
+	io_context_t&	io_ctx)
 {
 	ssize_t		n_retries = 0;
 
 	for (;;) {
 
-		memset(io_ctx, 0x0, sizeof(*io_ctx));
+		memset(&io_ctx, 0x0, sizeof(io_ctx));
 
 		/* Initialize the io_ctx. Tell it how many pending
 		IO requests this context will handle. */
 
-		int	ret = io_setup(max_events, io_ctx);
+		int	ret = io_setup(max_events, &io_ctx);
+		ut_a(ret != -EINVAL);
 
 		if (ret == 0) {
 			/* Success. Return now. */
@@ -2262,7 +2279,7 @@ AIO::is_linux_native_aio_supported()
 	io_context_t	io_ctx;
 	char		name[1000];
 
-	if (!linux_create_io_ctx(1, &io_ctx)) {
+	if (!linux_create_io_ctx(1, io_ctx)) {
 
 		/* The platform does not support native aio. */
 
@@ -2278,6 +2295,10 @@ AIO::is_linux_native_aio_supported()
 				<< "Unable to create temp file to check"
 				" native AIO support.";
 
+			int ret = io_destroy(io_ctx);
+			ut_a(ret != -EINVAL);
+			ut_ad(ret != -EFAULT);
+
 			return(false);
 		}
 	} else {
@@ -2307,6 +2328,10 @@ AIO::is_linux_native_aio_supported()
 				<< " \"" << name << "\" to check native"
 				<< " AIO read support.";
 
+			int ret = io_destroy(io_ctx);
+			ut_a(ret != EINVAL);
+			ut_ad(ret != EFAULT);
+
 			return(false);
 		}
 	}
@@ -2335,11 +2360,15 @@ AIO::is_linux_native_aio_supported()
 		io_prep_pread(p_iocb, fd, ptr, 512, 0);
 	}
 
+	ut_a(reinterpret_cast<size_t>(p_iocb->u.c.buf) % OS_FILE_LOG_BLOCK_SIZE
+	     == 0);
 	int	err = io_submit(io_ctx, 1, &p_iocb);
+	ut_a(err != -EINVAL);
 
 	if (err >= 1) {
 		/* Now collect the submitted IO request. */
 		err = io_getevents(io_ctx, 1, 1, &io_event, NULL);
+		ut_a(err != -EINVAL);
 	}
 
 	ut_free(buf);
@@ -2347,7 +2376,13 @@ AIO::is_linux_native_aio_supported()
 
 	switch (err) {
 	case 1:
-		return(true);
+		{
+			int ret = io_destroy(io_ctx);
+			ut_a(ret != -EINVAL);
+			ut_ad(ret != -EFAULT);
+
+			return(true);
+		}
 
 	case -EINVAL:
 	case -ENOSYS:
@@ -2367,6 +2402,10 @@ AIO::is_linux_native_aio_supported()
 			<< "returned error[" << -err << "]";
 	}
 
+	int ret = io_destroy(io_ctx);
+	ut_a(ret != -EINVAL);
+	ut_ad(ret != -EFAULT);
+
 	return(false);
 }
 
@@ -5723,8 +5762,7 @@ AIO::AIO(
 	m_n_segments(segments),
 	m_n_reserved()
 # ifdef LINUX_NATIVE_AIO
-	,m_aio_ctx(),
-	m_events(m_slots.size())
+	,m_events(m_slots.size())
 # endif /* LINUX_NATIVE_AIO */
 #ifdef WIN_ASYNC_IO
 	,m_completion_port(new_completion_port())
@@ -5780,29 +5818,20 @@ AIO::init_slots()
 dberr_t
 AIO::init_linux_native_aio()
 {
-	/* Initialize the io_context array. One io_context
-	per segment in the array. */
-
-	ut_a(m_aio_ctx == NULL);
-
-	m_aio_ctx = static_cast<io_context**>(
-		ut_zalloc_nokey(m_n_segments * sizeof(*m_aio_ctx)));
 
-	if (m_aio_ctx == NULL) {
-		return(DB_OUT_OF_MEMORY);
-	}
+	/* Initialize the io_context_t array. One io_context_t
+	per segment in the array. */
+	m_aio_ctx.resize(get_n_segments());
 
-	io_context**	ctx = m_aio_ctx;
 	ulint		max_events = slots_per_segment();
 
-	for (ulint i = 0; i < m_n_segments; ++i, ++ctx) {
+	for (std::vector<io_context_t>::iterator it = m_aio_ctx.begin(),
+						 end = m_aio_ctx.end();
+	     it != end; ++it) {
 
-		if (!linux_create_io_ctx(max_events, ctx)) {
+		if (!linux_create_io_ctx(max_events, *it)) {
 			/* If something bad happened during aio setup
 			we disable linux native aio.
-			The disadvantage will be a small memory leak
-			at shutdown but that's ok compared to a crash
-			or a not working server.
 			This frequently happens when running the test suite
 			with many threads on a system with low fs.aio-max-nr!
 			*/
@@ -5814,8 +5843,15 @@ AIO::init_linux_native_aio()
 				<< "try increasing system "
 				<< "fs.aio-max-nr to 1048576 or larger or "
 				<< "setting innodb_use_native_aio = 0 in my.cnf";
-			ut_free(m_aio_ctx);
-			m_aio_ctx = 0;
+
+			for (std::vector<io_context_t>::iterator it2
+			     = m_aio_ctx.begin();
+			     it2 != it; ++it2) {
+				int ret = io_destroy(*it2);
+				ut_a(ret != -EINVAL);
+			}
+
+			m_aio_ctx.clear();
 			srv_use_native_aio = FALSE;
 			return(DB_SUCCESS);
 		}
@@ -5891,15 +5927,15 @@ AIO::~AIO()
 
 #if defined(LINUX_NATIVE_AIO)
 	if (srv_use_native_aio) {
-		m_events.clear();
-		ut_free(m_aio_ctx);
+		for (ulint i = 0; i < m_aio_ctx.size(); i++) {
+			int ret = io_destroy(m_aio_ctx[i]);
+			ut_a(ret != -EINVAL);
+		}
 	}
 #endif /* LINUX_NATIVE_AIO */
 #if defined(WIN_ASYNC_IO)
 	CloseHandle(m_completion_port);
 #endif
-
-	m_slots.clear();
 }
 
 /** Initializes the asynchronous io system. Creates one array each for ibuf
@@ -6193,6 +6229,10 @@ AIO::reserve_slot(
 	os_offset_t		offset,
 	ulint			len)
 {
+	ut_ad(reinterpret_cast<size_t>(buf) % OS_FILE_LOG_BLOCK_SIZE == 0);
+	ut_ad(offset % OS_FILE_LOG_BLOCK_SIZE == 0);
+	ut_ad(len % OS_FILE_LOG_BLOCK_SIZE == 0);
+
 #ifdef WIN_ASYNC_IO
 	ut_a((len & 0xFFFFFFFFUL) == len);
 #endif /* WIN_ASYNC_IO */
diff --git a/storage/innobase/os/os0proc.cc b/storage/innobase/os/os0proc.cc
index 70f389436fa..60057880c18 100644
--- a/storage/innobase/os/os0proc.cc
+++ b/storage/innobase/os/os0proc.cc
@@ -157,6 +157,12 @@ os_mem_free_large(
 {
 	ut_a(os_total_large_mem_allocated >= size);
 
+	// We could have manually poisoned that memory for ASAN.
+	// And we must unpoison it by ourself as specified in documentation
+	// for __asan_poison_memory_region() in sanitizer/asan_interface.h
+	// munmap() doesn't do it for us automatically.
+	UNIV_MEM_ALLOC(ptr, size);
+
 #ifdef HAVE_LINUX_LARGE_PAGES
 	if (my_use_large_pages && opt_large_page_size && !shmdt(ptr)) {
 		my_atomic_addlint(
diff --git a/storage/innobase/os/os0thread.cc b/storage/innobase/os/os0thread.cc
index f9982bfc9ca..0c97ebccc1b 100644
--- a/storage/innobase/os/os0thread.cc
+++ b/storage/innobase/os/os0thread.cc
@@ -125,11 +125,17 @@ os_thread_create_func(
 
 	pthread_attr_t	attr;
 
-	pthread_attr_init(&attr);
+	int	ret = pthread_attr_init(&attr);
+	if (UNIV_UNLIKELY(ret)) {
+		fprintf(stderr,
+			"InnoDB: Error: pthread_attr_init() returned %d\n",
+			ret);
+		abort();
+	}
 
 	my_atomic_addlint(&os_thread_count, 1);
 
-	int	ret = pthread_create(&new_thread_id, &attr, func, arg);
+	ret = pthread_create(&new_thread_id, &attr, func, arg);
 
 	ut_a(ret == 0);
 
diff --git a/storage/innobase/page/page0cur.cc b/storage/innobase/page/page0cur.cc
index 204fedf9d29..16f0495527d 100644
--- a/storage/innobase/page/page0cur.cc
+++ b/storage/innobase/page/page0cur.cc
@@ -35,38 +35,6 @@ Created 10/4/1994 Heikki Tuuri
 
 #include <algorithm>
 
-/*******************************************************************//**
-This is a linear congruential generator PRNG. Returns a pseudo random
-number between 0 and 2^64-1 inclusive. The formula and the constants
-being used are:
-X[n+1] = (a * X[n] + c) mod m
-where:
-X[0] = my_interval_timer()
-a = 1103515245 (3^5 * 5 * 7 * 129749)
-c = 12345 (3 * 5 * 823)
-m = 18446744073709551616 (2^64)
-
-@return number between 0 and 2^64-1 */
-static
-ib_uint64_t
-page_cur_lcg_prng(void)
-/*===================*/
-{
-#define LCG_a	1103515245
-#define LCG_c	12345
-	static uint64_t	lcg_current;
-
-	if (!lcg_current) {
-		lcg_current = my_interval_timer();
-	}
-
-	/* no need to "% 2^64" explicitly because lcg_current is
-	64 bit and this will be done anyway */
-	lcg_current = LCG_a * lcg_current + LCG_c;
-
-	return(lcg_current);
-}
-
 #ifdef BTR_CUR_HASH_ADAPT
 # ifdef UNIV_SEARCH_PERF_STAT
 static ulint	page_cur_short_succ;
@@ -99,8 +67,8 @@ page_cur_try_search_shortcut(
 	ibool		success		= FALSE;
 	const page_t*	page		= buf_block_get_frame(block);
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(dtuple_check_typed(tuple));
@@ -183,8 +151,8 @@ page_cur_try_search_shortcut_bytes(
 	ibool		success		= FALSE;
 	const page_t*	page		= buf_block_get_frame(block);
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(dtuple_check_typed(tuple));
@@ -255,7 +223,7 @@ page_cur_rec_field_extends(
 /*=======================*/
 	const dtuple_t*	tuple,	/*!< in: data tuple */
 	const rec_t*	rec,	/*!< in: record */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		n)	/*!< in: compare nth field */
 {
 	const dtype_t*	type;
@@ -331,8 +299,8 @@ page_cur_search_with_match(
 	const page_zip_des_t*	page_zip = buf_block_get_page_zip(block);
 #endif /* UNIV_ZIP_DEBUG */
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(dtuple_validate(tuple));
@@ -590,8 +558,8 @@ page_cur_search_with_match_bytes(
 	const page_zip_des_t*	page_zip = buf_block_get_page_zip(block);
 #endif /* UNIV_ZIP_DEBUG */
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(dtuple_validate(tuple));
@@ -803,8 +771,7 @@ page_cur_open_on_rnd_user_rec(
 	buf_block_t*	block,	/*!< in: page */
 	page_cur_t*	cursor)	/*!< out: page cursor */
 {
-	ulint	rnd;
-	ulint	n_recs = page_get_n_recs(buf_block_get_frame(block));
+	const ulint	n_recs = page_get_n_recs(block->frame);
 
 	page_cur_set_before_first(block, cursor);
 
@@ -813,11 +780,8 @@ page_cur_open_on_rnd_user_rec(
 		return;
 	}
 
-	rnd = (ulint) (page_cur_lcg_prng() % n_recs);
-
-	do {
-		page_cur_move_to_next(cursor);
-	} while (rnd--);
+	cursor->rec = page_rec_get_nth(block->frame,
+				       ut_rnd_interval(n_recs) + 1);
 }
 
 /** Write a redo log record of inserting a record into an index page.
@@ -857,11 +821,11 @@ page_cur_insert_rec_write_log(
 
 	{
 		mem_heap_t*	heap		= NULL;
-		ulint		cur_offs_[REC_OFFS_NORMAL_SIZE];
-		ulint		ins_offs_[REC_OFFS_NORMAL_SIZE];
+		offset_t	cur_offs_[REC_OFFS_NORMAL_SIZE];
+		offset_t	ins_offs_[REC_OFFS_NORMAL_SIZE];
 
-		ulint*		cur_offs;
-		ulint*		ins_offs;
+		offset_t*	cur_offs;
+		offset_t*	ins_offs;
 
 		rec_offs_init(cur_offs_);
 		rec_offs_init(ins_offs_);
@@ -1037,8 +1001,8 @@ page_cur_parse_insert_rec(
 	ulint		info_and_status_bits = 0; /* remove warning */
 	page_cur_t	cursor;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	page = block ? buf_block_get_frame(block) : NULL;
@@ -1255,7 +1219,7 @@ page_cur_insert_rec_low(
 				which the new record is inserted */
 	dict_index_t*	index,	/*!< in: record descriptor */
 	const rec_t*	rec,	/*!< in: pointer to a physical record */
-	ulint*		offsets,/*!< in/out: rec_get_offsets(rec, index) */
+	offset_t*	offsets,/*!< in/out: rec_get_offsets(rec, index) */
 	mtr_t*		mtr)	/*!< in: mini-transaction handle, or NULL */
 {
 	byte*		insert_buf;
@@ -1306,8 +1270,8 @@ page_cur_insert_rec_low(
 	free_rec = page_header_get_ptr(page, PAGE_FREE);
 	if (UNIV_LIKELY_NULL(free_rec)) {
 		/* Try to allocate from the head of the free list. */
-		ulint		foffsets_[REC_OFFS_NORMAL_SIZE];
-		ulint*		foffsets	= foffsets_;
+		offset_t	foffsets_[REC_OFFS_NORMAL_SIZE];
+		offset_t*	foffsets	= foffsets_;
 		mem_heap_t*	heap		= NULL;
 
 		rec_offs_init(foffsets_);
@@ -1478,7 +1442,7 @@ page_cur_insert_rec_zip(
 	page_cur_t*	cursor,	/*!< in/out: page cursor */
 	dict_index_t*	index,	/*!< in: record descriptor */
 	const rec_t*	rec,	/*!< in: pointer to a physical record */
-	ulint*		offsets,/*!< in/out: rec_get_offsets(rec, index) */
+	offset_t*	offsets,/*!< in/out: rec_get_offsets(rec, index) */
 	mtr_t*		mtr)	/*!< in: mini-transaction handle, or NULL */
 {
 	byte*		insert_buf;
@@ -1719,8 +1683,8 @@ page_cur_insert_rec_zip(
 	if (UNIV_LIKELY_NULL(free_rec)) {
 		/* Try to allocate from the head of the free list. */
 		lint	extra_size_diff;
-		ulint		foffsets_[REC_OFFS_NORMAL_SIZE];
-		ulint*		foffsets	= foffsets_;
+		offset_t	foffsets_[REC_OFFS_NORMAL_SIZE];
+		offset_t*	foffsets	= foffsets_;
 		mem_heap_t*	heap		= NULL;
 
 		rec_offs_init(foffsets_);
@@ -2042,8 +2006,8 @@ page_copy_rec_list_end_to_created_page(
 	byte*	log_ptr;
 	ulint	log_data_len;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(page_dir_get_n_heap(new_page) == PAGE_HEAP_NO_USER_LOW);
@@ -2266,7 +2230,7 @@ page_cur_parse_delete_rec(
 	if (block) {
 		page_t*		page		= buf_block_get_frame(block);
 		mem_heap_t*	heap		= NULL;
-		ulint		offsets_[REC_OFFS_NORMAL_SIZE];
+		offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
 		rec_t*		rec		= page + offset;
 		rec_offs_init(offsets_);
 
@@ -2294,7 +2258,7 @@ page_cur_delete_rec(
 /*================*/
 	page_cur_t*		cursor,	/*!< in/out: a page cursor */
 	const dict_index_t*	index,	/*!< in: record descriptor */
-	const ulint*		offsets,/*!< in: rec_get_offsets(
+	const offset_t*		offsets,/*!< in: rec_get_offsets(
 					cursor->rec, index) */
 	mtr_t*			mtr)	/*!< in: mini-transaction handle
 					or NULL */
@@ -2430,18 +2394,17 @@ page_cur_delete_rec(
 #ifdef UNIV_COMPILE_TEST_FUNCS
 
 /*******************************************************************//**
-Print the first n numbers, generated by page_cur_lcg_prng() to make sure
+Print the first n numbers, generated by ut_rnd_gen() to make sure
 (visually) that it works properly. */
 void
-test_page_cur_lcg_prng(
-/*===================*/
+test_ut_rnd_gen(
 	int	n)	/*!< in: print first n numbers */
 {
 	int			i;
 	unsigned long long	rnd;
 
 	for (i = 0; i < n; i++) {
-		rnd = page_cur_lcg_prng();
+		rnd = ut_rnd_gen();
 		printf("%llu\t%%2=%llu %%3=%llu %%5=%llu %%7=%llu %%11=%llu\n",
 		       rnd,
 		       rnd % 2,
diff --git a/storage/innobase/page/page0page.cc b/storage/innobase/page/page0page.cc
index 77bdbf8bf2c..a916effa9b8 100644
--- a/storage/innobase/page/page0page.cc
+++ b/storage/innobase/page/page0page.cc
@@ -36,6 +36,7 @@ Created 2/2/1994 Heikki Tuuri
 #include "fut0lst.h"
 #include "btr0sea.h"
 #include "trx0sys.h"
+#include <algorithm>
 
 /*			THE INDEX PAGE
 			==============
@@ -581,8 +582,8 @@ page_copy_rec_list_end_no_locks(
 	page_cur_t	cur1;
 	rec_t*		cur2;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	page_cur_position(rec, block, &cur1);
@@ -814,8 +815,8 @@ page_copy_rec_list_start(
 	rtr_rec_move_t*	rec_move	= NULL;
 	rec_t*		ret
 		= page_rec_get_prev(page_get_supremum_rec(new_page));
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	/* Here, "ret" may be pointing to a user record or the
@@ -1051,8 +1052,8 @@ page_delete_rec_list_end(
 	page_zip_des_t*	page_zip	= buf_block_get_page_zip(block);
 	page_t*		page		= page_align(rec);
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(size == ULINT_UNDEFINED || size < srv_page_size);
@@ -1253,8 +1254,8 @@ page_delete_rec_list_start(
 	mtr_t*		mtr)	/*!< in: mtr */
 {
 	page_cur_t	cur1;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	mem_heap_t*	heap		= NULL;
 
 	rec_offs_init(offsets_);
@@ -1741,7 +1742,7 @@ void
 page_rec_print(
 /*===========*/
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets)/*!< in: record descriptor */
+	const offset_t*	offsets)/*!< in: record descriptor */
 {
 	ut_a(!page_rec_is_comp(rec) == !rec_offs_comp(offsets));
 	rec_print_new(stderr, rec, offsets);
@@ -1816,8 +1817,8 @@ page_print_list(
 	ulint		count;
 	ulint		n_recs;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_a((ibool)!!page_is_comp(page) == dict_table_is_comp(index->table));
@@ -1927,7 +1928,7 @@ ibool
 page_rec_validate(
 /*==============*/
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ulint		n_owned;
 	ulint		heap_no;
@@ -2412,8 +2413,13 @@ bool page_validate(const page_t* page, const dict_index_t* index)
 	ulint			n_slots;
 	ibool			ret		= TRUE;
 	ulint			i;
-	ulint*			offsets		= NULL;
-	ulint*			old_offsets	= NULL;
+	offset_t		offsets_1[REC_OFFS_NORMAL_SIZE];
+	offset_t		offsets_2[REC_OFFS_NORMAL_SIZE];
+	offset_t*		offsets		= offsets_1;
+	offset_t*		old_offsets	= offsets_2;
+
+	rec_offs_init(offsets_1);
+	rec_offs_init(offsets_2);
 
 #ifdef UNIV_GIS_DEBUG
 	if (dict_index_is_spatial(index)) {
@@ -2680,11 +2686,7 @@ next_rec:
 		}
 
 		/* set old_offsets to offsets; recycle offsets */
-		{
-			ulint* offs = old_offsets;
-			old_offsets = offsets;
-			offsets = offs;
-		}
+		std::swap(old_offsets, offsets);
 	}
 
 	if (page_is_comp(page)) {
@@ -2845,7 +2847,7 @@ page_delete_rec(
 		page_zip/*!< in: compressed page descriptor */
 #endif
 	,
-	const ulint*		offsets)/*!< in: offsets for record */
+	const offset_t*		offsets)/*!< in: offsets for record */
 {
 	bool		no_compress_needed;
 	buf_block_t*	block = pcur->block;
diff --git a/storage/innobase/page/page0zip.cc b/storage/innobase/page/page0zip.cc
index eb38b16c2d9..645032da3c2 100644
--- a/storage/innobase/page/page0zip.cc
+++ b/storage/innobase/page/page0zip.cc
@@ -2,7 +2,7 @@
 
 Copyright (c) 2005, 2016, Oracle and/or its affiliates. All Rights Reserved.
 Copyright (c) 2012, Facebook Inc.
-Copyright (c) 2014, 2019, MariaDB Corporation.
+Copyright (c) 2014, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -878,7 +878,7 @@ page_zip_compress_node_ptrs(
 	mem_heap_t*	heap)		/*!< in: temporary memory heap */
 {
 	int	err	= Z_OK;
-	ulint*	offsets = NULL;
+	offset_t* offsets = NULL;
 
 	do {
 		const rec_t*	rec = *recs++;
@@ -983,7 +983,7 @@ page_zip_compress_clust_ext(
 	FILE_LOGFILE
 	z_stream*	c_stream,	/*!< in/out: compressed page stream */
 	const rec_t*	rec,		/*!< in: record */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec) */
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec) */
 	ulint		trx_id_col,	/*!< in: position of of DB_TRX_ID */
 	byte*		deleted,	/*!< in: dense directory entry pointing
 					to the head of the free list */
@@ -1122,7 +1122,7 @@ page_zip_compress_clust(
 	mem_heap_t*	heap)		/*!< in: temporary memory heap */
 {
 	int	err		= Z_OK;
-	ulint*	offsets		= NULL;
+	offset_t* offsets		= NULL;
 	/* BTR_EXTERN_FIELD_REF storage */
 	byte*	externs		= storage - n_dense
 		* (DATA_TRX_ID_LEN + DATA_ROLL_PTR_LEN);
@@ -1985,7 +1985,7 @@ const byte*
 page_zip_apply_log_ext(
 /*===================*/
 	rec_t*		rec,		/*!< in/out: record */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec) */
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec) */
 	ulint		trx_id_col,	/*!< in: position of of DB_TRX_ID */
 	const byte*	data,		/*!< in: modification log */
 	const byte*	end)		/*!< in: end of modification log */
@@ -2086,7 +2086,7 @@ page_zip_apply_log(
 				/*!< in: heap_no and status bits for
 				the next record to uncompress */
 	dict_index_t*	index,	/*!< in: index of the page */
-	ulint*		offsets)/*!< in/out: work area for
+	offset_t*	offsets)/*!< in/out: work area for
 				rec_get_offsets_reverse() */
 {
 	const byte* const end = data + size;
@@ -2154,7 +2154,7 @@ page_zip_apply_log(
 		if (val & 1) {
 			/* Clear the data bytes of the record. */
 			mem_heap_t*	heap	= NULL;
-			ulint*		offs;
+			offset_t*	offs;
 			offs = rec_get_offsets(rec, index, offsets, is_leaf,
 					       ULINT_UNDEFINED, &heap);
 			memset(rec, 0, rec_offs_data_size(offs));
@@ -2304,7 +2304,7 @@ page_zip_decompress_node_ptrs(
 					sorted by address */
 	ulint		n_dense,	/*!< in: size of recs[] */
 	dict_index_t*	index,		/*!< in: the index of the page */
-	ulint*		offsets,	/*!< in/out: temporary offsets */
+	offset_t*	offsets,	/*!< in/out: temporary offsets */
 	mem_heap_t*	heap)		/*!< in: temporary memory heap */
 {
 	ulint		heap_status = REC_STATUS_NODE_PTR
@@ -2494,7 +2494,7 @@ page_zip_decompress_sec(
 					sorted by address */
 	ulint		n_dense,	/*!< in: size of recs[] */
 	dict_index_t*	index,		/*!< in: the index of the page */
-	ulint*		offsets)	/*!< in/out: temporary offsets */
+	offset_t*	offsets)	/*!< in/out: temporary offsets */
 {
 	ulint	heap_status	= REC_STATUS_ORDINARY
 		| PAGE_HEAP_NO_USER_LOW << REC_HEAP_NO_SHIFT;
@@ -2627,7 +2627,7 @@ page_zip_decompress_clust_ext(
 /*==========================*/
 	z_stream*	d_stream,	/*!< in/out: compressed page stream */
 	rec_t*		rec,		/*!< in/out: record */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec) */
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec) */
 	ulint		trx_id_col)	/*!< in: position of of DB_TRX_ID */
 {
 	ulint	i;
@@ -2742,7 +2742,7 @@ page_zip_decompress_clust(
 	ulint		n_dense,	/*!< in: size of recs[] */
 	dict_index_t*	index,		/*!< in: the index of the page */
 	ulint		trx_id_col,	/*!< index of the trx_id column */
-	ulint*		offsets,	/*!< in/out: temporary offsets */
+	offset_t*	offsets,	/*!< in/out: temporary offsets */
 	mem_heap_t*	heap)		/*!< in: temporary memory heap */
 {
 	int		err;
@@ -3046,7 +3046,7 @@ page_zip_decompress_low(
 	ulint		n_dense;/* number of user records on the page */
 	ulint		trx_id_col = ULINT_UNDEFINED;
 	mem_heap_t*	heap;
-	ulint*		offsets;
+	offset_t*	offsets;
 
 	ut_ad(page_zip_simple_validate(page_zip));
 	UNIV_MEM_ASSERT_W(page, srv_page_size);
@@ -3170,10 +3170,10 @@ zlib_error:
 		ulint	n = 1 + 1/* node ptr */ + REC_OFFS_HEADER_SIZE
 			+ dict_index_get_n_fields(index);
 
-		offsets = static_cast<ulint*>(
+		offsets = static_cast<offset_t*>(
 			mem_heap_alloc(heap, n * sizeof(ulint)));
 
-		*offsets = n;
+		rec_offs_set_n_alloc(offsets, n);
 	}
 
 	/* Decompress the records in heap_no order. */
@@ -3338,7 +3338,19 @@ page_zip_validate_low(
 		   FIL_PAGE_LSN - FIL_PAGE_PREV)
 	    || memcmp(page_zip->data + FIL_PAGE_TYPE, page + FIL_PAGE_TYPE, 2)
 	    || memcmp(page_zip->data + FIL_PAGE_DATA, page + FIL_PAGE_DATA,
-		      PAGE_DATA - FIL_PAGE_DATA)) {
+		      PAGE_ROOT_AUTO_INC)
+	    /* The PAGE_ROOT_AUTO_INC can be updated while holding an SX-latch
+	    on the clustered index root page (page number 3 in .ibd files).
+	    That allows concurrent readers (holding buf_block_t::lock S-latch).
+	    Because we do not know what type of a latch our caller is holding,
+	    we will ignore the field on clustered index root pages in order
+	    to avoid false positives. */
+	    || (page_get_page_no(page) != 3/* clustered index root page */
+		&& memcmp(&page_zip->data[FIL_PAGE_DATA + PAGE_ROOT_AUTO_INC],
+			  &page[FIL_PAGE_DATA + PAGE_ROOT_AUTO_INC], 8))
+	    || memcmp(&page_zip->data[FIL_PAGE_DATA + PAGE_HEADER_PRIV_END],
+		      &page[FIL_PAGE_DATA + PAGE_HEADER_PRIV_END],
+		      PAGE_DATA - FIL_PAGE_DATA - PAGE_HEADER_PRIV_END)) {
 		page_zip_fail(("page_zip_validate: page header\n"));
 		page_zip_hexdump(page_zip, sizeof *page_zip);
 		page_zip_hexdump(page_zip->data, page_zip_get_size(page_zip));
@@ -3398,7 +3410,7 @@ page_zip_validate_low(
 		committed.  Let us tolerate that difference when we
 		are performing a sloppy validation. */
 
-		ulint*		offsets;
+		offset_t*	offsets;
 		mem_heap_t*	heap;
 		const rec_t*	rec;
 		const rec_t*	trec;
@@ -3422,11 +3434,12 @@ page_zip_validate_low(
 				differed.  Let us ignore it. */
 				page_zip_fail(("page_zip_validate:"
 					       " min_rec_flag"
-					       " (%s%lu,%lu,0x%02lx)\n",
+					       " (%s" ULINTPF "," ULINTPF
+					       ",0x%02x)\n",
 					       sloppy ? "ignored, " : "",
 					       page_get_space_id(page),
 					       page_get_page_no(page),
-					       (ulong) page[offset]));
+					       page[offset]));
 				/* We don't check for spatial index, since
 				the "minimum record" could be deleted when
 				doing rtr_update_mbr_field.
@@ -3565,7 +3578,7 @@ page_zip_write_rec_ext(
 	const page_t*	page,		/*!< in: page containing rec */
 	const byte*	rec,		/*!< in: record being written */
 	dict_index_t*	index,		/*!< in: record descriptor */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec, index) */
 	ulint		create,		/*!< in: nonzero=insert, zero=update */
 	ulint		trx_id_col,	/*!< in: position of DB_TRX_ID */
 	ulint		heap_no,	/*!< in: heap number of rec */
@@ -3684,7 +3697,7 @@ page_zip_write_rec(
 	page_zip_des_t*	page_zip,/*!< in/out: compressed page */
 	const byte*	rec,	/*!< in: record being written */
 	dict_index_t*	index,	/*!< in: the index the record belongs to */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	ulint		create)	/*!< in: nonzero=insert, zero=update */
 {
 	const page_t*	page;
@@ -3934,7 +3947,7 @@ page_zip_write_blob_ptr(
 	const byte*	rec,	/*!< in/out: record whose data is being
 				written */
 	dict_index_t*	index,	/*!< in: index of the page */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	ulint		n,	/*!< in: column index */
 	mtr_t*		mtr)	/*!< in: mini-transaction handle,
 				or NULL if no logging is needed */
@@ -4155,7 +4168,7 @@ void
 page_zip_write_trx_id_and_roll_ptr(
 	page_zip_des_t*	page_zip,
 	byte*		rec,
-	const ulint*	offsets,
+	const offset_t*	offsets,
 	ulint		trx_id_col,
 	trx_id_t	trx_id,
 	roll_ptr_t	roll_ptr,
@@ -4294,7 +4307,7 @@ page_zip_clear_rec(
 	page_zip_des_t*	page_zip,	/*!< in/out: compressed page */
 	byte*		rec,		/*!< in: record to clear */
 	const dict_index_t*	index,	/*!< in: index of rec */
-	const ulint*	offsets)	/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets)	/*!< in: rec_get_offsets(rec, index) */
 {
 	ulint	heap_no;
 	page_t*	page	= page_align(rec);
@@ -4500,7 +4513,7 @@ page_zip_dir_delete(
 	page_zip_des_t*		page_zip,	/*!< in/out: compressed page */
 	byte*			rec,		/*!< in: deleted record */
 	const dict_index_t*	index,		/*!< in: index of rec */
-	const ulint*		offsets,	/*!< in: rec_get_offsets(rec) */
+	const offset_t*		offsets,	/*!< in: rec_get_offsets(rec) */
 	const byte*		free)		/*!< in: previous start of
 						the free list */
 {
diff --git a/storage/innobase/pars/lexyy.cc b/storage/innobase/pars/lexyy.cc
index e7f3981e0fe..1e93ec3ed50 100644
--- a/storage/innobase/pars/lexyy.cc
+++ b/storage/innobase/pars/lexyy.cc
@@ -356,8 +356,8 @@ static void yynoreturn yy_fatal_error ( const char* msg  );
 	(yy_hold_char) = *yy_cp; \
 	*yy_cp = '\0'; \
 	(yy_c_buf_p) = yy_cp;
-#define YY_NUM_RULES 123
-#define YY_END_OF_BUFFER 124
+#define YY_NUM_RULES 102
+#define YY_END_OF_BUFFER 103
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -365,53 +365,42 @@ struct yy_trans_info
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static const flex_int16_t yy_accept[404] =
+static const flex_int16_t yy_accept[307] =
     {   0,
-        0,    0,  118,  118,    0,    0,    0,    0,  124,  122,
-      121,  121,    8,  122,  113,    5,  102,  108,  111,  109,
-      106,  110,  122,  112,    1,  122,  107,  105,  103,  104,
-      116,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-      114,  115,  118,  119,    6,    7,    9,   10,  121,    4,
-       97,  117,    2,    1,    3,   98,   99,  101,  100,    0,
-       95,    0,   95,   95,   95,   95,   95,   44,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   28,   17,   25,   95,   95,   95,   95,
-
-       95,   95,   54,   62,   95,   14,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,  118,  119,  119,  120,    6,    7,
-        9,   10,    2,    0,   96,   13,   45,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   27,   95,   95,   95,   41,
-       95,   95,   95,   95,   21,   95,   95,   95,   95,   95,
-       15,   95,   95,   95,   18,   95,   95,   95,   95,   95,
-       81,   95,   95,   95,   51,   95,   12,   95,   36,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-
-        0,   96,   95,   95,   95,   95,   20,   95,   24,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       46,   95,   30,   95,   88,   95,   95,   39,   95,   95,
-       95,   95,   95,   48,   95,   93,   90,   32,   92,   95,
-       11,   65,   95,   95,   95,   42,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   29,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   86,    0,   95,   26,
-       95,   95,   95,   67,   95,   95,   95,   95,   37,   95,
-       95,   95,   95,   95,   95,   31,   66,   23,   95,   59,
-       95,   76,   95,   95,   95,   43,   95,   95,   95,   95,
-
-       95,   95,   95,   95,   91,   95,   95,   56,   95,   95,
-       95,   95,   95,   95,   95,   40,   33,    0,   80,   94,
-       19,   95,   95,   84,   95,   75,   55,   95,   64,   95,
-       52,   95,   95,   47,   95,   77,   95,   79,   95,   95,
-       34,   95,   95,   95,   35,   73,   95,   95,   95,   95,
-       60,   95,   50,   49,   95,   95,   95,   57,   53,   63,
-       95,   95,   22,   95,   95,   74,   82,   95,   95,   78,
-       95,   69,   95,   95,   95,   95,   95,   38,   89,   68,
-       95,   85,   95,   95,   95,   87,   95,   95,   61,   16,
-       95,   71,   70,   95,   58,   83,   95,   95,   95,   95,
-
-       95,   72,    0
+        0,    0,   97,   97,    0,    0,    0,    0,  103,  101,
+      100,  100,    8,  101,   92,    5,   81,   87,   90,   88,
+       85,   89,  101,   91,    1,  101,   86,   84,   82,   83,
+       95,   74,   74,   74,   74,   74,   74,   74,   74,   74,
+       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
+       93,   94,   97,   98,    6,    7,    9,   10,  100,    4,
+       76,   96,    2,    1,    3,   77,   78,   80,   79,    0,
+       74,    0,   74,   74,   74,   74,   36,   74,   74,   74,
+       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
+       23,   17,   20,   74,   74,   74,   74,   74,   74,   46,
+
+       52,   74,   14,   74,   74,   74,   74,   74,   74,   74,
+       74,   74,   74,   74,   74,   74,   74,   74,   97,   98,
+       98,   99,    6,    7,    9,   10,    2,    0,   75,   13,
+       37,   74,   74,   74,   74,   74,   74,   74,   74,   74,
+       74,   74,   74,   74,   74,   22,   74,   74,   34,   74,
+       74,   74,   74,   18,   74,   74,   74,   74,   74,   15,
+       74,   74,   74,   74,   74,   74,   74,   43,   74,   12,
+       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
+        0,   75,   74,   74,   19,   74,   74,   74,   74,   74,
+       74,   74,   74,   74,   74,   38,   25,   74,   67,   74,
+
+       32,   74,   74,   74,   74,   40,   74,   72,   69,   27,
+       71,   74,   11,   55,   74,   74,   74,   74,   74,   74,
+       74,   74,   24,   74,   74,   74,   74,   74,   74,   66,
+        0,   21,   74,   57,   74,   74,   74,   31,   74,   74,
+       74,   74,   74,   26,   56,   74,   49,   74,   62,   74,
+       74,   35,   74,   74,   74,   74,   70,   74,   48,   74,
+       74,   74,   74,   33,   28,    0,   73,   74,   64,   61,
+       47,   74,   54,   74,   44,   74,   39,   63,   74,   74,
+       29,   74,   30,   60,   74,   50,   42,   41,   74,   45,
+       53,   74,   74,   74,   74,   74,   74,   68,   58,   74,
+
+       65,   74,   51,   16,   59,    0
     } ;
 
 static const YY_CHAR yy_ec[256] =
@@ -424,12 +413,12 @@ static const YY_CHAR yy_ec[256] =
        17,   17,   17,   17,   17,   17,   17,   18,   19,   20,
        21,   22,   23,   24,   25,   26,   27,   28,   29,   30,
        31,   32,   33,   34,   35,   36,   37,   38,   39,   40,
-       41,   42,   43,   44,   45,   46,   47,   48,   49,   50,
-        1,    1,    1,    1,   51,    1,   34,   34,   34,   34,
+       41,   42,   43,   44,   45,   46,   47,   48,   49,   34,
+        1,    1,    1,    1,   50,    1,   34,   34,   34,   34,
 
-       34,   34,   34,   34,   34,   34,   34,   52,   34,   34,
-       34,   34,   53,   34,   54,   34,   34,   34,   34,   34,
-       34,   34,   55,    1,   56,    1,    1,    1,    1,    1,
+       34,   34,   34,   34,   34,   34,   34,   51,   34,   34,
+       34,   34,   52,   34,   53,   34,   34,   34,   34,   34,
+       34,   34,   54,    1,   55,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -446,418 +435,324 @@ static const YY_CHAR yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static const YY_CHAR yy_meta[57] =
+static const YY_CHAR yy_meta[56] =
     {   0,
         1,    1,    1,    2,    3,    1,    1,    4,    1,    1,
         5,    1,    1,    1,    1,    6,    7,    1,    1,    1,
         8,    1,    1,    6,    9,    9,    9,    9,    9,    9,
         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
-        9,    9,    9,    9,    1,    1
+        9,    9,    9,    1,    1
     } ;
 
-static const flex_int16_t yy_base[417] =
+static const flex_int16_t yy_base[320] =
     {   0,
-        0,    0,  296,  281,  283,  280,  261,  252,  253, 1285,
-       55,   57, 1285,    0, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285,  211,  213,   46,  202, 1285,   43, 1285,  199,
-     1285,   46,   50,   56,   52,   66,   64,   51,   81,   92,
-       91,   94,   96,  111,  113,  116,  130,  134,   53,  143,
-     1285, 1285,    0,  106,    0,  206,    0,  205,  141,    0,
-     1285, 1285,  177,   56,  152, 1285, 1285, 1285, 1285,  161,
-      140,  147,  152,  154,  155,  161,  167,  171,  177,  172,
-      184,  174,  188,  189,  191,  194,  203,  212,  217,  219,
-      222,  223,  228,  224,  226,  233,  235,  239,  244,  251,
-
-      256,  260,  261,  262,  265,  271,  266,  281,  277,  287,
-      282,  288,  303,  306,  307,  292,  310,  321,  322,  323,
-      324,  325,  335,  338,    0,  112,  173, 1285,    0,  152,
-        0,  145,  130,   59,    0,  339,  341,  353,  351,  354,
-      365,  367,  355,  372,  376,  383,  379,  386,  388,  385,
-      398,  392,  402,  401,  414,  415,  416,  417,  426,  430,
-      432,  437,  433,  439,  442,  443,  449,  456,  460,  461,
-      463,  470,  472,  473,  479,  483,  485,  489,  492,  495,
-      498,  499,  502,  508,  509,  514,  515,  518,  520,  527,
-      530,  534,  536,  541,  543,  553,  555,  557,  559,  568,
-
-       41,    0,  564,  569,  570,  573,  574,  585,  580,  589,
-      586,  595,  598,  600,  605,  610,  611,  617,  620,  615,
-      622,  627,  626,  631,  641,  642,  646,  647,  648,  651,
-      652,  653,  657,  662,  663,  667,  669,  673,  680,  682,
-      684,  685,  686,  687,  689,  696,  698,  700,  701,  703,
-      699,  710,  714,  716,  729,  732,  731,  733,  735,  734,
-      746,  747,  748,  752,  753,  759,  749,   39,  769,  770,
-      771,  773,  774,  780,  783,  784,  787,  785,  786,  802,
-      800,  803,  816,  817,  818,  819,  820,  823,  833,  835,
-      836,  837,  838,  839,  848,  849,  852,  853,  854,  859,
-
-      863,  870,  868,  872,  875,  884,  885,  887,  889,  890,
-      888,  904,  906,  907,  908,  918,  919,   73,  921,  922,
-      923,  924,  933,  934,  936,  937,  938,  939,  940,  949,
-      952,  955,  953,  965,  969,  970,  971,  972,  974,  975,
-      981,  984,  986,  988,  990,  991, 1000, 1006, 1004, 1009,
-     1016, 1018, 1020, 1021, 1025, 1027, 1032, 1034, 1038, 1039,
-     1041, 1043, 1048, 1050, 1052, 1055, 1059, 1064, 1066, 1068,
-     1071, 1073, 1077, 1084, 1086, 1087, 1091, 1093, 1098, 1100,
-     1102, 1104, 1105, 1111, 1114, 1116, 1117, 1118, 1120, 1127,
-     1129, 1130, 1134, 1139, 1141, 1145, 1146, 1148, 1150, 1151,
-
-     1155, 1157, 1285, 1197, 1206, 1215, 1218, 1221, 1225, 1234,
-     1243, 1252, 1261, 1268, 1272, 1275
+        0,    0,  262,  259,  249,  244,  239,  234,  236,  960,
+       54,   56,  960,    0,  960,  960,  960,  960,  960,  960,
+      960,  960,  217,  220,   45,  186,  960,   42,  960,  184,
+      960,   45,   49,   55,   51,   65,   80,   50,   69,   94,
+       90,   92,  104,   60,  114,  116,  131,  134,  135,  149,
+      960,  960,    0,   61,    0,  194,    0,  197,  133,    0,
+      960,  960,  163,   53,  143,  960,  960,  960,  960,  147,
+      125,  123,  138,  151,  152,  153,  155,  166,  169,  173,
+      170,  171,  176,  180,  193,  182,  200,  204,  206,  209,
+      210,  211,  213,  224,  225,  226,  235,  240,  242,  245,
+
+      251,  252,  255,  256,  258,  261,  270,  274,  272,  277,
+      289,  288,  276,  294,  295,  300,  304,  305,    0,   79,
+      110,  960,    0,  116,    0,  113,   98,   58,    0,  306,
+      315,  316,  318,  319,  322,  328,  329,  332,  334,  338,
+      344,  353,  351,  354,  366,  360,  367,  369,  376,  378,
+      381,  385,  388,  382,  394,  400,  403,  404,  406,  407,
+      410,  417,  423,  424,  426,  429,  433,  440,  442,  443,
+      444,  445,  454,  456,  459,  461,  472,  473,  474,  477,
+       53,    0,  475,  478,  479,  490,  502,  504,  505,  507,
+      508,  509,  511,  518,  520,  523,  524,  525,  529,  538,
+
+      541,  542,  543,  545,  547,  544,  556,  557,  558,  559,
+      560,  569,  572,  574,  578,  581,  579,  583,  588,  590,
+      600,  601,  602,  607,  611,  613,  612,  618,  622,  629,
+       41,  634,  636,  638,  639,  643,  645,  648,  649,  650,
+      655,  659,  661,  660,  670,  675,  676,  679,  680,  682,
+      686,  689,  691,  696,  693,  700,  705,  706,  709,  711,
+      712,  716,  722,  723,  726,   72,  727,  736,  737,  738,
+      739,  740,  742,  743,  752,  753,  755,  757,  758,  759,
+      764,  770,  769,  771,  774,  784,  785,  786,  787,  789,
+      790,  791,  796,  801,  802,  803,  806,  807,  812,  817,
+
+      816,  823,  826,  828,  832,  960,  872,  881,  890,  893,
+      896,  900,  909,  918,  927,  936,  943,  947,  950
     } ;
 
-static const flex_int16_t yy_def[417] =
+static const flex_int16_t yy_def[320] =
     {   0,
-      403,    1,  404,  404,  405,  405,  406,  406,  403,  403,
-      403,  403,  403,  407,  403,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  408,  403,  403,  403,  403,
-      403,  409,  409,  409,  409,  409,   34,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      403,  403,  410,  411,  412,  403,  413,  403,  403,  407,
-      403,  403,  403,  403,  408,  403,  403,  403,  403,  414,
-      409,  415,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  410,  411,  411,  403,  412,  403,
-      413,  403,  403,  403,  416,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-
-      403,  416,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  403,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  403,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-      409,  409,  409,  409,  409,  409,  409,  409,  409,  409,
-
-      409,  409,    0,  403,  403,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  403
+      306,    1,  307,  307,  308,  308,  309,  309,  306,  306,
+      306,  306,  306,  310,  306,  306,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  311,  306,  306,  306,  306,
+      306,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      306,  306,  313,  314,  315,  306,  316,  306,  306,  310,
+      306,  306,  306,  306,  311,  306,  306,  306,  306,  317,
+      312,  318,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  313,  314,
+      314,  306,  315,  306,  316,  306,  306,  306,  319,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      306,  319,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      306,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  306,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+      312,  312,  312,  312,  312,  312,  312,  312,  312,  312,
+
+      312,  312,  312,  312,  312,    0,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  306,  306,  306,  306
     } ;
 
-static const flex_int16_t yy_nxt[1342] =
+static const flex_int16_t yy_nxt[1016] =
     {   0,
        10,   11,   12,   13,   10,   14,   15,   16,   17,   18,
        19,   20,   21,   22,   23,   24,   25,   26,   27,   28,
        29,   30,   31,   10,   32,   33,   34,   35,   36,   37,
        38,   38,   39,   38,   38,   40,   41,   42,   43,   44,
        38,   45,   46,   47,   48,   49,   50,   38,   38,   38,
-       38,   38,   38,   38,   51,   52,   59,   59,   59,   59,
-       63,   70,   64,   67,   68,   70,   70,   70,   70,   72,
-       63,   70,   64,   72,   72,   72,   72,  122,   75,   72,
-       84,   70,   76,   73,   85,   77,  135,   79,   74,   72,
-      318,   80,   89,  268,   81,   71,   70,   82,   78,   90,
-
-       83,   86,   91,   87,   72,   92,   70,   70,   93,   70,
-       94,   70,  201,   88,   72,   72,  127,   72,   95,   72,
-       97,  128,  403,   96,   98,  103,   70,  403,   70,  100,
-       99,   70,  101,  104,   72,  105,   72,  106,  102,   72,
-      107,  109,   59,   59,  112,   70,  133,  113,  132,   70,
-      110,  111,  108,   72,  117,   70,  114,   72,   70,  130,
-      115,  118,   70,   72,  116,  134,   72,   70,  119,   70,
-       70,  120,  403,  121,  123,   72,   70,   72,   72,  136,
-      137,  124,   70,  127,   72,  139,   70,   70,  128,   70,
-       72,  140,   70,  133,   72,   72,  138,   72,  141,   70,
-
-       72,  143,  149,   70,   70,  142,   70,   72,  132,   70,
-      144,   72,   72,  130,   72,  151,  145,   72,   70,   69,
-      146,  147,   66,   62,  152,   61,   72,   70,  148,  150,
-      156,  153,   70,  154,   70,   72,  155,   70,   70,   70,
-       72,   70,   72,   70,  157,   72,   72,   72,   70,   72,
-       70,   72,  403,  163,   70,   58,   72,  159,   72,   70,
-      158,  161,   72,  160,   58,  162,   70,   72,  164,  165,
-      168,   70,  166,  167,   72,   70,   70,   70,  170,   72,
-       70,   70,  169,   72,   72,   72,   70,   56,   72,   72,
-       56,   54,   70,  173,   72,  172,   70,   70,  174,  171,
-
-       72,  178,   70,   70,   72,   72,   54,   70,  403,  175,
-       72,   72,  403,  176,  181,   72,  179,  182,   70,  177,
-      180,   70,   70,  184,  403,   70,   72,  186,  183,   72,
-       72,  185,  188,   72,  190,  191,   70,   70,   70,   70,
-       70,  187,  403,  189,   72,   72,   72,   72,   72,  192,
-       70,  196,  403,   70,   70,  194,   70,  403,   72,  403,
-      197,   72,   72,  198,   72,  195,   70,  199,   70,   70,
-       70,  403,  193,  403,   72,  403,   72,   72,   72,  200,
-       70,  203,   70,  204,  403,  403,  205,   70,   72,  206,
-       72,   70,  207,  208,   70,   72,  209,  403,   70,   72,
-
-       70,   70,   72,   70,  403,  214,   72,   70,   72,   72,
-      403,   72,  216,   70,  210,   72,   70,   70,  211,  212,
-      220,   72,  213,  215,   72,   72,  217,  218,  221,   70,
-       70,   70,   70,  219,  403,  403,  403,   72,   72,   72,
-       72,   70,  223,  226,  222,   70,  224,   70,   70,   72,
-      227,  403,   70,   72,   70,   72,   72,   70,   70,  225,
-       72,  230,   72,  229,   70,   72,   72,  231,  228,  403,
-      233,   70,   72,  235,  403,   70,   70,  236,   70,   72,
-      234,  403,  232,   72,   72,   70,   72,   70,   70,  239,
-      237,  403,  240,   72,   70,   72,   72,  403,   70,  238,
-
-       70,  243,   72,  403,   70,  241,   72,   70,   72,  242,
-       70,  245,   72,   70,   70,   72,  246,   70,   72,  403,
-      244,   72,   72,   70,   70,   72,  403,  247,  403,   70,
-       70,   72,   72,   70,  250,   70,  252,   72,   72,  248,
-      403,   72,   70,   72,  403,   70,  403,  403,  249,   70,
-       72,   70,  251,   72,  255,  253,   70,   72,   70,   72,
-      254,  258,  259,  403,   72,  256,   72,  403,   70,  403,
-       70,  257,   70,  260,   70,  262,   72,  263,   72,   70,
-       72,  261,   72,   70,   70,   70,  403,   72,   70,   70,
-      403,   72,   72,   72,  266,   70,   72,   72,  265,  264,
-
-       70,   70,  267,   72,   70,  269,  270,  271,   72,   72,
-       70,  403,   72,   70,  272,   70,  403,  274,   72,  273,
-       70,   72,  277,   72,  278,   70,   70,  276,   72,  275,
-       70,  403,   70,   72,   72,   70,  403,   70,   72,  281,
-       72,   70,   70,   72,  283,   72,   70,  403,  279,   72,
-       72,  403,  403,  280,   72,  282,   70,   70,  284,  285,
-      286,   70,   70,   70,   72,   72,   70,   70,   70,   72,
-       72,   72,   70,  287,   72,   72,   72,   70,   70,  403,
-       72,  403,   70,  403,   70,   72,   72,  293,   70,  288,
-       72,  289,   72,  291,  292,   70,   72,   70,  290,   70,
-
-       70,   70,   70,   72,   70,   72,  294,   72,   72,   72,
-       72,   70,   72,   70,   70,   70,   70,  298,   70,   72,
-      295,   72,   72,   72,   72,   70,   72,  296,  302,   70,
-      297,   70,  403,   72,  403,  403,  304,   72,  303,   72,
-      299,  300,  305,  301,   70,  403,   70,   70,   70,   70,
-       70,  403,   72,  307,   72,   72,   72,   72,   72,  306,
-      308,   70,   70,   70,   70,  309,  310,   70,   70,   72,
-       72,   72,   72,  403,   70,   72,   72,  313,  311,  403,
-      315,  316,   72,  403,   70,   70,   70,  317,   70,   70,
-      312,  314,   72,   72,   72,   70,   72,   72,   70,   70,
-
-       70,   70,   70,   72,  403,  403,   72,   72,   72,   72,
-       72,  323,  319,  325,  320,   70,  403,   70,   70,  403,
-      403,  321,  403,   72,  322,   72,   72,  324,  326,  403,
-      327,   70,   70,   70,   70,   70,  403,  328,   70,   72,
-       72,   72,   72,   72,  329,  331,   72,  403,   70,  403,
-       70,   70,   70,   70,   70,  332,   72,  330,   72,   72,
-       72,   72,   72,   70,   70,  333,  335,   70,   70,   70,
-      336,   72,   72,  403,   70,   72,   72,   72,   70,  334,
-      339,  338,   72,   70,  403,   70,   72,   70,  403,  403,
-       70,   72,  337,   72,  343,   72,  341,  340,   72,   70,
-
-       70,  403,   70,   70,   70,   70,  342,   72,   72,  344,
-       72,   72,   72,   72,  349,  345,  403,  403,  403,   70,
-      403,   70,   70,   70,  350,  346,  348,   72,  347,   72,
-       72,   72,  351,   70,   70,  353,   70,   70,   70,   70,
-      403,   72,   72,  352,   72,   72,   72,   72,   70,   70,
-      354,   70,   70,   70,   70,   70,   72,   72,  403,   72,
-       72,   72,   72,   72,   70,  403,  356,   70,   70,  403,
-       70,  403,   72,  355,  357,   72,   72,  360,   72,  358,
-       70,  361,  359,  403,   70,   70,   70,   70,   72,   70,
-       70,  362,   72,   72,   72,   72,   70,   72,   72,   70,
-
-      403,   70,  403,   70,   72,   70,   70,   72,  364,   72,
-      363,   72,  368,   72,   72,   70,  366,  403,  365,   70,
-      369,   70,  403,   72,   70,  367,  403,   72,  370,   72,
-      371,   70,   72,   70,  373,   70,   70,  403,  403,   72,
-       70,   72,   70,   72,   72,  372,  374,   70,   72,   70,
-       72,  403,  403,   70,   70,   72,   70,   72,   70,  376,
-      377,   72,   72,   70,   72,   70,   72,   70,  375,  403,
-       70,   72,  403,   72,   70,   72,  403,  380,   72,   70,
-      379,   70,   72,   70,  378,  403,   70,   72,   70,   72,
-      403,   72,   70,  381,   72,  403,   72,  403,  382,   70,
-
-       72,   70,   70,  383,  403,  385,   70,   72,   70,   72,
-       72,  386,  384,   70,   72,   70,   72,   70,  389,   70,
-       70,   72,  403,   72,  387,   72,   70,   72,   72,   70,
-      390,   70,   70,   70,   72,   70,  388,   72,  403,   72,
-       72,   72,   70,   72,   70,   70,  395,  403,  391,   70,
-       72,  403,   72,   72,   70,  393,   70,   72,  396,  392,
-       70,   70,   72,   70,   72,   70,   70,  394,   72,   72,
-       70,   72,   70,   72,   72,  400,  397,  403,   72,  401,
-       72,  403,  403,  403,  399,  403,  403,  403,  403,  403,
-      398,  403,  403,  403,  403,  403,  402,   53,   53,   53,
-
-       53,   53,   53,   53,   53,   53,   55,   55,   55,   55,
-       55,   55,   55,   55,   55,   57,   57,   57,   57,   57,
-       57,   57,   57,   57,   60,  403,   60,   65,   65,   65,
-       71,   71,  403,   71,  125,  125,  125,  125,  403,  125,
-      125,  125,  125,  126,  126,  126,  126,  126,  126,  126,
-      126,  126,  129,  129,  129,  403,  129,  129,  129,  129,
-      129,  131,  403,  131,  131,  131,  131,  131,  131,  131,
-      135,  403,  403,  403,  403,  403,  135,   72,   72,  403,
-       72,  202,  403,  202,    9,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
-
-      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
-      403
+       38,   38,   38,   51,   52,   59,   59,   59,   59,   63,
+       70,   64,   67,   68,   70,   70,   70,   63,   72,   64,
+       70,  121,   72,   72,   72,   70,  122,   75,   72,   83,
+       70,   76,   73,   72,   70,  129,   78,   74,   72,  306,
+       79,  266,   72,   80,  306,   70,   81,   77,   91,   82,
+
+       84,  104,   85,   72,  231,   70,   92,   70,   87,   70,
+      181,   93,   86,   72,  127,   72,  126,   72,   88,   70,
+      121,   89,   94,  124,   90,  122,   95,   72,   97,   70,
+       98,   70,   96,  100,   59,   59,   99,   72,   70,   72,
+       70,  101,  105,  102,  107,  103,   70,  108,   72,   70,
+       70,  128,  106,   70,   72,  111,  109,   72,   72,  116,
+      110,   72,  112,  306,   70,  130,   70,   70,   70,  113,
+       70,  114,   72,  115,   72,   72,   72,  131,   72,  127,
+      117,   70,  132,  133,   70,   70,   70,  118,   70,   72,
+      134,   70,   72,   72,   72,   70,   72,   70,  140,   72,
+
+      126,  124,  142,   72,   69,   72,   66,  135,   70,  137,
+      138,  143,  141,  136,  147,   70,   72,  139,  144,   70,
+      146,   70,  145,   72,   70,   70,   70,   72,   70,   72,
+       62,   61,   72,   72,   72,  306,   72,   58,  152,   70,
+       70,   70,   58,  148,  150,  149,  151,   72,   72,   72,
+       70,   56,  157,  153,  154,   70,   56,   70,   72,  156,
+       70,  155,  159,   72,  158,   72,   70,   70,   72,   54,
+       70,   70,   54,   70,   72,   72,   70,  161,   72,   72,
+      162,   72,  163,  160,   72,   70,  306,   70,  306,   70,
+      306,   70,   70,   72,  164,   72,  166,   72,  169,   72,
+
+       72,  165,  171,   70,   70,  167,  306,  170,  306,   70,
+       70,   72,   72,  168,  172,   70,  173,   72,   72,   70,
+       70,   70,  176,   72,  306,  174,  175,   72,   72,   72,
+       70,   70,  178,   70,   70,  177,  179,   70,   72,   72,
+      306,   72,   72,   70,   70,   72,  180,   70,  183,   70,
+      184,   72,   72,   70,  306,   72,  306,   72,  189,   70,
+      185,   72,  191,  306,  186,  188,   70,   72,   70,   70,
+      187,  190,  306,  306,   72,   70,   72,   72,  306,  195,
+      196,   70,   70,   72,   70,  192,  193,  306,  194,   72,
+       72,   70,   72,   70,  197,  200,   70,   70,  198,   72,
+
+       70,   72,  306,   70,   72,   72,  306,  202,   72,   70,
+      199,   72,  306,  203,  201,   70,  204,   72,   70,   70,
+      206,   70,   70,   72,  207,   70,   72,   72,  208,   72,
+       72,  205,   70,   72,  211,  306,  212,  209,   70,   70,
+       72,   70,  306,  210,   70,  213,   72,   72,   70,   72,
+      216,  215,   72,  306,  214,   70,   72,   70,   70,   70,
+       70,  219,  306,   72,  218,   72,   72,   72,   72,   70,
+      217,   70,  306,  306,   70,  306,   70,   72,  306,   72,
+      222,  224,   72,  220,   72,  226,  221,   70,   70,   70,
+       70,  223,   70,   70,   70,   72,   72,   72,   72,  225,
+
+       72,   72,   72,  306,  306,   70,  306,  306,  306,  229,
+      306,  230,  232,   72,  228,  233,  227,   70,  234,   70,
+       70,  306,   70,   70,   70,   72,   70,   72,   72,  237,
+       72,   72,   72,   70,   72,   70,  236,  240,   70,   70,
+       70,   72,  242,   72,   70,  235,   72,   72,   72,  241,
+      238,  239,   72,   70,  244,  306,   70,   70,   70,   70,
+       70,   72,   70,  243,   72,   72,   72,   72,   72,  245,
+       72,   70,   70,   70,   70,   70,  306,  306,  306,   72,
+       72,   72,   72,   72,   70,  246,  248,   70,  249,   70,
+      247,  306,   72,   70,   70,   72,   70,   72,   70,  250,
+
+      306,   72,   72,   70,   72,   70,   72,  251,  255,  253,
+      306,   72,  306,   72,  256,   70,   70,   70,  257,  252,
+      254,  306,   70,   72,   72,   72,   70,   70,   70,  259,
+       72,  306,  306,   70,   72,   72,   72,   70,  306,  260,
+      263,   72,  306,  258,   70,   72,  264,  306,  306,   70,
+      265,   70,   72,   70,   70,  261,  262,   72,   70,   72,
+       70,   72,   72,   70,   70,   70,   72,  268,   72,  306,
+       70,   72,   72,   72,   70,   70,   70,  271,   72,  267,
+      306,  306,   72,   72,   72,   70,  269,  272,  270,  275,
+       70,   70,  306,   72,   70,   70,  273,   70,   72,   72,
+
+      274,   70,   72,   72,   70,   72,   70,  276,   70,   72,
+      306,   70,   72,  278,   72,   70,   72,  282,  280,   72,
+       70,   70,  277,   72,   70,  306,   70,   70,   72,   72,
+      279,   70,   72,  281,   72,   72,  306,   70,   70,   72,
+      286,   70,   70,  283,  287,   72,   72,  284,  285,   72,
+       72,   70,   70,   70,   70,   70,  306,   70,   70,   72,
+       72,   72,   72,   72,  288,   72,   72,   70,   70,  306,
+       70,  291,   70,   70,   70,   72,   72,  289,   72,   70,
+       72,   72,   72,  290,   70,   70,   70,   72,  306,   70,
+      306,  292,   72,   72,   72,  293,  295,   72,  296,   70,
+
+       70,   70,   70,  294,   70,   70,   70,   72,   72,   72,
+       72,   70,   72,   72,   72,  297,   70,   70,   70,   72,
+      306,   70,   70,  299,   72,   72,   72,   70,  298,   72,
+       72,   70,   70,  303,  306,   72,  301,  306,   70,   72,
+       72,   70,  300,   70,  302,  304,   72,   70,  306,   72,
+      306,   72,  306,  306,  306,   72,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+      306,  305,   53,   53,   53,   53,   53,   53,   53,   53,
+       53,   55,   55,   55,   55,   55,   55,   55,   55,   55,
+       57,   57,   57,   57,   57,   57,   57,   57,   57,   60,
+
+      306,   60,   65,   65,   65,   71,   71,  306,   71,  119,
+      119,  119,  119,  306,  119,  119,  119,  119,  120,  120,
+      120,  120,  120,  120,  120,  120,  120,  123,  123,  123,
+      306,  123,  123,  123,  123,  123,  125,  306,  125,  125,
+      125,  125,  125,  125,  125,  129,  306,  306,  306,  306,
+      306,  129,   72,   72,  306,   72,  182,  306,  182,    9,
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+      306,  306,  306,  306,  306
     } ;
 
-static const flex_int16_t yy_chk[1342] =
+static const flex_int16_t yy_chk[1016] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,   11,   11,   12,   12,
-       25,   32,   25,   28,   28,   33,   38,   35,   49,   32,
-       64,   34,   64,   33,   38,   35,   49,   49,   33,   34,
-       35,   36,   33,   32,   35,   33,  318,   34,   32,   36,
-      268,   34,   37,  201,   34,   37,   39,   34,   33,   37,
-
-       34,   36,   37,   36,   39,   37,   41,   40,   37,   42,
-       39,   43,  134,   36,   41,   40,   54,   42,   39,   43,
-       40,   54,  126,   39,   40,   43,   44,  126,   45,   41,
-       40,   46,   42,   43,   44,   43,   45,   43,   42,   46,
-       43,   45,   59,   59,   46,   47,  133,   46,  132,   48,
-       45,   45,   44,   47,   47,   71,   46,   48,   50,  130,
-       46,   47,   72,   71,   46,   70,   50,   73,   47,   74,
-       75,   48,   65,   48,   50,   73,   76,   74,   75,   73,
-       74,   50,   77,  127,   76,   75,   78,   80,  127,   82,
-       77,   76,   79,   63,   78,   80,   74,   82,   76,   81,
-
-       79,   79,   82,   83,   84,   77,   85,   81,   58,   86,
-       80,   83,   84,   56,   85,   84,   80,   86,   87,   30,
-       81,   81,   26,   24,   84,   23,   87,   88,   81,   83,
-       87,   84,   89,   85,   90,   88,   86,   91,   92,   94,
-       89,   95,   90,   93,   88,   91,   92,   94,   96,   95,
-       97,   93,    9,   95,   98,    8,   96,   90,   97,   99,
-       89,   92,   98,   91,    7,   93,  100,   99,   95,   95,
-       99,  101,   97,   98,  100,  102,  103,  104,  100,  101,
-      105,  107,   99,  102,  103,  104,  106,    6,  105,  107,
-        5,    4,  109,  105,  106,  102,  108,  111,  106,  101,
-
-      109,  109,  110,  112,  108,  111,    3,  116,    0,  107,
-      110,  112,    0,  108,  110,  116,  109,  111,  113,  108,
-      109,  114,  115,  112,    0,  117,  113,  113,  111,  114,
-      115,  112,  115,  117,  116,  117,  118,  119,  120,  121,
-      122,  114,    0,  115,  118,  119,  120,  121,  122,  118,
-      123,  121,    0,  124,  136,  120,  137,    0,  123,    0,
-      122,  124,  136,  123,  137,  120,  139,  123,  138,  140,
-      143,    0,  119,    0,  139,    0,  138,  140,  143,  124,
-      141,  138,  142,  139,    0,    0,  140,  144,  141,  141,
-      142,  145,  142,  142,  147,  144,  143,    0,  146,  145,
-
-      150,  148,  147,  149,    0,  147,  146,  152,  150,  148,
-        0,  149,  149,  151,  144,  152,  154,  153,  145,  146,
-      152,  151,  146,  148,  154,  153,  150,  150,  153,  155,
-      156,  157,  158,  151,    0,    0,    0,  155,  156,  157,
-      158,  159,  155,  158,  154,  160,  155,  161,  163,  159,
-      159,    0,  162,  160,  164,  161,  163,  165,  166,  157,
-      162,  163,  164,  162,  167,  165,  166,  164,  161,    0,
-      165,  168,  167,  166,    0,  169,  170,  167,  171,  168,
-      165,    0,  164,  169,  170,  172,  171,  173,  174,  170,
-      168,    0,  171,  172,  175,  173,  174,    0,  176,  169,
-
-      177,  174,  175,    0,  178,  172,  176,  179,  177,  173,
-      180,  177,  178,  181,  182,  179,  178,  183,  180,    0,
-      176,  181,  182,  184,  185,  183,    0,  179,    0,  186,
-      187,  184,  185,  188,  182,  189,  184,  186,  187,  180,
-        0,  188,  190,  189,    0,  191,    0,    0,  181,  192,
-      190,  193,  183,  191,  190,  186,  194,  192,  195,  193,
-      188,  193,  193,    0,  194,  191,  195,    0,  196,    0,
-      197,  192,  198,  193,  199,  195,  196,  196,  197,  203,
-      198,  194,  199,  200,  204,  205,    0,  203,  206,  207,
-        0,  200,  204,  205,  199,  209,  206,  207,  198,  197,
-
-      208,  211,  200,  209,  210,  203,  204,  205,  208,  211,
-      212,    0,  210,  213,  206,  214,    0,  210,  212,  208,
-      215,  213,  213,  214,  214,  216,  217,  212,  215,  211,
-      220,    0,  218,  216,  217,  219,    0,  221,  220,  217,
-      218,  223,  222,  219,  219,  221,  224,    0,  215,  223,
-      222,    0,    0,  216,  224,  218,  225,  226,  220,  222,
-      224,  227,  228,  229,  225,  226,  230,  231,  232,  227,
-      228,  229,  233,  226,  230,  231,  232,  234,  235,    0,
-      233,    0,  236,    0,  237,  234,  235,  233,  238,  227,
-      236,  229,  237,  231,  232,  239,  238,  240,  230,  241,
-
-      242,  243,  244,  239,  245,  240,  235,  241,  242,  243,
-      244,  246,  245,  247,  251,  248,  249,  245,  250,  246,
-      240,  247,  251,  248,  249,  252,  250,  243,  250,  253,
-      244,  254,    0,  252,    0,    0,  252,  253,  251,  254,
-      247,  248,  253,  249,  255,    0,  257,  256,  258,  260,
-      259,    0,  255,  255,  257,  256,  258,  260,  259,  254,
-      256,  261,  262,  263,  267,  258,  259,  264,  265,  261,
-      262,  263,  267,    0,  266,  264,  265,  262,  260,    0,
-      264,  265,  266,    0,  269,  270,  271,  266,  272,  273,
-      261,  263,  269,  270,  271,  274,  272,  273,  275,  276,
-
-      278,  279,  277,  274,    0,    0,  275,  276,  278,  279,
-      277,  275,  269,  277,  271,  281,    0,  280,  282,    0,
-        0,  272,    0,  281,  273,  280,  282,  276,  278,    0,
-      280,  283,  284,  285,  286,  287,    0,  281,  288,  283,
-      284,  285,  286,  287,  282,  284,  288,    0,  289,    0,
-      290,  291,  292,  293,  294,  285,  289,  283,  290,  291,
-      292,  293,  294,  295,  296,  289,  293,  297,  298,  299,
-      294,  295,  296,    0,  300,  297,  298,  299,  301,  291,
-      298,  297,  300,  303,    0,  302,  301,  304,    0,    0,
-      305,  303,  295,  302,  302,  304,  300,  299,  305,  306,
-
-      307,    0,  308,  311,  309,  310,  301,  306,  307,  303,
-      308,  311,  309,  310,  310,  304,    0,    0,    0,  312,
-        0,  313,  314,  315,  311,  306,  309,  312,  307,  313,
-      314,  315,  312,  316,  317,  314,  319,  320,  321,  322,
-        0,  316,  317,  313,  319,  320,  321,  322,  323,  324,
-      315,  325,  326,  327,  328,  329,  323,  324,    0,  325,
-      326,  327,  328,  329,  330,    0,  322,  331,  333,    0,
-      332,    0,  330,  321,  323,  331,  333,  330,  332,  325,
-      334,  332,  328,    0,  335,  336,  337,  338,  334,  339,
-      340,  333,  335,  336,  337,  338,  341,  339,  340,  342,
-
-        0,  343,    0,  344,  341,  345,  346,  342,  337,  343,
-      335,  344,  343,  345,  346,  347,  340,    0,  339,  349,
-      344,  348,    0,  347,  350,  342,    0,  349,  347,  348,
-      348,  351,  350,  352,  350,  353,  354,    0,    0,  351,
-      355,  352,  356,  353,  354,  349,  352,  357,  355,  358,
-      356,    0,    0,  359,  360,  357,  361,  358,  362,  356,
-      357,  359,  360,  363,  361,  364,  362,  365,  355,    0,
-      366,  363,    0,  364,  367,  365,    0,  364,  366,  368,
-      362,  369,  367,  370,  361,    0,  371,  368,  372,  369,
-        0,  370,  373,  365,  371,    0,  372,    0,  368,  374,
-
-      373,  375,  376,  369,    0,  373,  377,  374,  378,  375,
-      376,  374,  371,  379,  377,  380,  378,  381,  377,  382,
-      383,  379,    0,  380,  375,  381,  384,  382,  383,  385,
-      381,  386,  387,  388,  384,  389,  376,  385,    0,  386,
-      387,  388,  390,  389,  391,  392,  388,    0,  383,  393,
-      390,    0,  391,  392,  394,  385,  395,  393,  391,  384,
-      396,  397,  394,  398,  395,  399,  400,  387,  396,  397,
-      401,  398,  402,  399,  400,  399,  394,    0,  401,  400,
-      402,    0,    0,    0,  398,    0,    0,    0,    0,    0,
-      397,    0,    0,    0,    0,    0,  401,  404,  404,  404,
-
-      404,  404,  404,  404,  404,  404,  405,  405,  405,  405,
-      405,  405,  405,  405,  405,  406,  406,  406,  406,  406,
-      406,  406,  406,  406,  407,    0,  407,  408,  408,  408,
-      409,  409,    0,  409,  410,  410,  410,  410,    0,  410,
-      410,  410,  410,  411,  411,  411,  411,  411,  411,  411,
-      411,  411,  412,  412,  412,    0,  412,  412,  412,  412,
-      412,  413,    0,  413,  413,  413,  413,  413,  413,  413,
-      414,    0,    0,    0,    0,    0,  414,  415,  415,    0,
-      415,  416,    0,  416,  403,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
-
-      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
-      403
+        1,    1,    1,    1,    1,   11,   11,   12,   12,   25,
+       32,   25,   28,   28,   33,   38,   35,   64,   32,   64,
+       34,   54,   33,   38,   35,   44,   54,   33,   34,   35,
+       36,   33,   32,   44,   39,  266,   34,   32,   36,  120,
+       34,  231,   39,   34,  120,   37,   34,   33,   39,   34,
+
+       36,   44,   36,   37,  181,   41,   39,   42,   37,   40,
+      128,   39,   36,   41,  127,   42,  126,   40,   37,   43,
+      121,   37,   40,  124,   37,  121,   40,   43,   41,   45,
+       42,   46,   40,   43,   59,   59,   42,   45,   72,   46,
+       71,   43,   45,   43,   46,   43,   47,   46,   71,   48,
+       49,   70,   45,   73,   47,   47,   46,   48,   49,   49,
+       46,   73,   47,   65,   50,   73,   74,   75,   76,   47,
+       77,   48,   50,   48,   74,   75,   76,   74,   77,   63,
+       50,   78,   75,   76,   79,   81,   82,   50,   80,   78,
+       78,   83,   79,   81,   82,   84,   80,   86,   81,   83,
+
+       58,   56,   83,   84,   30,   86,   26,   79,   85,   80,
+       80,   83,   82,   79,   86,   87,   85,   80,   83,   88,
+       85,   89,   84,   87,   90,   91,   92,   88,   93,   89,
+       24,   23,   90,   91,   92,    9,   93,    8,   92,   94,
+       95,   96,    7,   87,   89,   88,   90,   94,   95,   96,
+       97,    6,   96,   92,   92,   98,    5,   99,   97,   95,
+      100,   94,   97,   98,   96,   99,  101,  102,  100,    4,
+      103,  104,    3,  105,  101,  102,  106,   99,  103,  104,
+      102,  105,  103,   98,  106,  107,    0,  109,    0,  108,
+        0,  113,  110,  107,  104,  109,  106,  108,  108,  113,
+
+      110,  105,  110,  112,  111,  107,    0,  109,    0,  114,
+      115,  112,  111,  107,  111,  116,  112,  114,  115,  117,
+      118,  130,  115,  116,    0,  113,  114,  117,  118,  130,
+      131,  132,  117,  133,  134,  116,  117,  135,  131,  132,
+        0,  133,  134,  136,  137,  135,  118,  138,  132,  139,
+      133,  136,  137,  140,    0,  138,    0,  139,  138,  141,
+      134,  140,  140,    0,  135,  137,  143,  141,  142,  144,
+      136,  139,    0,    0,  143,  146,  142,  144,    0,  143,
+      144,  145,  147,  146,  148,  141,  141,    0,  142,  145,
+      147,  149,  148,  150,  145,  148,  151,  154,  145,  149,
+
+      152,  150,    0,  153,  151,  154,    0,  151,  152,  155,
+      147,  153,    0,  152,  150,  156,  153,  155,  157,  158,
+      154,  159,  160,  156,  155,  161,  157,  158,  156,  159,
+      160,  153,  162,  161,  159,    0,  160,  157,  163,  164,
+      162,  165,    0,  158,  166,  161,  163,  164,  167,  165,
+      164,  163,  166,    0,  162,  168,  167,  169,  170,  171,
+      172,  167,    0,  168,  166,  169,  170,  171,  172,  173,
+      165,  174,    0,    0,  175,    0,  176,  173,    0,  174,
+      172,  174,  175,  169,  176,  176,  171,  177,  178,  179,
+      183,  173,  180,  184,  185,  177,  178,  179,  183,  175,
+
+      180,  184,  185,    0,    0,  186,    0,    0,    0,  179,
+        0,  180,  183,  186,  178,  184,  177,  187,  186,  188,
+      189,    0,  190,  191,  192,  187,  193,  188,  189,  189,
+      190,  191,  192,  194,  193,  195,  188,  192,  196,  197,
+      198,  194,  194,  195,  199,  187,  196,  197,  198,  193,
+      190,  191,  199,  200,  198,    0,  201,  202,  203,  206,
+      204,  200,  205,  195,  201,  202,  203,  206,  204,  200,
+      205,  207,  208,  209,  210,  211,    0,    0,    0,  207,
+      208,  209,  210,  211,  212,  202,  204,  213,  205,  214,
+      203,    0,  212,  215,  217,  213,  216,  214,  218,  207,
+
+        0,  215,  217,  219,  216,  220,  218,  212,  218,  216,
+        0,  219,    0,  220,  219,  221,  222,  223,  220,  215,
+      217,    0,  224,  221,  222,  223,  225,  227,  226,  222,
+      224,    0,    0,  228,  225,  227,  226,  229,    0,  224,
+      227,  228,    0,  221,  230,  229,  228,    0,    0,  232,
+      229,  233,  230,  234,  235,  225,  226,  232,  236,  233,
+      237,  234,  235,  238,  239,  240,  236,  235,  237,    0,
+      241,  238,  239,  240,  242,  244,  243,  239,  241,  233,
+        0,    0,  242,  244,  243,  245,  236,  240,  237,  243,
+      246,  247,    0,  245,  248,  249,  241,  250,  246,  247,
+
+      242,  251,  248,  249,  252,  250,  253,  246,  255,  251,
+        0,  254,  252,  250,  253,  256,  255,  255,  253,  254,
+      257,  258,  248,  256,  259,    0,  260,  261,  257,  258,
+      251,  262,  259,  254,  260,  261,    0,  263,  264,  262,
+      261,  265,  267,  256,  262,  263,  264,  258,  260,  265,
+      267,  268,  269,  270,  271,  272,    0,  273,  274,  268,
+      269,  270,  271,  272,  263,  273,  274,  275,  276,    0,
+      277,  274,  278,  279,  280,  275,  276,  268,  277,  281,
+      278,  279,  280,  272,  283,  282,  284,  281,    0,  285,
+        0,  276,  283,  282,  284,  279,  282,  285,  285,  286,
+
+      287,  288,  289,  280,  290,  291,  292,  286,  287,  288,
+      289,  293,  290,  291,  292,  289,  294,  295,  296,  293,
+        0,  297,  298,  293,  294,  295,  296,  299,  292,  297,
+      298,  301,  300,  297,    0,  299,  295,    0,  302,  301,
+      300,  303,  294,  304,  296,  300,  302,  305,    0,  303,
+        0,  304,    0,    0,    0,  305,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,  302,  307,  307,  307,  307,  307,  307,  307,  307,
+      307,  308,  308,  308,  308,  308,  308,  308,  308,  308,
+      309,  309,  309,  309,  309,  309,  309,  309,  309,  310,
+
+        0,  310,  311,  311,  311,  312,  312,    0,  312,  313,
+      313,  313,  313,    0,  313,  313,  313,  313,  314,  314,
+      314,  314,  314,  314,  314,  314,  314,  315,  315,  315,
+        0,  315,  315,  315,  315,  315,  316,    0,  316,  316,
+      316,  316,  316,  316,  316,  317,    0,    0,    0,    0,
+        0,  317,  318,  318,    0,  318,  319,    0,  319,  306,
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+
+      306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
+      306,  306,  306,  306,  306
     } ;
 
 static yy_state_type yy_last_accepting_state;
@@ -961,9 +856,9 @@ string_append(
 	stringbuf_len += len;
 }
 
-#line 964 "lexyy.cc"
+#line 859 "lexyy.cc"
 
-#line 966 "lexyy.cc"
+#line 861 "lexyy.cc"
 
 #define INITIAL 0
 #define comment 1
@@ -1184,7 +1079,7 @@ YY_DECL
 #line 112 "pars0lex.l"
 
 
-#line 1187 "lexyy.cc"
+#line 1082 "lexyy.cc"
 
 	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
 		{
@@ -1211,13 +1106,13 @@ yy_match:
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 404 )
+				if ( yy_current_state >= 307 )
 					yy_c = yy_meta[yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
 			++yy_cp;
 			}
-		while ( yy_current_state != 403 );
+		while ( yy_current_state != 306 );
 		yy_cp = (yy_last_accepting_cpos);
 		yy_current_state = (yy_last_accepting_state);
 
@@ -1436,554 +1331,407 @@ case 18:
 YY_RULE_SETUP
 #line 252 "pars0lex.l"
 {
-			return(PARS_OUT_TOKEN);
+			return(PARS_INT_TOKEN);
 }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
 #line 256 "pars0lex.l"
 {
-			return(PARS_BINARY_TOKEN);
+			return(PARS_CHAR_TOKEN);
 }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
 #line 260 "pars0lex.l"
 {
-			return(PARS_BLOB_TOKEN);
+			return(PARS_IS_TOKEN);
 }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
 #line 264 "pars0lex.l"
 {
-			return(PARS_INT_TOKEN);
+			return(PARS_BEGIN_TOKEN);
 }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
 #line 268 "pars0lex.l"
 {
-			return(PARS_INT_TOKEN);
+			return(PARS_END_TOKEN);
 }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
 #line 272 "pars0lex.l"
 {
-			return(PARS_FLOAT_TOKEN);
+			return(PARS_IF_TOKEN);
 }
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
 #line 276 "pars0lex.l"
 {
-			return(PARS_CHAR_TOKEN);
+			return(PARS_THEN_TOKEN);
 }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
 #line 280 "pars0lex.l"
 {
-			return(PARS_IS_TOKEN);
+			return(PARS_ELSE_TOKEN);
 }
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
 #line 284 "pars0lex.l"
 {
-			return(PARS_BEGIN_TOKEN);
+			return(PARS_ELSIF_TOKEN);
 }
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
 #line 288 "pars0lex.l"
 {
-			return(PARS_END_TOKEN);
+			return(PARS_LOOP_TOKEN);
 }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
 #line 292 "pars0lex.l"
 {
-			return(PARS_IF_TOKEN);
+			return(PARS_WHILE_TOKEN);
 }
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
 #line 296 "pars0lex.l"
 {
-			return(PARS_THEN_TOKEN);
+			return(PARS_RETURN_TOKEN);
 }
 	YY_BREAK
 case 30:
 YY_RULE_SETUP
 #line 300 "pars0lex.l"
 {
-			return(PARS_ELSE_TOKEN);
+			return(PARS_SELECT_TOKEN);
 }
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
 #line 304 "pars0lex.l"
 {
-			return(PARS_ELSIF_TOKEN);
+			return(PARS_COUNT_TOKEN);
 }
 	YY_BREAK
 case 32:
 YY_RULE_SETUP
 #line 308 "pars0lex.l"
 {
-			return(PARS_LOOP_TOKEN);
+			return(PARS_FROM_TOKEN);
 }
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
 #line 312 "pars0lex.l"
 {
-			return(PARS_WHILE_TOKEN);
+			return(PARS_WHERE_TOKEN);
 }
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
 #line 316 "pars0lex.l"
 {
-			return(PARS_RETURN_TOKEN);
+			return(PARS_FOR_TOKEN);
 }
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
 #line 320 "pars0lex.l"
 {
-			return(PARS_SELECT_TOKEN);
+			return(PARS_ORDER_TOKEN);
 }
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
 #line 324 "pars0lex.l"
 {
-			return(PARS_SUM_TOKEN);
+			return(PARS_BY_TOKEN);
 }
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
 #line 328 "pars0lex.l"
 {
-			return(PARS_COUNT_TOKEN);
+			return(PARS_ASC_TOKEN);
 }
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
 #line 332 "pars0lex.l"
 {
-			return(PARS_DISTINCT_TOKEN);
+			return(PARS_DESC_TOKEN);
 }
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
 #line 336 "pars0lex.l"
 {
-			return(PARS_FROM_TOKEN);
+			return(PARS_INSERT_TOKEN);
 }
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
 #line 340 "pars0lex.l"
 {
-			return(PARS_WHERE_TOKEN);
+			return(PARS_INTO_TOKEN);
 }
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
 #line 344 "pars0lex.l"
 {
-			return(PARS_FOR_TOKEN);
+			return(PARS_VALUES_TOKEN);
 }
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
 #line 348 "pars0lex.l"
 {
-			return(PARS_READ_TOKEN);
+			return(PARS_UPDATE_TOKEN);
 }
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
 #line 352 "pars0lex.l"
 {
-			return(PARS_ORDER_TOKEN);
+			return(PARS_SET_TOKEN);
 }
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
 #line 356 "pars0lex.l"
 {
-			return(PARS_BY_TOKEN);
+			return(PARS_DELETE_TOKEN);
 }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
 #line 360 "pars0lex.l"
 {
-			return(PARS_ASC_TOKEN);
+			return(PARS_CURRENT_TOKEN);
 }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
 #line 364 "pars0lex.l"
 {
-			return(PARS_DESC_TOKEN);
+			return(PARS_OF_TOKEN);
 }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
 #line 368 "pars0lex.l"
 {
-			return(PARS_INSERT_TOKEN);
+			return(PARS_CREATE_TOKEN);
 }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
 #line 372 "pars0lex.l"
 {
-			return(PARS_INTO_TOKEN);
+			return(PARS_TABLE_TOKEN);
 }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
 #line 376 "pars0lex.l"
 {
-			return(PARS_VALUES_TOKEN);
+			return(PARS_INDEX_TOKEN);
 }
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
 #line 380 "pars0lex.l"
 {
-			return(PARS_UPDATE_TOKEN);
+			return(PARS_UNIQUE_TOKEN);
 }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
 #line 384 "pars0lex.l"
 {
-			return(PARS_SET_TOKEN);
+			return(PARS_CLUSTERED_TOKEN);
 }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
 #line 388 "pars0lex.l"
 {
-			return(PARS_DELETE_TOKEN);
+			return(PARS_ON_TOKEN);
 }
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
 #line 392 "pars0lex.l"
 {
-			return(PARS_CURRENT_TOKEN);
+			return(PARS_DECLARE_TOKEN);
 }
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
 #line 396 "pars0lex.l"
 {
-			return(PARS_OF_TOKEN);
+			return(PARS_CURSOR_TOKEN);
 }
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
 #line 400 "pars0lex.l"
 {
-			return(PARS_CREATE_TOKEN);
+			return(PARS_OPEN_TOKEN);
 }
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
 #line 404 "pars0lex.l"
 {
-			return(PARS_TABLE_TOKEN);
+			return(PARS_FETCH_TOKEN);
 }
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
 #line 408 "pars0lex.l"
 {
-			return(PARS_COMPACT_TOKEN);
+			return(PARS_CLOSE_TOKEN);
 }
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
 #line 412 "pars0lex.l"
 {
-			return(PARS_BLOCK_SIZE_TOKEN);
+			return(PARS_NOTFOUND_TOKEN);
 }
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
 #line 416 "pars0lex.l"
 {
-			return(PARS_INDEX_TOKEN);
+			return(PARS_TO_BINARY_TOKEN);
 }
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
 #line 420 "pars0lex.l"
 {
-			return(PARS_UNIQUE_TOKEN);
+			return(PARS_SUBSTR_TOKEN);
 }
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
 #line 424 "pars0lex.l"
 {
-			return(PARS_CLUSTERED_TOKEN);
+			return(PARS_CONCAT_TOKEN);
 }
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
 #line 428 "pars0lex.l"
 {
-			return(PARS_ON_TOKEN);
+			return(PARS_INSTR_TOKEN);
 }
 	YY_BREAK
 case 63:
 YY_RULE_SETUP
 #line 432 "pars0lex.l"
 {
-			return(PARS_DECLARE_TOKEN);
+			return(PARS_LENGTH_TOKEN);
 }
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
 #line 436 "pars0lex.l"
 {
-			return(PARS_CURSOR_TOKEN);
+			return(PARS_COMMIT_TOKEN);
 }
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
 #line 440 "pars0lex.l"
 {
-			return(PARS_OPEN_TOKEN);
+			return(PARS_ROLLBACK_TOKEN);
 }
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
 #line 444 "pars0lex.l"
 {
-			return(PARS_FETCH_TOKEN);
+			return(PARS_WORK_TOKEN);
 }
 	YY_BREAK
 case 67:
 YY_RULE_SETUP
 #line 448 "pars0lex.l"
 {
-			return(PARS_CLOSE_TOKEN);
+			return(PARS_EXIT_TOKEN);
 }
 	YY_BREAK
 case 68:
 YY_RULE_SETUP
 #line 452 "pars0lex.l"
 {
-			return(PARS_NOTFOUND_TOKEN);
+			return(PARS_FUNCTION_TOKEN);
 }
 	YY_BREAK
 case 69:
 YY_RULE_SETUP
 #line 456 "pars0lex.l"
 {
-			return(PARS_TO_CHAR_TOKEN);
+			return(PARS_LOCK_TOKEN);
 }
 	YY_BREAK
 case 70:
 YY_RULE_SETUP
 #line 460 "pars0lex.l"
 {
-			return(PARS_TO_NUMBER_TOKEN);
+			return(PARS_SHARE_TOKEN);
 }
 	YY_BREAK
 case 71:
 YY_RULE_SETUP
 #line 464 "pars0lex.l"
 {
-			return(PARS_TO_BINARY_TOKEN);
+			return(PARS_MODE_TOKEN);
 }
 	YY_BREAK
 case 72:
 YY_RULE_SETUP
 #line 468 "pars0lex.l"
 {
-			return(PARS_BINARY_TO_NUMBER_TOKEN);
+                        return(PARS_LIKE_TOKEN);
 }
 	YY_BREAK
 case 73:
 YY_RULE_SETUP
 #line 472 "pars0lex.l"
 {
-			return(PARS_SUBSTR_TOKEN);
+			return(PARS_BIGINT_TOKEN);
 }
 	YY_BREAK
 case 74:
 YY_RULE_SETUP
 #line 476 "pars0lex.l"
 {
-			return(PARS_REPLSTR_TOKEN);
-}
-	YY_BREAK
-case 75:
-YY_RULE_SETUP
-#line 480 "pars0lex.l"
-{
-			return(PARS_CONCAT_TOKEN);
-}
-	YY_BREAK
-case 76:
-YY_RULE_SETUP
-#line 484 "pars0lex.l"
-{
-			return(PARS_INSTR_TOKEN);
-}
-	YY_BREAK
-case 77:
-YY_RULE_SETUP
-#line 488 "pars0lex.l"
-{
-			return(PARS_LENGTH_TOKEN);
-}
-	YY_BREAK
-case 78:
-YY_RULE_SETUP
-#line 492 "pars0lex.l"
-{
-			return(PARS_SYSDATE_TOKEN);
-}
-	YY_BREAK
-case 79:
-YY_RULE_SETUP
-#line 496 "pars0lex.l"
-{
-			return(PARS_PRINTF_TOKEN);
-}
-	YY_BREAK
-case 80:
-YY_RULE_SETUP
-#line 500 "pars0lex.l"
-{
-			return(PARS_ASSERT_TOKEN);
-}
-	YY_BREAK
-case 81:
-YY_RULE_SETUP
-#line 504 "pars0lex.l"
-{
-			return(PARS_RND_TOKEN);
-}
-	YY_BREAK
-case 82:
-YY_RULE_SETUP
-#line 508 "pars0lex.l"
-{
-			return(PARS_RND_STR_TOKEN);
-}
-	YY_BREAK
-case 83:
-YY_RULE_SETUP
-#line 512 "pars0lex.l"
-{
-			return(PARS_ROW_PRINTF_TOKEN);
-}
-	YY_BREAK
-case 84:
-YY_RULE_SETUP
-#line 516 "pars0lex.l"
-{
-			return(PARS_COMMIT_TOKEN);
-}
-	YY_BREAK
-case 85:
-YY_RULE_SETUP
-#line 520 "pars0lex.l"
-{
-			return(PARS_ROLLBACK_TOKEN);
-}
-	YY_BREAK
-case 86:
-YY_RULE_SETUP
-#line 524 "pars0lex.l"
-{
-			return(PARS_WORK_TOKEN);
-}
-	YY_BREAK
-case 87:
-YY_RULE_SETUP
-#line 528 "pars0lex.l"
-{
-			return(PARS_UNSIGNED_TOKEN);
-}
-	YY_BREAK
-case 88:
-YY_RULE_SETUP
-#line 532 "pars0lex.l"
-{
-			return(PARS_EXIT_TOKEN);
-}
-	YY_BREAK
-case 89:
-YY_RULE_SETUP
-#line 536 "pars0lex.l"
-{
-			return(PARS_FUNCTION_TOKEN);
-}
-	YY_BREAK
-case 90:
-YY_RULE_SETUP
-#line 540 "pars0lex.l"
-{
-			return(PARS_LOCK_TOKEN);
-}
-	YY_BREAK
-case 91:
-YY_RULE_SETUP
-#line 544 "pars0lex.l"
-{
-			return(PARS_SHARE_TOKEN);
-}
-	YY_BREAK
-case 92:
-YY_RULE_SETUP
-#line 548 "pars0lex.l"
-{
-			return(PARS_MODE_TOKEN);
-}
-	YY_BREAK
-case 93:
-YY_RULE_SETUP
-#line 552 "pars0lex.l"
-{
-                        return(PARS_LIKE_TOKEN);
-}
-	YY_BREAK
-case 94:
-YY_RULE_SETUP
-#line 556 "pars0lex.l"
-{
-			return(PARS_BIGINT_TOKEN);
-}
-	YY_BREAK
-case 95:
-YY_RULE_SETUP
-#line 560 "pars0lex.l"
-{
 			yylval = sym_tab_add_id(pars_sym_tab_global,
 							(byte*) yytext,
 							ut_strlen(yytext));
 			return(PARS_ID_TOKEN);
 }
 	YY_BREAK
-case 96:
+case 75:
 YY_RULE_SETUP
-#line 567 "pars0lex.l"
+#line 483 "pars0lex.l"
 {
 			yylval = sym_tab_add_id(pars_sym_tab_global,
 							(byte*) yytext,
@@ -1991,192 +1739,192 @@ YY_RULE_SETUP
 			return(PARS_TABLE_NAME_TOKEN);
 }
 	YY_BREAK
-case 97:
+case 76:
 YY_RULE_SETUP
-#line 574 "pars0lex.l"
+#line 490 "pars0lex.l"
 {
 			return(PARS_DDOT_TOKEN);
 }
 	YY_BREAK
-case 98:
+case 77:
 YY_RULE_SETUP
-#line 578 "pars0lex.l"
+#line 494 "pars0lex.l"
 {
 			return(PARS_ASSIGN_TOKEN);
 }
 	YY_BREAK
-case 99:
+case 78:
 YY_RULE_SETUP
-#line 582 "pars0lex.l"
+#line 498 "pars0lex.l"
 {
 			return(PARS_LE_TOKEN);
 }
 	YY_BREAK
-case 100:
+case 79:
 YY_RULE_SETUP
-#line 586 "pars0lex.l"
+#line 502 "pars0lex.l"
 {
 			return(PARS_GE_TOKEN);
 }
 	YY_BREAK
-case 101:
+case 80:
 YY_RULE_SETUP
-#line 590 "pars0lex.l"
+#line 506 "pars0lex.l"
 {
 			return(PARS_NE_TOKEN);
 }
 	YY_BREAK
-case 102:
+case 81:
 YY_RULE_SETUP
-#line 594 "pars0lex.l"
+#line 510 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 103:
+case 82:
 YY_RULE_SETUP
-#line 599 "pars0lex.l"
+#line 515 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 104:
+case 83:
 YY_RULE_SETUP
-#line 604 "pars0lex.l"
+#line 520 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 105:
+case 84:
 YY_RULE_SETUP
-#line 609 "pars0lex.l"
+#line 525 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 106:
+case 85:
 YY_RULE_SETUP
-#line 614 "pars0lex.l"
+#line 530 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 107:
+case 86:
 YY_RULE_SETUP
-#line 619 "pars0lex.l"
+#line 535 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 108:
+case 87:
 YY_RULE_SETUP
-#line 624 "pars0lex.l"
+#line 540 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 109:
+case 88:
 YY_RULE_SETUP
-#line 629 "pars0lex.l"
+#line 545 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 110:
+case 89:
 YY_RULE_SETUP
-#line 634 "pars0lex.l"
+#line 550 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 111:
+case 90:
 YY_RULE_SETUP
-#line 639 "pars0lex.l"
+#line 555 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 112:
+case 91:
 YY_RULE_SETUP
-#line 644 "pars0lex.l"
+#line 560 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 113:
+case 92:
 YY_RULE_SETUP
-#line 649 "pars0lex.l"
+#line 565 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 114:
+case 93:
 YY_RULE_SETUP
-#line 654 "pars0lex.l"
+#line 570 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 115:
+case 94:
 YY_RULE_SETUP
-#line 659 "pars0lex.l"
+#line 575 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 116:
+case 95:
 YY_RULE_SETUP
-#line 664 "pars0lex.l"
+#line 580 "pars0lex.l"
 {
 
 			return((int)(*yytext));
 }
 	YY_BREAK
-case 117:
+case 96:
 YY_RULE_SETUP
-#line 669 "pars0lex.l"
+#line 585 "pars0lex.l"
 BEGIN(comment); /* eat up comment */
 	YY_BREAK
-case 118:
-/* rule 118 can match eol */
+case 97:
+/* rule 97 can match eol */
 YY_RULE_SETUP
-#line 671 "pars0lex.l"
+#line 587 "pars0lex.l"
 
 	YY_BREAK
-case 119:
-/* rule 119 can match eol */
+case 98:
+/* rule 98 can match eol */
 YY_RULE_SETUP
-#line 672 "pars0lex.l"
+#line 588 "pars0lex.l"
 
 	YY_BREAK
-case 120:
+case 99:
 YY_RULE_SETUP
-#line 673 "pars0lex.l"
+#line 589 "pars0lex.l"
 BEGIN(INITIAL);
 	YY_BREAK
-case 121:
-/* rule 121 can match eol */
+case 100:
+/* rule 100 can match eol */
 YY_RULE_SETUP
-#line 675 "pars0lex.l"
+#line 591 "pars0lex.l"
 /* eat up whitespace */
 	YY_BREAK
-case 122:
+case 101:
 YY_RULE_SETUP
-#line 678 "pars0lex.l"
+#line 594 "pars0lex.l"
 {
 			fprintf(stderr,"Unrecognized character: %02x\n",
 				*yytext);
@@ -2186,12 +1934,12 @@ YY_RULE_SETUP
 			return(0);
 }
 	YY_BREAK
-case 123:
+case 102:
 YY_RULE_SETUP
-#line 687 "pars0lex.l"
+#line 603 "pars0lex.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 2194 "lexyy.cc"
+#line 1942 "lexyy.cc"
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(comment):
 case YY_STATE_EOF(quoted):
@@ -2492,7 +2240,7 @@ static int yy_get_next_buffer (void)
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 404 )
+			if ( yy_current_state >= 307 )
 				yy_c = yy_meta[yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
@@ -2520,11 +2268,11 @@ static int yy_get_next_buffer (void)
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 404 )
+		if ( yy_current_state >= 307 )
 			yy_c = yy_meta[yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-	yy_is_jam = (yy_current_state == 403);
+	yy_is_jam = (yy_current_state == 306);
 
 		return yy_is_jam ? 0 : yy_current_state;
 }
@@ -3077,7 +2825,7 @@ static void yyfree (void * ptr )
 
 #define YYTABLES_NAME "yytables"
 
-#line 687 "pars0lex.l"
+#line 603 "pars0lex.l"
 
 
 /**********************************************************************
diff --git a/storage/innobase/pars/pars0grm.cc b/storage/innobase/pars/pars0grm.cc
index a0a09771106..7e10a783310 100644
--- a/storage/innobase/pars/pars0grm.cc
+++ b/storage/innobase/pars/pars0grm.cc
@@ -1,8 +1,9 @@
-/* A Bison parser, made by GNU Bison 3.0.4.  */
+/* A Bison parser, made by GNU Bison 3.4.2.  */
 
 /* Bison implementation for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
+   Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -40,11 +41,14 @@
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 
+/* Undocumented macros, especially those whose name start with YY_,
+   are private implementation details.  Do not rely on them.  */
+
 /* Identify Bison output.  */
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "3.0.4"
+#define YYBISON_VERSION "3.4.2"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -61,8 +65,8 @@
 
 
 
-/* Copy the first part of user declarations.  */
-#line 29 "pars0grm.y" /* yacc.c:339  */
+/* First part of user prologue.  */
+#line 29 "pars0grm.y"
 
 /* The value of the semantic attribute is a pointer to a query tree node
 que_node_t */
@@ -81,13 +85,17 @@ que_node_t */
 int
 yylex(void);
 
-#line 85 "pars0grm.cc" /* yacc.c:339  */
+#line 89 "pars0grm.cc"
 
 # ifndef YY_NULLPTR
-#  if defined __cplusplus && 201103L <= __cplusplus
-#   define YY_NULLPTR nullptr
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif
 #  else
-#   define YY_NULLPTR 0
+#   define YY_NULLPTR ((void*)0)
 #  endif
 # endif
 
@@ -99,8 +107,8 @@ yylex(void);
 # define YYERROR_VERBOSE 0
 #endif
 
-/* In a future release of Bison, this section will be replaced
-   by #include "pars0grm.tab.h".  */
+/* Use api.header.include to #include this header
+   instead of duplicating it here.  */
 #ifndef YY_YY_PARS0GRM_TAB_H_INCLUDED
 # define YY_YY_PARS0GRM_TAB_H_INCLUDED
 /* Debug traces.  */
@@ -129,91 +137,71 @@ extern int yydebug;
     PARS_NE_TOKEN = 268,
     PARS_PROCEDURE_TOKEN = 269,
     PARS_IN_TOKEN = 270,
-    PARS_OUT_TOKEN = 271,
-    PARS_BINARY_TOKEN = 272,
-    PARS_BLOB_TOKEN = 273,
-    PARS_INT_TOKEN = 274,
-    PARS_FLOAT_TOKEN = 275,
-    PARS_CHAR_TOKEN = 276,
-    PARS_IS_TOKEN = 277,
-    PARS_BEGIN_TOKEN = 278,
-    PARS_END_TOKEN = 279,
-    PARS_IF_TOKEN = 280,
-    PARS_THEN_TOKEN = 281,
-    PARS_ELSE_TOKEN = 282,
-    PARS_ELSIF_TOKEN = 283,
-    PARS_LOOP_TOKEN = 284,
-    PARS_WHILE_TOKEN = 285,
-    PARS_RETURN_TOKEN = 286,
-    PARS_SELECT_TOKEN = 287,
-    PARS_SUM_TOKEN = 288,
-    PARS_COUNT_TOKEN = 289,
-    PARS_DISTINCT_TOKEN = 290,
-    PARS_FROM_TOKEN = 291,
-    PARS_WHERE_TOKEN = 292,
-    PARS_FOR_TOKEN = 293,
-    PARS_DDOT_TOKEN = 294,
-    PARS_READ_TOKEN = 295,
-    PARS_ORDER_TOKEN = 296,
-    PARS_BY_TOKEN = 297,
-    PARS_ASC_TOKEN = 298,
-    PARS_DESC_TOKEN = 299,
-    PARS_INSERT_TOKEN = 300,
-    PARS_INTO_TOKEN = 301,
-    PARS_VALUES_TOKEN = 302,
-    PARS_UPDATE_TOKEN = 303,
-    PARS_SET_TOKEN = 304,
-    PARS_DELETE_TOKEN = 305,
-    PARS_CURRENT_TOKEN = 306,
-    PARS_OF_TOKEN = 307,
-    PARS_CREATE_TOKEN = 308,
-    PARS_TABLE_TOKEN = 309,
-    PARS_INDEX_TOKEN = 310,
-    PARS_UNIQUE_TOKEN = 311,
-    PARS_CLUSTERED_TOKEN = 312,
-    PARS_ON_TOKEN = 313,
-    PARS_ASSIGN_TOKEN = 314,
-    PARS_DECLARE_TOKEN = 315,
-    PARS_CURSOR_TOKEN = 316,
-    PARS_SQL_TOKEN = 317,
-    PARS_OPEN_TOKEN = 318,
-    PARS_FETCH_TOKEN = 319,
-    PARS_CLOSE_TOKEN = 320,
-    PARS_NOTFOUND_TOKEN = 321,
-    PARS_TO_CHAR_TOKEN = 322,
-    PARS_TO_NUMBER_TOKEN = 323,
-    PARS_TO_BINARY_TOKEN = 324,
-    PARS_BINARY_TO_NUMBER_TOKEN = 325,
-    PARS_SUBSTR_TOKEN = 326,
-    PARS_REPLSTR_TOKEN = 327,
-    PARS_CONCAT_TOKEN = 328,
-    PARS_INSTR_TOKEN = 329,
-    PARS_LENGTH_TOKEN = 330,
-    PARS_SYSDATE_TOKEN = 331,
-    PARS_PRINTF_TOKEN = 332,
-    PARS_ASSERT_TOKEN = 333,
-    PARS_RND_TOKEN = 334,
-    PARS_RND_STR_TOKEN = 335,
-    PARS_ROW_PRINTF_TOKEN = 336,
-    PARS_COMMIT_TOKEN = 337,
-    PARS_ROLLBACK_TOKEN = 338,
-    PARS_WORK_TOKEN = 339,
-    PARS_UNSIGNED_TOKEN = 340,
-    PARS_EXIT_TOKEN = 341,
-    PARS_FUNCTION_TOKEN = 342,
-    PARS_LOCK_TOKEN = 343,
-    PARS_SHARE_TOKEN = 344,
-    PARS_MODE_TOKEN = 345,
-    PARS_LIKE_TOKEN = 346,
-    PARS_LIKE_TOKEN_EXACT = 347,
-    PARS_LIKE_TOKEN_PREFIX = 348,
-    PARS_LIKE_TOKEN_SUFFIX = 349,
-    PARS_LIKE_TOKEN_SUBSTR = 350,
-    PARS_TABLE_NAME_TOKEN = 351,
-    PARS_COMPACT_TOKEN = 352,
-    PARS_BLOCK_SIZE_TOKEN = 353,
-    PARS_BIGINT_TOKEN = 354,
-    NEG = 355
+    PARS_INT_TOKEN = 271,
+    PARS_CHAR_TOKEN = 272,
+    PARS_IS_TOKEN = 273,
+    PARS_BEGIN_TOKEN = 274,
+    PARS_END_TOKEN = 275,
+    PARS_IF_TOKEN = 276,
+    PARS_THEN_TOKEN = 277,
+    PARS_ELSE_TOKEN = 278,
+    PARS_ELSIF_TOKEN = 279,
+    PARS_LOOP_TOKEN = 280,
+    PARS_WHILE_TOKEN = 281,
+    PARS_RETURN_TOKEN = 282,
+    PARS_SELECT_TOKEN = 283,
+    PARS_COUNT_TOKEN = 284,
+    PARS_FROM_TOKEN = 285,
+    PARS_WHERE_TOKEN = 286,
+    PARS_FOR_TOKEN = 287,
+    PARS_DDOT_TOKEN = 288,
+    PARS_ORDER_TOKEN = 289,
+    PARS_BY_TOKEN = 290,
+    PARS_ASC_TOKEN = 291,
+    PARS_DESC_TOKEN = 292,
+    PARS_INSERT_TOKEN = 293,
+    PARS_INTO_TOKEN = 294,
+    PARS_VALUES_TOKEN = 295,
+    PARS_UPDATE_TOKEN = 296,
+    PARS_SET_TOKEN = 297,
+    PARS_DELETE_TOKEN = 298,
+    PARS_CURRENT_TOKEN = 299,
+    PARS_OF_TOKEN = 300,
+    PARS_CREATE_TOKEN = 301,
+    PARS_TABLE_TOKEN = 302,
+    PARS_INDEX_TOKEN = 303,
+    PARS_UNIQUE_TOKEN = 304,
+    PARS_CLUSTERED_TOKEN = 305,
+    PARS_ON_TOKEN = 306,
+    PARS_ASSIGN_TOKEN = 307,
+    PARS_DECLARE_TOKEN = 308,
+    PARS_CURSOR_TOKEN = 309,
+    PARS_SQL_TOKEN = 310,
+    PARS_OPEN_TOKEN = 311,
+    PARS_FETCH_TOKEN = 312,
+    PARS_CLOSE_TOKEN = 313,
+    PARS_NOTFOUND_TOKEN = 314,
+    PARS_TO_BINARY_TOKEN = 315,
+    PARS_SUBSTR_TOKEN = 316,
+    PARS_CONCAT_TOKEN = 317,
+    PARS_INSTR_TOKEN = 318,
+    PARS_LENGTH_TOKEN = 319,
+    PARS_COMMIT_TOKEN = 320,
+    PARS_ROLLBACK_TOKEN = 321,
+    PARS_WORK_TOKEN = 322,
+    PARS_EXIT_TOKEN = 323,
+    PARS_FUNCTION_TOKEN = 324,
+    PARS_LOCK_TOKEN = 325,
+    PARS_SHARE_TOKEN = 326,
+    PARS_MODE_TOKEN = 327,
+    PARS_LIKE_TOKEN = 328,
+    PARS_LIKE_TOKEN_EXACT = 329,
+    PARS_LIKE_TOKEN_PREFIX = 330,
+    PARS_LIKE_TOKEN_SUFFIX = 331,
+    PARS_LIKE_TOKEN_SUBSTR = 332,
+    PARS_TABLE_NAME_TOKEN = 333,
+    PARS_BIGINT_TOKEN = 334,
+    NEG = 335
   };
 #endif
 
@@ -231,9 +219,7 @@ int yyparse (void);
 
 #endif /* !YY_YY_PARS0GRM_TAB_H_INCLUDED  */
 
-/* Copy the second part of user declarations.  */
 
-#line 237 "pars0grm.cc" /* yacc.c:358  */
 
 #ifdef short
 # undef short
@@ -254,13 +240,13 @@ typedef signed char yytype_int8;
 #ifdef YYTYPE_UINT16
 typedef YYTYPE_UINT16 yytype_uint16;
 #else
-typedef unsigned short int yytype_uint16;
+typedef unsigned short yytype_uint16;
 #endif
 
 #ifdef YYTYPE_INT16
 typedef YYTYPE_INT16 yytype_int16;
 #else
-typedef short int yytype_int16;
+typedef short yytype_int16;
 #endif
 
 #ifndef YYSIZE_T
@@ -272,7 +258,7 @@ typedef short int yytype_int16;
 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 #  define YYSIZE_T size_t
 # else
-#  define YYSIZE_T unsigned int
+#  define YYSIZE_T unsigned
 # endif
 #endif
 
@@ -308,15 +294,6 @@ typedef short int yytype_int16;
 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
 #endif
 
-#if !defined _Noreturn \
-     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
-# if defined _MSC_VER && 1200 <= _MSC_VER
-#  define _Noreturn __declspec (noreturn)
-# else
-#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
-# endif
-#endif
-
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
 # define YYUSE(E) ((void) (E))
@@ -324,7 +301,7 @@ typedef short int yytype_int16;
 # define YYUSE(E) /* empty */
 #endif
 
-#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
     _Pragma ("GCC diagnostic push") \
@@ -344,6 +321,8 @@ typedef short int yytype_int16;
 #endif
 
 
+#define YY_ASSERT(E) ((void) (0 && (E)))
+
 #if ! defined yyoverflow || YYERROR_VERBOSE
 
 /* The parser invokes alloca or malloc; define the necessary symbols.  */
@@ -475,42 +454,42 @@ union yyalloc
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  5
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   780
+#define YYLAST   603
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  116
+#define YYNTOKENS  96
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  72
+#define YYNNTS  64
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  178
+#define YYNRULES  150
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  345
+#define YYNSTATES  300
 
-/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
-   by yylex, with out-of-bounds checking.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   355
+#define YYMAXUTOK   335
 
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, with out-of-bounds checking.  */
 #define YYTRANSLATE(YYX)                                                \
-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+  ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
-   as returned by yylex, without out-of-bounds checking.  */
+   as returned by yylex.  */
 static const yytype_uint8 yytranslate[] =
 {
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,   108,     2,     2,
-     110,   111,   105,   104,   113,   103,     2,   106,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,   109,
-     101,   100,   102,   112,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,    88,     2,     2,
+      90,    91,    85,    84,    93,    83,     2,    86,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,    89,
+      81,    80,    82,    92,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,   114,     2,   115,     2,     2,     2,     2,
+       2,     2,     2,    94,     2,    95,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -531,33 +510,29 @@ static const yytype_uint8 yytranslate[] =
       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   107
+      75,    76,    77,    78,    79,    87
 };
 
 #if YYDEBUG
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   160,   160,   163,   164,   165,   166,   167,   168,   169,
-     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
-     180,   181,   182,   183,   184,   188,   189,   194,   195,   197,
-     198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
-     208,   209,   211,   212,   213,   214,   215,   216,   217,   218,
-     219,   221,   226,   227,   228,   229,   231,   232,   233,   234,
-     235,   236,   237,   240,   242,   243,   247,   253,   258,   259,
-     260,   264,   268,   269,   274,   275,   276,   281,   282,   283,
-     287,   288,   293,   299,   306,   307,   308,   313,   315,   318,
-     322,   323,   327,   328,   333,   334,   339,   340,   341,   345,
-     346,   353,   368,   373,   376,   384,   390,   391,   396,   402,
-     411,   419,   427,   434,   442,   450,   456,   463,   469,   470,
-     475,   476,   478,   482,   489,   495,   505,   509,   513,   520,
-     527,   531,   539,   548,   549,   554,   555,   560,   561,   567,
-     568,   574,   575,   580,   581,   586,   597,   598,   603,   604,
-     608,   609,   613,   627,   628,   632,   637,   642,   643,   644,
-     645,   646,   650,   655,   663,   664,   665,   670,   676,   678,
-     679,   683,   691,   697,   698,   701,   703,   704,   708
+       0,   140,   140,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   166,   167,   172,   173,   175,   176,   177,
+     178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,   199,
+     204,   205,   206,   207,   208,   211,   213,   214,   218,   224,
+     228,   229,   234,   235,   236,   241,   242,   243,   247,   248,
+     256,   257,   258,   263,   265,   268,   272,   273,   277,   278,
+     283,   284,   289,   290,   291,   295,   296,   303,   318,   323,
+     326,   334,   340,   341,   346,   352,   361,   369,   377,   384,
+     392,   400,   407,   413,   414,   419,   420,   422,   426,   433,
+     439,   449,   453,   457,   464,   471,   475,   483,   492,   493,
+     498,   499,   504,   505,   511,   519,   520,   525,   526,   530,
+     531,   535,   549,   550,   554,   559,   564,   565,   566,   570,
+     576,   578,   579,   583,   591,   597,   598,   601,   603,   604,
+     608
 };
 #endif
 
@@ -570,39 +545,30 @@ static const char *const yytname[] =
   "PARS_STR_LIT", "PARS_NULL_LIT", "PARS_ID_TOKEN", "PARS_AND_TOKEN",
   "PARS_OR_TOKEN", "PARS_NOT_TOKEN", "PARS_GE_TOKEN", "PARS_LE_TOKEN",
   "PARS_NE_TOKEN", "PARS_PROCEDURE_TOKEN", "PARS_IN_TOKEN",
-  "PARS_OUT_TOKEN", "PARS_BINARY_TOKEN", "PARS_BLOB_TOKEN",
-  "PARS_INT_TOKEN", "PARS_FLOAT_TOKEN", "PARS_CHAR_TOKEN", "PARS_IS_TOKEN",
-  "PARS_BEGIN_TOKEN", "PARS_END_TOKEN", "PARS_IF_TOKEN", "PARS_THEN_TOKEN",
-  "PARS_ELSE_TOKEN", "PARS_ELSIF_TOKEN", "PARS_LOOP_TOKEN",
-  "PARS_WHILE_TOKEN", "PARS_RETURN_TOKEN", "PARS_SELECT_TOKEN",
-  "PARS_SUM_TOKEN", "PARS_COUNT_TOKEN", "PARS_DISTINCT_TOKEN",
+  "PARS_INT_TOKEN", "PARS_CHAR_TOKEN", "PARS_IS_TOKEN", "PARS_BEGIN_TOKEN",
+  "PARS_END_TOKEN", "PARS_IF_TOKEN", "PARS_THEN_TOKEN", "PARS_ELSE_TOKEN",
+  "PARS_ELSIF_TOKEN", "PARS_LOOP_TOKEN", "PARS_WHILE_TOKEN",
+  "PARS_RETURN_TOKEN", "PARS_SELECT_TOKEN", "PARS_COUNT_TOKEN",
   "PARS_FROM_TOKEN", "PARS_WHERE_TOKEN", "PARS_FOR_TOKEN",
-  "PARS_DDOT_TOKEN", "PARS_READ_TOKEN", "PARS_ORDER_TOKEN",
-  "PARS_BY_TOKEN", "PARS_ASC_TOKEN", "PARS_DESC_TOKEN",
-  "PARS_INSERT_TOKEN", "PARS_INTO_TOKEN", "PARS_VALUES_TOKEN",
-  "PARS_UPDATE_TOKEN", "PARS_SET_TOKEN", "PARS_DELETE_TOKEN",
-  "PARS_CURRENT_TOKEN", "PARS_OF_TOKEN", "PARS_CREATE_TOKEN",
-  "PARS_TABLE_TOKEN", "PARS_INDEX_TOKEN", "PARS_UNIQUE_TOKEN",
-  "PARS_CLUSTERED_TOKEN", "PARS_ON_TOKEN", "PARS_ASSIGN_TOKEN",
-  "PARS_DECLARE_TOKEN", "PARS_CURSOR_TOKEN", "PARS_SQL_TOKEN",
-  "PARS_OPEN_TOKEN", "PARS_FETCH_TOKEN", "PARS_CLOSE_TOKEN",
-  "PARS_NOTFOUND_TOKEN", "PARS_TO_CHAR_TOKEN", "PARS_TO_NUMBER_TOKEN",
-  "PARS_TO_BINARY_TOKEN", "PARS_BINARY_TO_NUMBER_TOKEN",
-  "PARS_SUBSTR_TOKEN", "PARS_REPLSTR_TOKEN", "PARS_CONCAT_TOKEN",
-  "PARS_INSTR_TOKEN", "PARS_LENGTH_TOKEN", "PARS_SYSDATE_TOKEN",
-  "PARS_PRINTF_TOKEN", "PARS_ASSERT_TOKEN", "PARS_RND_TOKEN",
-  "PARS_RND_STR_TOKEN", "PARS_ROW_PRINTF_TOKEN", "PARS_COMMIT_TOKEN",
-  "PARS_ROLLBACK_TOKEN", "PARS_WORK_TOKEN", "PARS_UNSIGNED_TOKEN",
-  "PARS_EXIT_TOKEN", "PARS_FUNCTION_TOKEN", "PARS_LOCK_TOKEN",
-  "PARS_SHARE_TOKEN", "PARS_MODE_TOKEN", "PARS_LIKE_TOKEN",
-  "PARS_LIKE_TOKEN_EXACT", "PARS_LIKE_TOKEN_PREFIX",
+  "PARS_DDOT_TOKEN", "PARS_ORDER_TOKEN", "PARS_BY_TOKEN", "PARS_ASC_TOKEN",
+  "PARS_DESC_TOKEN", "PARS_INSERT_TOKEN", "PARS_INTO_TOKEN",
+  "PARS_VALUES_TOKEN", "PARS_UPDATE_TOKEN", "PARS_SET_TOKEN",
+  "PARS_DELETE_TOKEN", "PARS_CURRENT_TOKEN", "PARS_OF_TOKEN",
+  "PARS_CREATE_TOKEN", "PARS_TABLE_TOKEN", "PARS_INDEX_TOKEN",
+  "PARS_UNIQUE_TOKEN", "PARS_CLUSTERED_TOKEN", "PARS_ON_TOKEN",
+  "PARS_ASSIGN_TOKEN", "PARS_DECLARE_TOKEN", "PARS_CURSOR_TOKEN",
+  "PARS_SQL_TOKEN", "PARS_OPEN_TOKEN", "PARS_FETCH_TOKEN",
+  "PARS_CLOSE_TOKEN", "PARS_NOTFOUND_TOKEN", "PARS_TO_BINARY_TOKEN",
+  "PARS_SUBSTR_TOKEN", "PARS_CONCAT_TOKEN", "PARS_INSTR_TOKEN",
+  "PARS_LENGTH_TOKEN", "PARS_COMMIT_TOKEN", "PARS_ROLLBACK_TOKEN",
+  "PARS_WORK_TOKEN", "PARS_EXIT_TOKEN", "PARS_FUNCTION_TOKEN",
+  "PARS_LOCK_TOKEN", "PARS_SHARE_TOKEN", "PARS_MODE_TOKEN",
+  "PARS_LIKE_TOKEN", "PARS_LIKE_TOKEN_EXACT", "PARS_LIKE_TOKEN_PREFIX",
   "PARS_LIKE_TOKEN_SUFFIX", "PARS_LIKE_TOKEN_SUBSTR",
-  "PARS_TABLE_NAME_TOKEN", "PARS_COMPACT_TOKEN", "PARS_BLOCK_SIZE_TOKEN",
-  "PARS_BIGINT_TOKEN", "'='", "'<'", "'>'", "'-'", "'+'", "'*'", "'/'",
-  "NEG", "'%'", "';'", "'('", "')'", "'?'", "','", "'{'", "'}'", "$accept",
-  "top_statement", "statement", "statement_list", "exp", "function_name",
-  "question_mark_list", "stored_procedure_call",
-  "predefined_procedure_call", "predefined_procedure_name",
+  "PARS_TABLE_NAME_TOKEN", "PARS_BIGINT_TOKEN", "'='", "'<'", "'>'", "'-'",
+  "'+'", "'*'", "'/'", "NEG", "'%'", "';'", "'('", "')'", "'?'", "','",
+  "'{'", "'}'", "$accept", "top_statement", "statement", "statement_list",
+  "exp", "function_name", "question_mark_list", "stored_procedure_call",
   "user_function_call", "table_list", "variable_list", "exp_list",
   "select_item", "select_item_list", "select_list", "search_condition",
   "for_update_clause", "lock_shared_clause", "order_direction",
@@ -611,16 +577,14 @@ static const char *const yytname[] =
   "cursor_positioned", "update_statement_start",
   "update_statement_searched", "update_statement_positioned",
   "delete_statement_start", "delete_statement_searched",
-  "delete_statement_positioned", "row_printf_statement",
-  "assignment_statement", "elsif_element", "elsif_list", "else_part",
-  "if_statement", "while_statement", "for_statement", "exit_statement",
-  "return_statement", "open_cursor_statement", "close_cursor_statement",
-  "fetch_statement", "column_def", "column_def_list", "opt_column_len",
-  "opt_unsigned", "opt_not_null", "compact", "block_size", "create_table",
-  "column_list", "unique_def", "clustered_def", "create_index",
-  "table_name", "commit_statement", "rollback_statement", "type_name",
-  "parameter_declaration", "parameter_declaration_list",
-  "variable_declaration", "variable_declaration_list",
+  "delete_statement_positioned", "assignment_statement", "elsif_element",
+  "elsif_list", "else_part", "if_statement", "while_statement",
+  "for_statement", "exit_statement", "return_statement",
+  "open_cursor_statement", "close_cursor_statement", "fetch_statement",
+  "column_def", "column_def_list", "opt_column_len", "opt_not_null",
+  "create_table", "column_list", "unique_def", "clustered_def",
+  "create_index", "table_name", "commit_statement", "rollback_statement",
+  "type_name", "variable_declaration", "variable_declaration_list",
   "cursor_declaration", "function_declaration", "declaration",
   "declaration_list", "procedure_definition", YY_NULLPTR
 };
@@ -639,17 +603,15 @@ static const yytype_uint16 yytoknum[] =
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
-      61,    60,    62,    45,    43,    42,    47,   355,    37,    59,
+      61,    60,    62,    45,    43,    42,    47,   335,    37,    59,
       40,    41,    63,    44,   123,   125
 };
 # endif
 
-#define YYPACT_NINF -176
+#define YYPACT_NINF -129
 
 #define yypact_value_is_default(Yystate) \
-  (!!((Yystate) == (-176)))
+  (!!((Yystate) == (-129)))
 
 #define YYTABLE_NINF -1
 
@@ -660,41 +622,36 @@ static const yytype_uint16 yytoknum[] =
      STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-      20,    21,    41,   -64,   -59,  -176,  -176,    48,    54,  -176,
-     -74,    12,    12,    45,    48,  -176,  -176,  -176,  -176,  -176,
-    -176,  -176,    69,  -176,    12,  -176,     8,   -32,   -43,  -176,
-    -176,  -176,  -176,   -13,  -176,    72,    81,   445,  -176,    75,
-     -11,    42,   530,   530,  -176,    16,    99,    67,    -3,    78,
-     -14,   108,   109,   110,  -176,  -176,  -176,    86,    36,    44,
-    -176,   122,  -176,   216,  -176,    22,    23,    25,     6,    26,
-      93,    27,    33,    93,    46,    51,    53,    56,    61,    63,
-      64,    66,    68,    70,    71,    76,    79,    89,    94,    95,
-      86,  -176,   530,  -176,  -176,  -176,  -176,    43,   530,    49,
-    -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,
-    -176,   530,   530,   570,    77,   603,    80,    96,  -176,   674,
-    -176,   -38,   118,   161,    -3,  -176,  -176,   129,    -3,    -3,
-    -176,   148,  -176,   163,  -176,  -176,  -176,  -176,    97,  -176,
-    -176,  -176,   530,  -176,   100,  -176,  -176,   481,  -176,  -176,
-    -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,
-    -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,
-     102,   674,   149,   220,   155,    14,    91,   530,   530,   530,
-     530,   530,   445,   219,   530,   530,   530,   530,   530,   530,
-     530,   530,   445,   530,   -24,   218,   267,    -3,   530,  -176,
-     221,  -176,   117,  -176,   179,   228,   124,   674,   -65,   530,
-     185,   674,  -176,  -176,  -176,  -176,   220,   220,    19,    19,
-     674,   136,  -176,    19,    19,    19,     3,     3,    14,    14,
-     -57,   326,   554,   231,   128,  -176,   130,  -176,    -1,  -176,
-     610,   142,  -176,   131,   238,   242,   141,  -176,   130,  -176,
-     -52,  -176,   530,   -51,   246,   445,   530,  -176,   227,   233,
-    -176,   229,  -176,   151,  -176,   252,   530,    -3,   225,   530,
-     530,   221,    12,  -176,   -48,   207,   156,   153,   164,   674,
-    -176,  -176,   445,   626,  -176,   250,  -176,  -176,  -176,  -176,
-     230,   194,   655,   674,  -176,   173,   187,   238,    -3,  -176,
-    -176,  -176,   445,  -176,  -176,   270,   245,   445,   284,   204,
-    -176,   192,  -176,   181,   445,   203,   253,  -176,   386,   193,
-    -176,   286,   205,  -176,   296,   217,   299,   279,  -176,   303,
-    -176,   307,  -176,   -47,  -176,    30,  -176,  -176,  -176,  -176,
-     305,  -176,  -176,  -176,  -176
+       5,    34,    46,   -28,   -41,  -129,  -129,   -12,    45,    57,
+      23,  -129,     9,  -129,  -129,  -129,    20,    -9,  -129,  -129,
+    -129,  -129,     2,  -129,    83,    87,   278,  -129,    93,    28,
+      71,   427,   427,  -129,   335,   105,    85,    -1,   104,   -27,
+     129,   132,   133,    76,    77,  -129,   141,  -129,   149,  -129,
+      61,    19,    62,   118,    65,    66,   118,    68,    69,    70,
+      72,    73,    74,    75,    78,    79,    82,    84,    89,    90,
+      91,    94,   138,  -129,   427,  -129,  -129,  -129,  -129,    86,
+     427,    96,  -129,  -129,  -129,  -129,  -129,   427,   427,   438,
+      92,   454,    95,  -129,     1,  -129,   -24,   130,   157,    -1,
+    -129,  -129,   144,    -1,    -1,  -129,   139,  -129,   154,  -129,
+    -129,  -129,    98,  -129,  -129,  -129,   108,  -129,  -129,   345,
+    -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,
+    -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,
+    -129,   112,     1,   135,   285,   143,    -8,    15,   427,   427,
+     427,   427,   427,   278,   203,   427,   427,   427,   427,   427,
+     427,   427,   427,   278,   124,   204,   381,    -1,   427,  -129,
+     209,  -129,   120,  -129,   173,   215,   131,   427,   180,     1,
+    -129,  -129,  -129,  -129,   285,   285,    30,    30,     1,    10,
+    -129,    30,    30,    30,    60,    60,    -8,    -8,     1,   -39,
+     192,   137,  -129,   136,  -129,   -13,  -129,   472,   146,  -129,
+     147,   225,   227,   151,  -129,   136,  -129,   -21,     0,   229,
+     278,   427,  -129,   213,   219,  -129,   427,   220,  -129,   237,
+     427,    -1,   214,   427,   427,   209,    23,  -129,    14,   196,
+     160,   158,   162,  -129,  -129,   278,   486,  -129,   231,     1,
+    -129,  -129,  -129,   218,   194,   517,     1,  -129,   175,  -129,
+     225,    -1,  -129,  -129,  -129,   278,  -129,  -129,   251,   234,
+     278,   266,   260,  -129,   181,   278,   201,   239,  -129,   235,
+     184,   271,  -129,   272,   208,   275,   258,  -129,  -129,  -129,
+      17,  -129,    -7,  -129,  -129,   277,  -129,  -129,  -129,  -129
 };
 
   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -702,67 +659,60 @@ static const yytype_int16 yypact[] =
      means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       0,     0,     0,     0,     0,     1,     2,   164,     0,   165,
-       0,     0,     0,     0,     0,   160,   161,   157,   159,   158,
-     162,   163,   168,   166,     0,   169,   175,     0,     0,   170,
-     173,   174,   176,     0,   167,     0,     0,     0,   177,     0,
-       0,     0,     0,     0,   127,    84,     0,     0,     0,     0,
-     148,     0,     0,     0,    68,    69,    70,     0,     0,     0,
-     126,     0,    25,     0,     3,     0,     0,     0,     0,     0,
-      90,     0,     0,    90,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     1,     2,     0,     0,   140,
+       0,   141,   147,   136,   138,   137,     0,     0,   142,   145,
+     146,   148,     0,   139,     0,     0,     0,   149,     0,     0,
+       0,     0,     0,   112,    70,     0,     0,     0,     0,   127,
+       0,     0,     0,     0,     0,   111,     0,    23,     0,     3,
+       0,     0,     0,    76,     0,     0,    76,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   172,     0,    29,    30,    31,    32,    27,     0,    33,
-      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
-      62,     0,     0,     0,     0,     0,     0,     0,    87,    80,
-      85,    89,     0,     0,     0,   153,   154,     0,     0,     0,
-     149,   150,   128,     0,   129,   115,   155,   156,     0,   178,
-      26,     4,    77,    11,     0,   104,    12,     0,   110,   111,
-      16,    17,   113,   114,    14,    15,    13,    10,     8,     5,
-       6,     7,     9,    18,    20,    19,    23,    24,    21,    22,
-       0,   116,     0,    49,     0,    38,     0,     0,     0,     0,
+       0,     0,     0,   144,     0,    27,    28,    29,    30,    25,
+       0,    31,    50,    51,    52,    53,    54,     0,     0,     0,
+       0,     0,     0,    73,    68,    71,    75,     0,     0,     0,
+     132,   133,     0,     0,     0,   128,   129,   113,     0,   114,
+     134,   135,     0,   150,    24,    10,     0,    90,    11,     0,
+      96,    97,    14,    15,    99,   100,    12,    13,     9,     7,
+       4,     5,     6,     8,    16,    18,    17,    21,    22,    19,
+      20,     0,   101,     0,    47,     0,    36,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    77,     0,     0,     0,    74,     0,     0,     0,   102,
-       0,   112,     0,   151,     0,    74,    63,    78,     0,    77,
-       0,    91,   171,    50,    51,    39,    47,    48,    44,    45,
-      46,   120,    41,    40,    42,    43,    35,    34,    36,    37,
-       0,     0,     0,     0,     0,    75,    88,    86,    90,    72,
-       0,     0,   106,   109,     0,     0,    75,   131,   130,    64,
-       0,    67,     0,     0,     0,     0,     0,   118,   122,     0,
-      28,     0,    83,     0,    81,     0,     0,     0,    92,     0,
-       0,     0,     0,   133,     0,     0,     0,     0,     0,    79,
-     103,   108,   121,     0,   119,     0,   124,    82,    76,    73,
-       0,    94,     0,   105,   107,   135,   141,     0,     0,    71,
-      66,    65,     0,   123,    93,     0,    99,     0,     0,   137,
-     142,   143,   134,     0,   117,     0,     0,   101,     0,     0,
-     138,   139,     0,   145,     0,     0,     0,     0,   136,     0,
-     132,     0,   146,     0,    95,    96,   125,   140,   144,   152,
-       0,    97,    98,   100,   147
+       0,     0,    65,     0,     0,    62,     0,     0,     0,    88,
+       0,    98,     0,   130,     0,    62,    55,    65,     0,    77,
+     143,    48,    49,    37,    45,    46,    42,    43,    44,   105,
+      39,    38,    40,    41,    33,    32,    34,    35,    66,     0,
+       0,     0,    63,    74,    72,    76,    60,     0,     0,    92,
+      95,     0,     0,    63,   116,   115,    56,     0,     0,     0,
+       0,     0,   103,   107,     0,    26,     0,     0,    69,     0,
+       0,     0,    78,     0,     0,     0,     0,   118,     0,     0,
+       0,     0,     0,    89,    94,   106,     0,   104,     0,    67,
+     109,    64,    61,     0,    80,     0,    91,    93,   120,   124,
+       0,     0,    59,    58,    57,     0,   108,    79,     0,    85,
+       0,     0,   122,   119,     0,   102,     0,     0,    87,     0,
+       0,     0,   117,     0,     0,     0,     0,   121,   123,   125,
+       0,    81,    82,   110,   131,     0,    83,    84,    86,   126
 };
 
   /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -176,  -176,   -62,  -175,   -40,  -176,  -176,  -176,  -176,  -176,
-    -176,  -176,   111,  -166,   119,  -176,  -176,   -67,  -176,  -176,
-    -176,  -176,   -33,  -176,  -176,    47,  -176,   240,  -176,  -176,
-    -176,  -176,  -176,  -176,  -176,  -176,    59,  -176,  -176,  -176,
-    -176,  -176,  -176,  -176,  -176,  -176,  -176,    17,  -176,  -176,
-    -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,  -176,  -115,
-    -176,  -176,   -12,   313,  -176,   293,  -176,  -176,  -176,   295,
-    -176,  -176
+    -129,  -129,   -48,  -128,   -30,  -129,  -129,  -129,  -129,  -129,
+     113,   110,   123,  -129,  -129,   -52,  -129,  -129,  -129,  -129,
+     -40,  -129,  -129,    55,  -129,   238,  -129,  -129,  -129,  -129,
+    -129,  -129,  -129,    88,  -129,  -129,  -129,  -129,  -129,  -129,
+    -129,  -129,  -129,  -129,    35,  -129,  -129,  -129,  -129,  -129,
+    -129,  -129,  -129,   -96,  -129,  -129,    81,   290,  -129,  -129,
+    -129,   286,  -129,  -129
 };
 
   /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,     2,    62,    63,   207,   114,   250,    64,    65,    66,
-     247,   238,   236,   208,   120,   121,   122,   148,   291,   306,
-     343,   317,    67,    68,    69,   242,   243,   149,    70,    71,
-      72,    73,    74,    75,    76,    77,   257,   258,   259,    78,
-      79,    80,    81,    82,    83,    84,    85,   273,   274,   309,
-     321,   330,   311,   323,    86,   333,   131,   204,    87,   127,
-      88,    89,    20,     9,    10,    25,    26,    30,    31,    32,
-      33,     3
+      -1,     2,    47,    48,    94,    90,   217,    49,   214,   205,
+     203,   199,    95,    96,    97,   120,   254,   269,   298,   278,
+      50,    51,    52,   209,   210,   121,    53,    54,    55,    56,
+      57,    58,    59,   222,   223,   224,    60,    61,    62,    63,
+      64,    65,    66,    67,   237,   238,   272,   282,    68,   290,
+     106,   174,    69,   102,    70,    71,    16,    11,    12,    19,
+      20,    21,    22,     3
 };
 
   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
@@ -770,232 +720,189 @@ static const yytype_int16 yydefgoto[] =
      number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_uint16 yytable[] =
 {
-      21,   140,   113,   115,   125,   119,   152,   221,   195,   199,
-      37,   233,    27,   201,   202,    24,   181,   231,    35,    93,
-      94,    95,    96,    97,   135,   230,    98,   181,     4,    15,
-      16,    17,   181,    18,     1,   145,   266,    13,    45,    14,
-     129,     5,   130,   253,    36,     6,   251,    28,   252,   116,
-     117,     7,   171,   144,   260,     8,   252,   170,   173,   277,
-     280,   278,   252,   296,   339,   297,   340,    22,    28,    11,
-      12,   175,   176,   341,   342,   196,    24,    34,    99,    39,
-     282,   234,   239,   100,   101,   102,   103,   104,    40,   105,
-     106,   107,   108,   126,   183,   109,   110,    90,    91,   177,
-     178,    92,   179,   180,   181,   183,   123,   211,   189,   190,
-     183,    19,   267,   124,   128,   132,   133,   134,    45,   111,
-     136,   118,   187,   188,   189,   190,   112,   314,   137,   138,
-     147,   141,   318,   142,   143,   146,   150,   216,   217,   218,
-     219,   220,   151,    41,   223,   224,   225,   226,   227,   228,
-     229,   172,   289,   232,   197,   154,   119,   174,   240,   140,
-     155,    42,   156,   255,   256,   157,    43,    44,    45,   140,
-     158,   268,   159,   160,    46,   161,   198,   162,   200,   163,
-     164,    47,   183,   313,    48,   165,    49,   191,   166,    50,
-     193,   184,   185,   186,   187,   188,   189,   190,   167,    51,
-      52,    53,   215,   168,   169,   203,   194,   206,    54,   205,
-     209,   212,   279,    55,    56,   213,   283,    57,    58,    59,
-     140,   214,    60,    41,   222,   235,   211,   244,   241,   292,
-     293,   179,   180,   181,   245,   246,   249,   254,   263,   264,
-     139,    42,   270,   265,   271,   272,    43,    44,    45,   275,
-      61,   276,   140,   281,    46,   256,   140,   285,   286,   288,
-     295,    47,   287,   290,    48,   298,    49,   299,   300,    50,
-      93,    94,    95,    96,    97,   303,   301,    98,   304,    51,
-      52,    53,   305,   308,   310,   315,   316,   319,    54,   320,
-     322,   324,   325,    55,    56,   326,   329,    57,    58,    59,
-     116,   117,    60,   332,   328,   331,   335,   334,   336,   337,
-     338,   183,   344,   153,   312,   237,   248,   284,   294,    29,
-     184,   185,   186,   187,   188,   189,   190,    23,    38,    99,
-      61,     0,     0,    41,   100,   101,   102,   103,   104,     0,
-     105,   106,   107,   108,     0,     0,   109,   110,     0,     0,
-     261,    42,     0,     0,     0,     0,    43,    44,    45,     0,
-       0,     0,     0,     0,    46,     0,     0,     0,     0,     0,
-     111,    47,     0,     0,    48,     0,    49,   112,     0,    50,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    51,
-      52,    53,     0,    41,     0,     0,     0,     0,    54,     0,
-       0,     0,     0,    55,    56,     0,     0,    57,    58,    59,
-     327,    42,    60,     0,     0,     0,    43,    44,    45,     0,
-       0,     0,     0,     0,    46,     0,     0,     0,     0,     0,
-       0,    47,     0,     0,    48,     0,    49,     0,     0,    50,
-      61,     0,     0,     0,     0,     0,     0,     0,     0,    51,
-      52,    53,    41,     0,     0,     0,     0,     0,    54,     0,
-       0,     0,     0,    55,    56,     0,     0,    57,    58,    59,
-      42,     0,    60,     0,     0,    43,    44,    45,     0,     0,
-       0,     0,     0,    46,    93,    94,    95,    96,    97,     0,
-      47,    98,     0,    48,     0,    49,     0,     0,    50,     0,
-      61,     0,     0,     0,     0,     0,     0,     0,    51,    52,
-      53,     0,     0,     0,     0,     0,     0,    54,     0,     0,
-       0,     0,    55,    56,     0,     0,    57,    58,    59,     0,
-       0,    60,   210,    93,    94,    95,    96,    97,     0,     0,
-      98,     0,     0,    99,     0,     0,     0,     0,   100,   101,
-     102,   103,   104,     0,   105,   106,   107,   108,     0,    61,
-     109,   110,   177,   178,     0,   179,   180,   181,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   177,   178,
-       0,   179,   180,   181,   111,     0,     0,     0,     0,     0,
-       0,   112,    99,     0,     0,     0,   182,   100,   101,   102,
-     103,   104,     0,   105,   106,   107,   108,     0,     0,   109,
-     110,   177,   178,     0,   179,   180,   181,     0,   177,   178,
-       0,   179,   180,   181,     0,     0,     0,     0,     0,     0,
-       0,     0,   192,   111,   177,   178,     0,   179,   180,   181,
-     112,     0,     0,     0,     0,   183,     0,     0,     0,   269,
-       0,     0,   302,     0,   184,   185,   186,   187,   188,   189,
-     190,   183,     0,   177,   178,   262,   179,   180,   181,     0,
-     184,   185,   186,   187,   188,   189,   190,     0,     0,     0,
-       0,     0,   177,   178,   307,   179,   180,   181,     0,     0,
-       0,     0,     0,     0,   183,     0,     0,     0,     0,     0,
-       0,   183,     0,   184,   185,   186,   187,   188,   189,   190,
-     184,   185,   186,   187,   188,   189,   190,   183,     0,     0,
-       0,     0,     0,     0,     0,     0,   184,   185,   186,   187,
-     188,   189,   190,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   183,     0,     0,     0,
-       0,     0,     0,     0,     0,   184,   185,   186,   187,   188,
-     189,   190,     0,     0,     0,   183,     0,     0,     0,     0,
-       0,     0,     0,     0,   184,   185,   186,   187,   188,   189,
-     190
+     114,    89,    91,   169,   124,   152,   100,   171,   172,   148,
+     149,   117,   150,   151,   152,   165,    10,    30,   230,     1,
+     104,    26,   105,   148,   149,   189,   150,   151,   152,   296,
+     297,    31,   141,   220,   221,   200,    32,    33,    34,    13,
+      14,     4,    35,   152,   142,    24,     5,    34,    36,     7,
+     144,    37,   225,    38,   226,    17,    39,   146,   147,   116,
+      25,     6,    17,     9,    10,   154,    40,    41,    42,   166,
+     241,   206,   242,   152,   154,    43,    44,   101,    45,     8,
+     231,   155,   156,   157,   158,   159,   160,   161,   154,   179,
+      28,   243,   245,   226,    29,   155,   156,   157,   158,   159,
+     160,   161,    15,   154,    46,   259,   183,   260,   294,    23,
+     295,    72,    98,   158,   159,   160,   161,    73,   184,   185,
+     186,   187,   188,    74,    99,   191,   192,   193,   194,   195,
+     196,   197,   198,   154,   103,   252,   107,   275,   207,   108,
+     109,   114,   279,   110,   111,   160,   161,   198,   112,   119,
+     115,   118,   114,   232,   122,   123,    30,   126,   127,   128,
+     167,   129,   130,   131,   132,   274,    34,   133,   134,   113,
+      31,   135,   168,   136,   143,    32,    33,    34,   137,   138,
+     139,    35,   162,   140,   145,   164,   170,    36,   176,   173,
+      37,   246,    38,   175,   181,    39,   249,   114,   177,    30,
+     179,   180,   182,   255,   256,    40,    41,    42,   190,   201,
+     211,   202,   227,    31,    43,    44,   208,    45,    32,    33,
+      34,   212,   213,   216,    35,   219,   234,   114,   228,   229,
+      36,   114,   236,    37,   239,    38,   244,   221,    39,   248,
+     235,   240,    30,    46,   251,   250,   253,   261,    40,    41,
+      42,   262,   266,   263,   264,   286,    31,    43,    44,   267,
+      45,    32,    33,    34,   268,   271,   276,    35,   277,   280,
+     281,   283,   284,    36,   285,   287,    37,   288,    38,   289,
+     291,    39,   292,   293,   299,    30,    46,   218,   215,   204,
+     257,    40,    41,    42,   125,   273,   150,   151,   152,    31,
+      43,    44,    18,    45,    32,    33,    34,     0,    27,     0,
+      35,   247,     0,     0,     0,     0,    36,   258,     0,    37,
+       0,    38,     0,     0,    39,     0,     0,     0,     0,    46,
+       0,     0,     0,     0,    40,    41,    42,     0,    75,    76,
+      77,    78,    79,    43,    44,    80,    45,     0,    75,    76,
+      77,    78,    79,     0,     0,    80,     0,     0,   154,     0,
+       0,     0,     0,     0,    92,   155,   156,   157,   158,   159,
+     160,   161,    46,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    75,    76,    77,    78,    79,   178,
+      81,    80,     0,     0,     0,    82,    83,    84,    85,    86,
+      81,     0,     0,     0,     0,    82,    83,    84,    85,    86,
+      92,     0,     0,     0,     0,     0,     0,     0,    87,     0,
+      93,     0,     0,     0,     0,    88,     0,     0,    87,     0,
+      75,    76,    77,    78,    79,    88,    81,    80,     0,     0,
+       0,    82,    83,    84,    85,    86,   148,   149,     0,   150,
+     151,   152,     0,     0,     0,     0,     0,     0,     0,     0,
+     153,     0,   148,   149,    87,   150,   151,   152,     0,     0,
+       0,    88,     0,     0,     0,     0,     0,     0,     0,   163,
+     148,   149,    81,   150,   151,   152,     0,    82,    83,    84,
+      85,    86,     0,     0,   148,   149,     0,   150,   151,   152,
+       0,     0,     0,     0,     0,   233,     0,     0,   265,     0,
+      87,   154,     0,     0,     0,     0,     0,    88,   155,   156,
+     157,   158,   159,   160,   161,   148,   149,   154,   150,   151,
+     152,     0,     0,     0,   155,   156,   157,   158,   159,   160,
+     161,     0,   270,     0,     0,   154,     0,     0,     0,     0,
+       0,     0,   155,   156,   157,   158,   159,   160,   161,   154,
+       0,     0,     0,     0,     0,     0,   155,   156,   157,   158,
+     159,   160,   161,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     154,     0,     0,     0,     0,     0,     0,   155,   156,   157,
+     158,   159,   160,   161
 };
 
 static const yytype_int16 yycheck[] =
 {
-      12,    63,    42,    43,     7,    45,    73,   182,    46,   124,
-      23,    35,    24,   128,   129,     7,    13,   192,    61,     3,
-       4,     5,     6,     7,    57,   191,    10,    13,     7,    17,
-      18,    19,    13,    21,    14,    68,    37,   111,    32,   113,
-      54,     0,    56,   209,    87,   109,   111,    60,   113,    33,
-      34,   110,    92,    47,   111,     7,   113,    90,    98,   111,
-     111,   113,   113,   111,   111,   113,   113,    22,    60,    15,
-      16,   111,   112,    43,    44,   113,     7,   109,    62,     7,
-     255,   105,   197,    67,    68,    69,    70,    71,     7,    73,
-      74,    75,    76,    96,    91,    79,    80,    22,   109,     8,
-       9,    59,    11,    12,    13,    91,     7,   147,   105,   106,
-      91,    99,   113,    46,    36,     7,     7,     7,    32,   103,
-      84,   105,   103,   104,   105,   106,   110,   302,    84,     7,
-      37,   109,   307,   110,   109,   109,   109,   177,   178,   179,
-     180,   181,   109,     7,   184,   185,   186,   187,   188,   189,
-     190,   108,   267,   193,    36,   109,   196,   108,   198,   221,
-     109,    25,   109,    27,    28,   109,    30,    31,    32,   231,
-     109,   238,   109,   109,    38,   109,    15,   109,    49,   109,
-     109,    45,    91,   298,    48,   109,    50,   110,   109,    53,
-     110,   100,   101,   102,   103,   104,   105,   106,   109,    63,
-      64,    65,   111,   109,   109,    57,   110,   110,    72,    46,
-     110,   109,   252,    77,    78,    66,   256,    81,    82,    83,
-     282,    66,    86,     7,     5,     7,   266,   110,     7,   269,
-     270,    11,    12,    13,    55,     7,   112,    52,     7,   111,
-      24,    25,   100,   113,   113,     7,    30,    31,    32,     7,
-     114,   110,   314,     7,    38,    28,   318,    24,    29,     7,
-     272,    45,   111,    38,    48,    58,    50,   111,   115,    53,
-       3,     4,     5,     6,     7,    25,   112,    10,    48,    63,
-      64,    65,    88,   110,    97,    15,    41,     3,    72,    85,
-      98,   110,    89,    77,    78,    42,    10,    81,    82,    83,
-      33,    34,    86,     7,   111,   100,     7,    90,    29,     6,
-       3,    91,     7,    73,   297,   196,   205,   258,   271,    26,
-     100,   101,   102,   103,   104,   105,   106,    14,    33,    62,
-     114,    -1,    -1,     7,    67,    68,    69,    70,    71,    -1,
-      73,    74,    75,    76,    -1,    -1,    79,    80,    -1,    -1,
-      24,    25,    -1,    -1,    -1,    -1,    30,    31,    32,    -1,
-      -1,    -1,    -1,    -1,    38,    -1,    -1,    -1,    -1,    -1,
-     103,    45,    -1,    -1,    48,    -1,    50,   110,    -1,    53,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    63,
-      64,    65,    -1,     7,    -1,    -1,    -1,    -1,    72,    -1,
-      -1,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
-      24,    25,    86,    -1,    -1,    -1,    30,    31,    32,    -1,
-      -1,    -1,    -1,    -1,    38,    -1,    -1,    -1,    -1,    -1,
-      -1,    45,    -1,    -1,    48,    -1,    50,    -1,    -1,    53,
-     114,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    63,
-      64,    65,     7,    -1,    -1,    -1,    -1,    -1,    72,    -1,
-      -1,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
-      25,    -1,    86,    -1,    -1,    30,    31,    32,    -1,    -1,
-      -1,    -1,    -1,    38,     3,     4,     5,     6,     7,    -1,
-      45,    10,    -1,    48,    -1,    50,    -1,    -1,    53,    -1,
-     114,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,
-      65,    -1,    -1,    -1,    -1,    -1,    -1,    72,    -1,    -1,
-      -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    -1,
-      -1,    86,    51,     3,     4,     5,     6,     7,    -1,    -1,
-      10,    -1,    -1,    62,    -1,    -1,    -1,    -1,    67,    68,
-      69,    70,    71,    -1,    73,    74,    75,    76,    -1,   114,
-      79,    80,     8,     9,    -1,    11,    12,    13,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,     9,
-      -1,    11,    12,    13,   103,    -1,    -1,    -1,    -1,    -1,
-      -1,   110,    62,    -1,    -1,    -1,    26,    67,    68,    69,
-      70,    71,    -1,    73,    74,    75,    76,    -1,    -1,    79,
-      80,     8,     9,    -1,    11,    12,    13,    -1,     8,     9,
-      -1,    11,    12,    13,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    29,   103,     8,     9,    -1,    11,    12,    13,
-     110,    -1,    -1,    -1,    -1,    91,    -1,    -1,    -1,    39,
-      -1,    -1,    26,    -1,   100,   101,   102,   103,   104,   105,
-     106,    91,    -1,     8,     9,   111,    11,    12,    13,    -1,
-     100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
-      -1,    -1,     8,     9,    29,    11,    12,    13,    -1,    -1,
-      -1,    -1,    -1,    -1,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    91,    -1,   100,   101,   102,   103,   104,   105,   106,
-     100,   101,   102,   103,   104,   105,   106,    91,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   100,   101,   102,   103,
-     104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    91,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   100,   101,   102,   103,   104,
-     105,   106,    -1,    -1,    -1,    91,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   100,   101,   102,   103,   104,   105,
-     106
+      48,    31,    32,    99,    56,    13,     7,   103,   104,     8,
+       9,    51,    11,    12,    13,    39,     7,     7,    31,    14,
+      47,    19,    49,     8,     9,   153,    11,    12,    13,    36,
+      37,    21,    72,    23,    24,   163,    26,    27,    28,    16,
+      17,     7,    32,    13,    74,    54,     0,    28,    38,    90,
+      80,    41,    91,    43,    93,    53,    46,    87,    88,    40,
+      69,    89,    53,    18,     7,    73,    56,    57,    58,    93,
+      91,   167,    93,    13,    73,    65,    66,    78,    68,    91,
+      93,    80,    81,    82,    83,    84,    85,    86,    73,   119,
+       7,    91,   220,    93,     7,    80,    81,    82,    83,    84,
+      85,    86,    79,    73,    94,    91,    91,    93,    91,    89,
+      93,    18,     7,    83,    84,    85,    86,    89,   148,   149,
+     150,   151,   152,    52,    39,   155,   156,   157,   158,   159,
+     160,   161,   162,    73,    30,   231,     7,   265,   168,     7,
+       7,   189,   270,    67,    67,    85,    86,   177,     7,    31,
+      89,    89,   200,   205,    89,    89,     7,    89,    89,    89,
+      30,    89,    89,    89,    89,   261,    28,    89,    89,    20,
+      21,    89,    15,    89,    88,    26,    27,    28,    89,    89,
+      89,    32,    90,    89,    88,    90,    42,    38,    90,    50,
+      41,   221,    43,    39,    59,    46,   226,   245,    90,     7,
+     230,    89,    59,   233,   234,    56,    57,    58,     5,    85,
+      90,     7,    20,    21,    65,    66,     7,    68,    26,    27,
+      28,    48,     7,    92,    32,    45,    80,   275,    91,    93,
+      38,   279,     7,    41,     7,    43,     7,    24,    46,    20,
+      93,    90,     7,    94,     7,    25,    32,    51,    56,    57,
+      58,    91,    21,    95,    92,    20,    21,    65,    66,    41,
+      68,    26,    27,    28,    70,    90,    15,    32,    34,     3,
+      10,    90,    71,    38,    35,    91,    41,     6,    43,     7,
+      72,    46,     7,    25,     7,     7,    94,   177,   175,   166,
+     235,    56,    57,    58,    56,   260,    11,    12,    13,    21,
+      65,    66,    12,    68,    26,    27,    28,    -1,    22,    -1,
+      32,   223,    -1,    -1,    -1,    -1,    38,   236,    -1,    41,
+      -1,    43,    -1,    -1,    46,    -1,    -1,    -1,    -1,    94,
+      -1,    -1,    -1,    -1,    56,    57,    58,    -1,     3,     4,
+       5,     6,     7,    65,    66,    10,    68,    -1,     3,     4,
+       5,     6,     7,    -1,    -1,    10,    -1,    -1,    73,    -1,
+      -1,    -1,    -1,    -1,    29,    80,    81,    82,    83,    84,
+      85,    86,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,    44,
+      55,    10,    -1,    -1,    -1,    60,    61,    62,    63,    64,
+      55,    -1,    -1,    -1,    -1,    60,    61,    62,    63,    64,
+      29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    83,    -1,
+      85,    -1,    -1,    -1,    -1,    90,    -1,    -1,    83,    -1,
+       3,     4,     5,     6,     7,    90,    55,    10,    -1,    -1,
+      -1,    60,    61,    62,    63,    64,     8,     9,    -1,    11,
+      12,    13,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      22,    -1,     8,     9,    83,    11,    12,    13,    -1,    -1,
+      -1,    90,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    25,
+       8,     9,    55,    11,    12,    13,    -1,    60,    61,    62,
+      63,    64,    -1,    -1,     8,     9,    -1,    11,    12,    13,
+      -1,    -1,    -1,    -1,    -1,    33,    -1,    -1,    22,    -1,
+      83,    73,    -1,    -1,    -1,    -1,    -1,    90,    80,    81,
+      82,    83,    84,    85,    86,     8,     9,    73,    11,    12,
+      13,    -1,    -1,    -1,    80,    81,    82,    83,    84,    85,
+      86,    -1,    25,    -1,    -1,    73,    -1,    -1,    -1,    -1,
+      -1,    -1,    80,    81,    82,    83,    84,    85,    86,    73,
+      -1,    -1,    -1,    -1,    -1,    -1,    80,    81,    82,    83,
+      84,    85,    86,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      73,    -1,    -1,    -1,    -1,    -1,    -1,    80,    81,    82,
+      83,    84,    85,    86
 };
 
   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
      symbol of state STATE-NUM.  */
 static const yytype_uint8 yystos[] =
 {
-       0,    14,   117,   187,     7,     0,   109,   110,     7,   179,
-     180,    15,    16,   111,   113,    17,    18,    19,    21,    99,
-     178,   178,    22,   179,     7,   181,   182,   178,    60,   181,
-     183,   184,   185,   186,   109,    61,    87,    23,   185,     7,
-       7,     7,    25,    30,    31,    32,    38,    45,    48,    50,
-      53,    63,    64,    65,    72,    77,    78,    81,    82,    83,
-      86,   114,   118,   119,   123,   124,   125,   138,   139,   140,
-     144,   145,   146,   147,   148,   149,   150,   151,   155,   156,
-     157,   158,   159,   160,   161,   162,   170,   174,   176,   177,
-      22,   109,    59,     3,     4,     5,     6,     7,    10,    62,
-      67,    68,    69,    70,    71,    73,    74,    75,    76,    79,
-      80,   103,   110,   120,   121,   120,    33,    34,   105,   120,
-     130,   131,   132,     7,    46,     7,    96,   175,    36,    54,
-      56,   172,     7,     7,     7,   138,    84,    84,     7,    24,
-     118,   109,   110,   109,    47,   138,   109,    37,   133,   143,
-     109,   109,   133,   143,   109,   109,   109,   109,   109,   109,
-     109,   109,   109,   109,   109,   109,   109,   109,   109,   109,
-     138,   120,   108,   120,   108,   120,   120,     8,     9,    11,
-      12,    13,    26,    91,   100,   101,   102,   103,   104,   105,
-     106,   110,    29,   110,   110,    46,   113,    36,    15,   175,
-      49,   175,   175,    57,   173,    46,   110,   120,   129,   110,
-      51,   120,   109,    66,    66,   111,   120,   120,   120,   120,
-     120,   119,     5,   120,   120,   120,   120,   120,   120,   120,
-     129,   119,   120,    35,   105,     7,   128,   130,   127,   175,
-     120,     7,   141,   142,   110,    55,     7,   126,   128,   112,
-     122,   111,   113,   129,    52,    27,    28,   152,   153,   154,
-     111,    24,   111,     7,   111,   113,    37,   113,   133,    39,
-     100,   113,     7,   163,   164,     7,   110,   111,   113,   120,
-     111,     7,   119,   120,   152,    24,    29,   111,     7,   175,
-      38,   134,   120,   120,   141,   178,   111,   113,    58,   111,
-     115,   112,    26,    25,    48,    88,   135,    29,   110,   165,
-      97,   168,   163,   175,   119,    15,    41,   137,   119,     3,
-      85,   166,    98,   169,   110,    89,    42,    24,   111,    10,
-     167,   100,     7,   171,    90,     7,    29,     6,     3,   111,
-     113,    43,    44,   136,     7
+       0,    14,    97,   159,     7,     0,    89,    90,    91,    18,
+       7,   153,   154,    16,    17,    79,   152,    53,   153,   155,
+     156,   157,   158,    89,    54,    69,    19,   157,     7,     7,
+       7,    21,    26,    27,    28,    32,    38,    41,    43,    46,
+      56,    57,    58,    65,    66,    68,    94,    98,    99,   103,
+     116,   117,   118,   122,   123,   124,   125,   126,   127,   128,
+     132,   133,   134,   135,   136,   137,   138,   139,   144,   148,
+     150,   151,    18,    89,    52,     3,     4,     5,     6,     7,
+      10,    55,    60,    61,    62,    63,    64,    83,    90,   100,
+     101,   100,    29,    85,   100,   108,   109,   110,     7,    39,
+       7,    78,   149,    30,    47,    49,   146,     7,     7,     7,
+      67,    67,     7,    20,    98,    89,    40,   116,    89,    31,
+     111,   121,    89,    89,   111,   121,    89,    89,    89,    89,
+      89,    89,    89,    89,    89,    89,    89,    89,    89,    89,
+      89,   116,   100,    88,   100,    88,   100,   100,     8,     9,
+      11,    12,    13,    22,    73,    80,    81,    82,    83,    84,
+      85,    86,    90,    25,    90,    39,    93,    30,    15,   149,
+      42,   149,   149,    50,   147,    39,    90,    90,    44,   100,
+      89,    59,    59,    91,   100,   100,   100,   100,   100,    99,
+       5,   100,   100,   100,   100,   100,   100,   100,   100,   107,
+      99,    85,     7,   106,   108,   105,   149,   100,     7,   119,
+     120,    90,    48,     7,   104,   106,    92,   102,   107,    45,
+      23,    24,   129,   130,   131,    91,    93,    20,    91,    93,
+      31,    93,   111,    33,    80,    93,     7,   140,   141,     7,
+      90,    91,    93,    91,     7,    99,   100,   129,    20,   100,
+      25,     7,   149,    32,   112,   100,   100,   119,   152,    91,
+      93,    51,    91,    95,    92,    22,    21,    41,    70,   113,
+      25,    90,   142,   140,   149,    99,    15,    34,   115,    99,
+       3,    10,   143,    90,    71,    35,    20,    91,     6,     7,
+     145,    72,     7,    25,    91,    93,    36,    37,   114,     7
 };
 
   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint8 yyr1[] =
 {
-       0,   116,   117,   118,   118,   118,   118,   118,   118,   118,
-     118,   118,   118,   118,   118,   118,   118,   118,   118,   118,
-     118,   118,   118,   118,   118,   119,   119,   120,   120,   120,
-     120,   120,   120,   120,   120,   120,   120,   120,   120,   120,
-     120,   120,   120,   120,   120,   120,   120,   120,   120,   120,
-     120,   120,   121,   121,   121,   121,   121,   121,   121,   121,
-     121,   121,   121,   122,   122,   122,   123,   124,   125,   125,
-     125,   126,   127,   127,   128,   128,   128,   129,   129,   129,
-     130,   130,   130,   130,   131,   131,   131,   132,   132,   132,
-     133,   133,   134,   134,   135,   135,   136,   136,   136,   137,
-     137,   138,   139,   140,   140,   141,   142,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   153,
-     154,   154,   154,   155,   156,   157,   158,   159,   160,   161,
-     162,   162,   163,   164,   164,   165,   165,   166,   166,   167,
-     167,   168,   168,   169,   169,   170,   171,   171,   172,   172,
-     173,   173,   174,   175,   175,   176,   177,   178,   178,   178,
-     178,   178,   179,   179,   180,   180,   180,   181,   182,   182,
-     182,   183,   184,   185,   185,   186,   186,   186,   187
+       0,    96,    97,    98,    98,    98,    98,    98,    98,    98,
+      98,    98,    98,    98,    98,    98,    98,    98,    98,    98,
+      98,    98,    98,    99,    99,   100,   100,   100,   100,   100,
+     100,   100,   100,   100,   100,   100,   100,   100,   100,   100,
+     100,   100,   100,   100,   100,   100,   100,   100,   100,   100,
+     101,   101,   101,   101,   101,   102,   102,   102,   103,   104,
+     105,   105,   106,   106,   106,   107,   107,   107,   108,   108,
+     109,   109,   109,   110,   110,   110,   111,   111,   112,   112,
+     113,   113,   114,   114,   114,   115,   115,   116,   117,   118,
+     118,   119,   120,   120,   121,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   130,   131,   131,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   139,   140,   141,   141,
+     142,   142,   143,   143,   144,   145,   145,   146,   146,   147,
+     147,   148,   149,   149,   150,   151,   152,   152,   152,   153,
+     154,   154,   154,   155,   156,   157,   157,   158,   158,   158,
+     159
 };
 
   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
@@ -1003,22 +910,20 @@ static const yytype_uint8 yyr2[] =
 {
        0,     2,     2,     1,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     1,     2,     1,     4,     1,
-       1,     1,     1,     1,     3,     3,     3,     3,     2,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     3,     2,
-       3,     3,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     0,     1,     3,     6,     4,     1,     1,
-       1,     3,     1,     3,     0,     1,     3,     0,     1,     3,
-       1,     4,     5,     4,     0,     1,     3,     1,     3,     1,
-       0,     2,     0,     2,     0,     4,     0,     1,     1,     0,
-       4,     8,     3,     5,     2,     3,     1,     3,     4,     4,
-       2,     2,     3,     2,     2,     2,     3,     4,     1,     2,
-       0,     2,     1,     7,     6,    10,     1,     1,     2,     2,
-       4,     4,     5,     1,     3,     0,     3,     0,     1,     0,
-       2,     0,     1,     0,     3,     8,     1,     3,     0,     1,
-       0,     1,    10,     1,     1,     2,     2,     1,     1,     1,
-       1,     1,     3,     3,     0,     1,     3,     3,     0,     1,
-       2,     6,     4,     1,     1,     0,     1,     2,    11
+       2,     2,     2,     1,     2,     1,     4,     1,     1,     1,
+       1,     1,     3,     3,     3,     3,     2,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     2,     3,     3,
+       1,     1,     1,     1,     1,     0,     1,     3,     6,     3,
+       1,     3,     0,     1,     3,     0,     1,     3,     1,     4,
+       0,     1,     3,     1,     3,     1,     0,     2,     0,     2,
+       0,     4,     0,     1,     1,     0,     4,     8,     3,     5,
+       2,     3,     1,     3,     4,     4,     2,     2,     3,     2,
+       2,     3,     4,     1,     2,     0,     2,     1,     7,     6,
+      10,     1,     1,     2,     2,     4,     4,     4,     1,     3,
+       0,     3,     0,     2,     6,     1,     3,     0,     1,     0,
+       1,    10,     1,     1,     2,     2,     1,     1,     1,     3,
+       0,     1,     2,     6,     4,     1,     1,     0,     1,     2,
+      10
 };
 
 
@@ -1034,22 +939,22 @@ static const yytype_uint8 yyr2[] =
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
-#define YYBACKUP(Token, Value)                                  \
-do                                                              \
-  if (yychar == YYEMPTY)                                        \
-    {                                                           \
-      yychar = (Token);                                         \
-      yylval = (Value);                                         \
-      YYPOPSTACK (yylen);                                       \
-      yystate = *yyssp;                                         \
-      goto yybackup;                                            \
-    }                                                           \
-  else                                                          \
-    {                                                           \
-      yyerror (YY_("syntax error: cannot back up")); \
-      YYERROR;                                                  \
-    }                                                           \
-while (0)
+#define YYBACKUP(Token, Value)                                    \
+  do                                                              \
+    if (yychar == YYEMPTY)                                        \
+      {                                                           \
+        yychar = (Token);                                         \
+        yylval = (Value);                                         \
+        YYPOPSTACK (yylen);                                       \
+        yystate = *yyssp;                                         \
+        goto yybackup;                                            \
+      }                                                           \
+    else                                                          \
+      {                                                           \
+        yyerror (YY_("syntax error: cannot back up")); \
+        YYERROR;                                                  \
+      }                                                           \
+  while (0)
 
 /* Error token number */
 #define YYTERROR        1
@@ -1089,37 +994,39 @@ do {                                                                      \
 } while (0)
 
 
-/*----------------------------------------.
-| Print this symbol's value on YYOUTPUT.  |
-`----------------------------------------*/
+/*-----------------------------------.
+| Print this symbol's value on YYO.  |
+`-----------------------------------*/
 
 static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
 {
-  FILE *yyo = yyoutput;
-  YYUSE (yyo);
+  FILE *yyoutput = yyo;
+  YYUSE (yyoutput);
   if (!yyvaluep)
     return;
 # ifdef YYPRINT
   if (yytype < YYNTOKENS)
-    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
 # endif
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   YYUSE (yytype);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
 }
 
 
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
+/*---------------------------.
+| Print this symbol on YYO.  |
+`---------------------------*/
 
 static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
 {
-  YYFPRINTF (yyoutput, "%s %s (",
+  YYFPRINTF (yyo, "%s %s (",
              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
 
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
-  YYFPRINTF (yyoutput, ")");
+  yy_symbol_value_print (yyo, yytype, yyvaluep);
+  YYFPRINTF (yyo, ")");
 }
 
 /*------------------------------------------------------------------.
@@ -1153,7 +1060,7 @@ do {                                                            \
 static void
 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
 {
-  unsigned long int yylno = yyrline[yyrule];
+  unsigned long yylno = yyrline[yyrule];
   int yynrhs = yyr2[yyrule];
   int yyi;
   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
@@ -1164,7 +1071,7 @@ yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
       yy_symbol_print (stderr,
                        yystos[yyssp[yyi + 1 - yynrhs]],
-                       &(yyvsp[(yyi + 1) - (yynrhs)])
+                       &yyvsp[(yyi + 1) - (yynrhs)]
                                               );
       YYFPRINTF (stderr, "\n");
     }
@@ -1268,7 +1175,10 @@ yytnamerr (char *yyres, const char *yystr)
           case '\\':
             if (*++yyp != '\\')
               goto do_not_strip_quotes;
-            /* Fall through.  */
+            else
+              goto append;
+
+          append:
           default:
             if (yyres)
               yyres[yyn] = *yyp;
@@ -1286,7 +1196,7 @@ yytnamerr (char *yyres, const char *yystr)
   if (! yyres)
     return yystrlen (yystr);
 
-  return yystpcpy (yyres, yystr) - yyres;
+  return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
 }
 # endif
 
@@ -1364,10 +1274,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                 yyarg[yycount++] = yytname[yyx];
                 {
                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
-                  if (! (yysize <= yysize1
-                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+                    yysize = yysize1;
+                  else
                     return 2;
-                  yysize = yysize1;
                 }
               }
         }
@@ -1379,6 +1289,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
       case N:                               \
         yyformat = S;                       \
       break
+    default: /* Avoid compiler warnings. */
       YYCASE_(0, YY_("syntax error"));
       YYCASE_(1, YY_("syntax error, unexpected %s"));
       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
@@ -1390,9 +1301,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 
   {
     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
-    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+      yysize = yysize1;
+    else
       return 2;
-    yysize = yysize1;
   }
 
   if (*yymsg_alloc < yysize)
@@ -1518,23 +1430,33 @@ yyparse (void)
   yychar = YYEMPTY; /* Cause a token to be read.  */
   goto yysetstate;
 
+
 /*------------------------------------------------------------.
-| yynewstate -- Push a new state, which is found in yystate.  |
+| yynewstate -- push a new state, which is found in yystate.  |
 `------------------------------------------------------------*/
- yynewstate:
+yynewstate:
   /* In all cases, when you get here, the value and location stacks
      have just been pushed.  So pushing a state here evens the stacks.  */
   yyssp++;
 
- yysetstate:
-  *yyssp = yystate;
+
+/*--------------------------------------------------------------------.
+| yynewstate -- set current state (the top of the stack) to yystate.  |
+`--------------------------------------------------------------------*/
+yysetstate:
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
+  *yyssp = (yytype_int16) yystate;
 
   if (yyss + yystacksize - 1 <= yyssp)
+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
+    goto yyexhaustedlab;
+#else
     {
       /* Get the current used size of the three stacks, in elements.  */
-      YYSIZE_T yysize = yyssp - yyss + 1;
+      YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);
 
-#ifdef yyoverflow
+# if defined yyoverflow
       {
         /* Give user a chance to reallocate the stack.  Use copies of
            these so that the &'s don't force the real ones into
@@ -1550,14 +1472,10 @@ yyparse (void)
                     &yyss1, yysize * sizeof (*yyssp),
                     &yyvs1, yysize * sizeof (*yyvsp),
                     &yystacksize);
-
         yyss = yyss1;
         yyvs = yyvs1;
       }
-#else /* no yyoverflow */
-# ifndef YYSTACK_RELOCATE
-      goto yyexhaustedlab;
-# else
+# else /* defined YYSTACK_RELOCATE */
       /* Extend the stack our own way.  */
       if (YYMAXDEPTH <= yystacksize)
         goto yyexhaustedlab;
@@ -1573,35 +1491,33 @@ yyparse (void)
           goto yyexhaustedlab;
         YYSTACK_RELOCATE (yyss_alloc, yyss);
         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-#  undef YYSTACK_RELOCATE
+# undef YYSTACK_RELOCATE
         if (yyss1 != yyssa)
           YYSTACK_FREE (yyss1);
       }
 # endif
-#endif /* no yyoverflow */
 
       yyssp = yyss + yysize - 1;
       yyvsp = yyvs + yysize - 1;
 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-                  (unsigned long int) yystacksize));
+                  (unsigned long) yystacksize));
 
       if (yyss + yystacksize - 1 <= yyssp)
         YYABORT;
     }
-
-  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
 
   if (yystate == YYFINAL)
     YYACCEPT;
 
   goto yybackup;
 
+
 /*-----------.
 | yybackup.  |
 `-----------*/
 yybackup:
-
   /* Do appropriate processing given the current state.  Read a
      lookahead token if we need one and don't already have one.  */
 
@@ -1659,7 +1575,6 @@ yybackup:
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   *++yyvsp = yylval;
   YY_IGNORE_MAYBE_UNINITIALIZED_END
-
   goto yynewstate;
 
 
@@ -1674,7 +1589,7 @@ yydefault:
 
 
 /*-----------------------------.
-| yyreduce -- Do a reduction.  |
+| yyreduce -- do a reduction.  |
 `-----------------------------*/
 yyreduce:
   /* yyn is the number of a rule to reduce with.  */
@@ -1694,953 +1609,779 @@ yyreduce:
   YY_REDUCE_PRINT (yyn);
   switch (yyn)
     {
-        case 25:
-#line 188 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); }
-#line 1701 "pars0grm.cc" /* yacc.c:1646  */
+  case 23:
+#line 166 "pars0grm.y"
+    { yyval = que_node_list_add_last(NULL, yyvsp[0]); }
+#line 1616 "pars0grm.cc"
+    break;
+
+  case 24:
+#line 168 "pars0grm.y"
+    { yyval = que_node_list_add_last(yyvsp[-1], yyvsp[0]); }
+#line 1622 "pars0grm.cc"
+    break;
+
+  case 25:
+#line 172 "pars0grm.y"
+    { yyval = yyvsp[0];}
+#line 1628 "pars0grm.cc"
     break;
 
   case 26:
-#line 190 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last((yyvsp[-1]), (yyvsp[0])); }
-#line 1707 "pars0grm.cc" /* yacc.c:1646  */
+#line 174 "pars0grm.y"
+    { yyval = pars_func(yyvsp[-3], yyvsp[-1]); }
+#line 1634 "pars0grm.cc"
     break;
 
   case 27:
-#line 194 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]);}
-#line 1713 "pars0grm.cc" /* yacc.c:1646  */
+#line 175 "pars0grm.y"
+    { yyval = yyvsp[0];}
+#line 1640 "pars0grm.cc"
     break;
 
   case 28:
-#line 196 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_func((yyvsp[-3]), (yyvsp[-1])); }
-#line 1719 "pars0grm.cc" /* yacc.c:1646  */
+#line 176 "pars0grm.y"
+    { yyval = yyvsp[0];}
+#line 1646 "pars0grm.cc"
     break;
 
   case 29:
-#line 197 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]);}
-#line 1725 "pars0grm.cc" /* yacc.c:1646  */
+#line 177 "pars0grm.y"
+    { yyval = yyvsp[0];}
+#line 1652 "pars0grm.cc"
     break;
 
   case 30:
-#line 198 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]);}
-#line 1731 "pars0grm.cc" /* yacc.c:1646  */
+#line 178 "pars0grm.y"
+    { yyval = yyvsp[0];}
+#line 1658 "pars0grm.cc"
     break;
 
   case 31:
-#line 199 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]);}
-#line 1737 "pars0grm.cc" /* yacc.c:1646  */
+#line 179 "pars0grm.y"
+    { yyval = yyvsp[0];}
+#line 1664 "pars0grm.cc"
     break;
 
   case 32:
-#line 200 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]);}
-#line 1743 "pars0grm.cc" /* yacc.c:1646  */
+#line 180 "pars0grm.y"
+    { yyval = pars_op('+', yyvsp[-2], yyvsp[0]); }
+#line 1670 "pars0grm.cc"
     break;
 
   case 33:
-#line 201 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]);}
-#line 1749 "pars0grm.cc" /* yacc.c:1646  */
+#line 181 "pars0grm.y"
+    { yyval = pars_op('-', yyvsp[-2], yyvsp[0]); }
+#line 1676 "pars0grm.cc"
     break;
 
   case 34:
-#line 202 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op('+', (yyvsp[-2]), (yyvsp[0])); }
-#line 1755 "pars0grm.cc" /* yacc.c:1646  */
+#line 182 "pars0grm.y"
+    { yyval = pars_op('*', yyvsp[-2], yyvsp[0]); }
+#line 1682 "pars0grm.cc"
     break;
 
   case 35:
-#line 203 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op('-', (yyvsp[-2]), (yyvsp[0])); }
-#line 1761 "pars0grm.cc" /* yacc.c:1646  */
+#line 183 "pars0grm.y"
+    { yyval = pars_op('/', yyvsp[-2], yyvsp[0]); }
+#line 1688 "pars0grm.cc"
     break;
 
   case 36:
-#line 204 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op('*', (yyvsp[-2]), (yyvsp[0])); }
-#line 1767 "pars0grm.cc" /* yacc.c:1646  */
+#line 184 "pars0grm.y"
+    { yyval = pars_op('-', yyvsp[0], NULL); }
+#line 1694 "pars0grm.cc"
     break;
 
   case 37:
-#line 205 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op('/', (yyvsp[-2]), (yyvsp[0])); }
-#line 1773 "pars0grm.cc" /* yacc.c:1646  */
+#line 185 "pars0grm.y"
+    { yyval = yyvsp[-1]; }
+#line 1700 "pars0grm.cc"
     break;
 
   case 38:
-#line 206 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op('-', (yyvsp[0]), NULL); }
-#line 1779 "pars0grm.cc" /* yacc.c:1646  */
+#line 186 "pars0grm.y"
+    { yyval = pars_op('=', yyvsp[-2], yyvsp[0]); }
+#line 1706 "pars0grm.cc"
     break;
 
   case 39:
-#line 207 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[-1]); }
-#line 1785 "pars0grm.cc" /* yacc.c:1646  */
+#line 188 "pars0grm.y"
+    { yyval = pars_op(PARS_LIKE_TOKEN, yyvsp[-2], yyvsp[0]); }
+#line 1712 "pars0grm.cc"
     break;
 
   case 40:
-#line 208 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op('=', (yyvsp[-2]), (yyvsp[0])); }
-#line 1791 "pars0grm.cc" /* yacc.c:1646  */
+#line 189 "pars0grm.y"
+    { yyval = pars_op('<', yyvsp[-2], yyvsp[0]); }
+#line 1718 "pars0grm.cc"
     break;
 
   case 41:
-#line 210 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op(PARS_LIKE_TOKEN, (yyvsp[-2]), (yyvsp[0])); }
-#line 1797 "pars0grm.cc" /* yacc.c:1646  */
+#line 190 "pars0grm.y"
+    { yyval = pars_op('>', yyvsp[-2], yyvsp[0]); }
+#line 1724 "pars0grm.cc"
     break;
 
   case 42:
-#line 211 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op('<', (yyvsp[-2]), (yyvsp[0])); }
-#line 1803 "pars0grm.cc" /* yacc.c:1646  */
+#line 191 "pars0grm.y"
+    { yyval = pars_op(PARS_GE_TOKEN, yyvsp[-2], yyvsp[0]); }
+#line 1730 "pars0grm.cc"
     break;
 
   case 43:
-#line 212 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op('>', (yyvsp[-2]), (yyvsp[0])); }
-#line 1809 "pars0grm.cc" /* yacc.c:1646  */
+#line 192 "pars0grm.y"
+    { yyval = pars_op(PARS_LE_TOKEN, yyvsp[-2], yyvsp[0]); }
+#line 1736 "pars0grm.cc"
     break;
 
   case 44:
-#line 213 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op(PARS_GE_TOKEN, (yyvsp[-2]), (yyvsp[0])); }
-#line 1815 "pars0grm.cc" /* yacc.c:1646  */
+#line 193 "pars0grm.y"
+    { yyval = pars_op(PARS_NE_TOKEN, yyvsp[-2], yyvsp[0]); }
+#line 1742 "pars0grm.cc"
     break;
 
   case 45:
-#line 214 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op(PARS_LE_TOKEN, (yyvsp[-2]), (yyvsp[0])); }
-#line 1821 "pars0grm.cc" /* yacc.c:1646  */
+#line 194 "pars0grm.y"
+    { yyval = pars_op(PARS_AND_TOKEN, yyvsp[-2], yyvsp[0]); }
+#line 1748 "pars0grm.cc"
     break;
 
   case 46:
-#line 215 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op(PARS_NE_TOKEN, (yyvsp[-2]), (yyvsp[0])); }
-#line 1827 "pars0grm.cc" /* yacc.c:1646  */
+#line 195 "pars0grm.y"
+    { yyval = pars_op(PARS_OR_TOKEN, yyvsp[-2], yyvsp[0]); }
+#line 1754 "pars0grm.cc"
     break;
 
   case 47:
-#line 216 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op(PARS_AND_TOKEN, (yyvsp[-2]), (yyvsp[0])); }
-#line 1833 "pars0grm.cc" /* yacc.c:1646  */
+#line 196 "pars0grm.y"
+    { yyval = pars_op(PARS_NOT_TOKEN, yyvsp[0], NULL); }
+#line 1760 "pars0grm.cc"
     break;
 
   case 48:
-#line 217 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op(PARS_OR_TOKEN, (yyvsp[-2]), (yyvsp[0])); }
-#line 1839 "pars0grm.cc" /* yacc.c:1646  */
+#line 198 "pars0grm.y"
+    { yyval = pars_op(PARS_NOTFOUND_TOKEN, yyvsp[-2], NULL); }
+#line 1766 "pars0grm.cc"
     break;
 
   case 49:
-#line 218 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op(PARS_NOT_TOKEN, (yyvsp[0]), NULL); }
-#line 1845 "pars0grm.cc" /* yacc.c:1646  */
+#line 200 "pars0grm.y"
+    { yyval = pars_op(PARS_NOTFOUND_TOKEN, yyvsp[-2], NULL); }
+#line 1772 "pars0grm.cc"
     break;
 
   case 50:
-#line 220 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op(PARS_NOTFOUND_TOKEN, (yyvsp[-2]), NULL); }
-#line 1851 "pars0grm.cc" /* yacc.c:1646  */
+#line 204 "pars0grm.y"
+    { yyval = &pars_to_binary_token; }
+#line 1778 "pars0grm.cc"
     break;
 
   case 51:
-#line 222 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_op(PARS_NOTFOUND_TOKEN, (yyvsp[-2]), NULL); }
-#line 1857 "pars0grm.cc" /* yacc.c:1646  */
+#line 205 "pars0grm.y"
+    { yyval = &pars_substr_token; }
+#line 1784 "pars0grm.cc"
     break;
 
   case 52:
-#line 226 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_to_char_token; }
-#line 1863 "pars0grm.cc" /* yacc.c:1646  */
+#line 206 "pars0grm.y"
+    { yyval = &pars_concat_token; }
+#line 1790 "pars0grm.cc"
     break;
 
   case 53:
-#line 227 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_to_number_token; }
-#line 1869 "pars0grm.cc" /* yacc.c:1646  */
+#line 207 "pars0grm.y"
+    { yyval = &pars_instr_token; }
+#line 1796 "pars0grm.cc"
     break;
 
   case 54:
-#line 228 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_to_binary_token; }
-#line 1875 "pars0grm.cc" /* yacc.c:1646  */
+#line 208 "pars0grm.y"
+    { yyval = &pars_length_token; }
+#line 1802 "pars0grm.cc"
     break;
 
-  case 55:
-#line 230 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_binary_to_number_token; }
-#line 1881 "pars0grm.cc" /* yacc.c:1646  */
+  case 58:
+#line 219 "pars0grm.y"
+    { yyval = pars_stored_procedure_call(
+					static_cast<sym_node_t*>(yyvsp[-4])); }
+#line 1809 "pars0grm.cc"
     break;
 
-  case 56:
-#line 231 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_substr_token; }
-#line 1887 "pars0grm.cc" /* yacc.c:1646  */
+  case 59:
+#line 224 "pars0grm.y"
+    { yyval = yyvsp[-2]; }
+#line 1815 "pars0grm.cc"
     break;
 
-  case 57:
-#line 232 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_concat_token; }
-#line 1893 "pars0grm.cc" /* yacc.c:1646  */
+  case 60:
+#line 228 "pars0grm.y"
+    { yyval = que_node_list_add_last(NULL, yyvsp[0]); }
+#line 1821 "pars0grm.cc"
     break;
 
-  case 58:
-#line 233 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_instr_token; }
-#line 1899 "pars0grm.cc" /* yacc.c:1646  */
+  case 61:
+#line 230 "pars0grm.y"
+    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); }
+#line 1827 "pars0grm.cc"
     break;
 
-  case 59:
-#line 234 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_length_token; }
-#line 1905 "pars0grm.cc" /* yacc.c:1646  */
+  case 62:
+#line 234 "pars0grm.y"
+    { yyval = NULL; }
+#line 1833 "pars0grm.cc"
     break;
 
-  case 60:
-#line 235 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_sysdate_token; }
-#line 1911 "pars0grm.cc" /* yacc.c:1646  */
+  case 63:
+#line 235 "pars0grm.y"
+    { yyval = que_node_list_add_last(NULL, yyvsp[0]); }
+#line 1839 "pars0grm.cc"
     break;
 
-  case 61:
-#line 236 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_rnd_token; }
-#line 1917 "pars0grm.cc" /* yacc.c:1646  */
+  case 64:
+#line 237 "pars0grm.y"
+    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); }
+#line 1845 "pars0grm.cc"
     break;
 
-  case 62:
-#line 237 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_rnd_str_token; }
-#line 1923 "pars0grm.cc" /* yacc.c:1646  */
+  case 65:
+#line 241 "pars0grm.y"
+    { yyval = NULL; }
+#line 1851 "pars0grm.cc"
     break;
 
   case 66:
-#line 248 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_stored_procedure_call(
-					static_cast<sym_node_t*>((yyvsp[-4]))); }
-#line 1930 "pars0grm.cc" /* yacc.c:1646  */
+#line 242 "pars0grm.y"
+    { yyval = que_node_list_add_last(NULL, yyvsp[0]);}
+#line 1857 "pars0grm.cc"
     break;
 
   case 67:
-#line 254 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_procedure_call((yyvsp[-3]), (yyvsp[-1])); }
-#line 1936 "pars0grm.cc" /* yacc.c:1646  */
+#line 243 "pars0grm.y"
+    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); }
+#line 1863 "pars0grm.cc"
     break;
 
   case 68:
-#line 258 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_replstr_token; }
-#line 1942 "pars0grm.cc" /* yacc.c:1646  */
+#line 247 "pars0grm.y"
+    { yyval = yyvsp[0]; }
+#line 1869 "pars0grm.cc"
     break;
 
   case 69:
-#line 259 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_printf_token; }
-#line 1948 "pars0grm.cc" /* yacc.c:1646  */
+#line 249 "pars0grm.y"
+    { yyval = pars_func(&pars_count_token,
+					  que_node_list_add_last(NULL,
+					    sym_tab_add_int_lit(
+						pars_sym_tab_global, 1))); }
+#line 1878 "pars0grm.cc"
     break;
 
   case 70:
-#line 260 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_assert_token; }
-#line 1954 "pars0grm.cc" /* yacc.c:1646  */
+#line 256 "pars0grm.y"
+    { yyval = NULL; }
+#line 1884 "pars0grm.cc"
     break;
 
   case 71:
-#line 264 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[-2]); }
-#line 1960 "pars0grm.cc" /* yacc.c:1646  */
+#line 257 "pars0grm.y"
+    { yyval = que_node_list_add_last(NULL, yyvsp[0]); }
+#line 1890 "pars0grm.cc"
     break;
 
   case 72:
-#line 268 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); }
-#line 1966 "pars0grm.cc" /* yacc.c:1646  */
+#line 259 "pars0grm.y"
+    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); }
+#line 1896 "pars0grm.cc"
     break;
 
   case 73:
-#line 270 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); }
-#line 1972 "pars0grm.cc" /* yacc.c:1646  */
+#line 263 "pars0grm.y"
+    { yyval = pars_select_list(&pars_star_denoter,
+								NULL); }
+#line 1903 "pars0grm.cc"
     break;
 
   case 74:
-#line 274 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 1978 "pars0grm.cc" /* yacc.c:1646  */
+#line 266 "pars0grm.y"
+    { yyval = pars_select_list(
+					yyvsp[-2], static_cast<sym_node_t*>(yyvsp[0])); }
+#line 1910 "pars0grm.cc"
     break;
 
   case 75:
-#line 275 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); }
-#line 1984 "pars0grm.cc" /* yacc.c:1646  */
+#line 268 "pars0grm.y"
+    { yyval = pars_select_list(yyvsp[0], NULL); }
+#line 1916 "pars0grm.cc"
     break;
 
   case 76:
-#line 277 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); }
-#line 1990 "pars0grm.cc" /* yacc.c:1646  */
+#line 272 "pars0grm.y"
+    { yyval = NULL; }
+#line 1922 "pars0grm.cc"
     break;
 
   case 77:
-#line 281 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 1996 "pars0grm.cc" /* yacc.c:1646  */
+#line 273 "pars0grm.y"
+    { yyval = yyvsp[0]; }
+#line 1928 "pars0grm.cc"
     break;
 
   case 78:
-#line 282 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0]));}
-#line 2002 "pars0grm.cc" /* yacc.c:1646  */
+#line 277 "pars0grm.y"
+    { yyval = NULL; }
+#line 1934 "pars0grm.cc"
     break;
 
   case 79:
-#line 283 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); }
-#line 2008 "pars0grm.cc" /* yacc.c:1646  */
+#line 279 "pars0grm.y"
+    { yyval = &pars_update_token; }
+#line 1940 "pars0grm.cc"
     break;
 
   case 80:
-#line 287 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]); }
-#line 2014 "pars0grm.cc" /* yacc.c:1646  */
+#line 283 "pars0grm.y"
+    { yyval = NULL; }
+#line 1946 "pars0grm.cc"
     break;
 
   case 81:
-#line 289 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_func(&pars_count_token,
-				          que_node_list_add_last(NULL,
-					    sym_tab_add_int_lit(
-						pars_sym_tab_global, 1))); }
-#line 2023 "pars0grm.cc" /* yacc.c:1646  */
+#line 285 "pars0grm.y"
+    { yyval = &pars_share_token; }
+#line 1952 "pars0grm.cc"
     break;
 
   case 82:
-#line 294 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_func(&pars_count_token,
-					    que_node_list_add_last(NULL,
-						pars_func(&pars_distinct_token,
-						     que_node_list_add_last(
-								NULL, (yyvsp[-1]))))); }
-#line 2033 "pars0grm.cc" /* yacc.c:1646  */
+#line 289 "pars0grm.y"
+    { yyval = &pars_asc_token; }
+#line 1958 "pars0grm.cc"
     break;
 
   case 83:
-#line 300 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_func(&pars_sum_token,
-						que_node_list_add_last(NULL,
-									(yyvsp[-1]))); }
-#line 2041 "pars0grm.cc" /* yacc.c:1646  */
+#line 290 "pars0grm.y"
+    { yyval = &pars_asc_token; }
+#line 1964 "pars0grm.cc"
     break;
 
   case 84:
-#line 306 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2047 "pars0grm.cc" /* yacc.c:1646  */
+#line 291 "pars0grm.y"
+    { yyval = &pars_desc_token; }
+#line 1970 "pars0grm.cc"
     break;
 
   case 85:
-#line 307 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); }
-#line 2053 "pars0grm.cc" /* yacc.c:1646  */
+#line 295 "pars0grm.y"
+    { yyval = NULL; }
+#line 1976 "pars0grm.cc"
     break;
 
   case 86:
-#line 309 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); }
-#line 2059 "pars0grm.cc" /* yacc.c:1646  */
+#line 297 "pars0grm.y"
+    { yyval = pars_order_by(
+					static_cast<sym_node_t*>(yyvsp[-1]),
+					static_cast<pars_res_word_t*>(yyvsp[0])); }
+#line 1984 "pars0grm.cc"
     break;
 
   case 87:
-#line 313 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_select_list(&pars_star_denoter,
-								NULL); }
-#line 2066 "pars0grm.cc" /* yacc.c:1646  */
+#line 308 "pars0grm.y"
+    { yyval = pars_select_statement(
+					static_cast<sel_node_t*>(yyvsp[-6]),
+					static_cast<sym_node_t*>(yyvsp[-4]),
+					static_cast<que_node_t*>(yyvsp[-3]),
+					static_cast<pars_res_word_t*>(yyvsp[-2]),
+					static_cast<pars_res_word_t*>(yyvsp[-1]),
+					static_cast<order_node_t*>(yyvsp[0])); }
+#line 1996 "pars0grm.cc"
     break;
 
   case 88:
-#line 316 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_select_list(
-					(yyvsp[-2]), static_cast<sym_node_t*>((yyvsp[0]))); }
-#line 2073 "pars0grm.cc" /* yacc.c:1646  */
+#line 319 "pars0grm.y"
+    { yyval = yyvsp[0]; }
+#line 2002 "pars0grm.cc"
     break;
 
   case 89:
-#line 318 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_select_list((yyvsp[0]), NULL); }
-#line 2079 "pars0grm.cc" /* yacc.c:1646  */
+#line 324 "pars0grm.y"
+    { yyval = pars_insert_statement(
+					static_cast<sym_node_t*>(yyvsp[-4]), yyvsp[-1], NULL); }
+#line 2009 "pars0grm.cc"
     break;
 
   case 90:
-#line 322 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2085 "pars0grm.cc" /* yacc.c:1646  */
+#line 327 "pars0grm.y"
+    { yyval = pars_insert_statement(
+					static_cast<sym_node_t*>(yyvsp[-1]),
+					NULL,
+					static_cast<sel_node_t*>(yyvsp[0])); }
+#line 2018 "pars0grm.cc"
     break;
 
   case 91:
-#line 323 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]); }
-#line 2091 "pars0grm.cc" /* yacc.c:1646  */
+#line 334 "pars0grm.y"
+    { yyval = pars_column_assignment(
+					static_cast<sym_node_t*>(yyvsp[-2]),
+					static_cast<que_node_t*>(yyvsp[0])); }
+#line 2026 "pars0grm.cc"
     break;
 
   case 92:
-#line 327 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2097 "pars0grm.cc" /* yacc.c:1646  */
+#line 340 "pars0grm.y"
+    { yyval = que_node_list_add_last(NULL, yyvsp[0]); }
+#line 2032 "pars0grm.cc"
     break;
 
   case 93:
-#line 329 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_update_token; }
-#line 2103 "pars0grm.cc" /* yacc.c:1646  */
+#line 342 "pars0grm.y"
+    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); }
+#line 2038 "pars0grm.cc"
     break;
 
   case 94:
-#line 333 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2109 "pars0grm.cc" /* yacc.c:1646  */
+#line 348 "pars0grm.y"
+    { yyval = yyvsp[0]; }
+#line 2044 "pars0grm.cc"
     break;
 
   case 95:
-#line 335 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_share_token; }
-#line 2115 "pars0grm.cc" /* yacc.c:1646  */
+#line 354 "pars0grm.y"
+    { yyval = pars_update_statement_start(
+					FALSE,
+					static_cast<sym_node_t*>(yyvsp[-2]),
+					static_cast<col_assign_node_t*>(yyvsp[0])); }
+#line 2053 "pars0grm.cc"
     break;
 
   case 96:
-#line 339 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_asc_token; }
-#line 2121 "pars0grm.cc" /* yacc.c:1646  */
+#line 362 "pars0grm.y"
+    { yyval = pars_update_statement(
+					static_cast<upd_node_t*>(yyvsp[-1]),
+					NULL,
+					static_cast<que_node_t*>(yyvsp[0])); }
+#line 2062 "pars0grm.cc"
     break;
 
   case 97:
-#line 340 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_asc_token; }
-#line 2127 "pars0grm.cc" /* yacc.c:1646  */
+#line 370 "pars0grm.y"
+    { yyval = pars_update_statement(
+					static_cast<upd_node_t*>(yyvsp[-1]),
+					static_cast<sym_node_t*>(yyvsp[0]),
+					NULL); }
+#line 2071 "pars0grm.cc"
     break;
 
   case 98:
-#line 341 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_desc_token; }
-#line 2133 "pars0grm.cc" /* yacc.c:1646  */
+#line 378 "pars0grm.y"
+    { yyval = pars_update_statement_start(
+					TRUE,
+					static_cast<sym_node_t*>(yyvsp[0]), NULL); }
+#line 2079 "pars0grm.cc"
     break;
 
   case 99:
-#line 345 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2139 "pars0grm.cc" /* yacc.c:1646  */
+#line 385 "pars0grm.y"
+    { yyval = pars_update_statement(
+					static_cast<upd_node_t*>(yyvsp[-1]),
+					NULL,
+					static_cast<que_node_t*>(yyvsp[0])); }
+#line 2088 "pars0grm.cc"
     break;
 
   case 100:
-#line 347 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_order_by(
-					static_cast<sym_node_t*>((yyvsp[-1])),
-					static_cast<pars_res_word_t*>((yyvsp[0]))); }
-#line 2147 "pars0grm.cc" /* yacc.c:1646  */
+#line 393 "pars0grm.y"
+    { yyval = pars_update_statement(
+					static_cast<upd_node_t*>(yyvsp[-1]),
+					static_cast<sym_node_t*>(yyvsp[0]),
+					NULL); }
+#line 2097 "pars0grm.cc"
     break;
 
   case 101:
-#line 358 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_select_statement(
-					static_cast<sel_node_t*>((yyvsp[-6])),
-					static_cast<sym_node_t*>((yyvsp[-4])),
-					static_cast<que_node_t*>((yyvsp[-3])),
-					static_cast<pars_res_word_t*>((yyvsp[-2])),
-					static_cast<pars_res_word_t*>((yyvsp[-1])),
-					static_cast<order_node_t*>((yyvsp[0]))); }
-#line 2159 "pars0grm.cc" /* yacc.c:1646  */
+#line 401 "pars0grm.y"
+    { yyval = pars_assignment_statement(
+					static_cast<sym_node_t*>(yyvsp[-2]),
+					static_cast<que_node_t*>(yyvsp[0])); }
+#line 2105 "pars0grm.cc"
     break;
 
   case 102:
-#line 369 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]); }
-#line 2165 "pars0grm.cc" /* yacc.c:1646  */
+#line 409 "pars0grm.y"
+    { yyval = pars_elsif_element(yyvsp[-2], yyvsp[0]); }
+#line 2111 "pars0grm.cc"
     break;
 
   case 103:
-#line 374 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_insert_statement(
-					static_cast<sym_node_t*>((yyvsp[-4])), (yyvsp[-1]), NULL); }
-#line 2172 "pars0grm.cc" /* yacc.c:1646  */
+#line 413 "pars0grm.y"
+    { yyval = que_node_list_add_last(NULL, yyvsp[0]); }
+#line 2117 "pars0grm.cc"
     break;
 
   case 104:
-#line 377 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_insert_statement(
-					static_cast<sym_node_t*>((yyvsp[-1])),
-					NULL,
-					static_cast<sel_node_t*>((yyvsp[0]))); }
-#line 2181 "pars0grm.cc" /* yacc.c:1646  */
+#line 415 "pars0grm.y"
+    { yyval = que_node_list_add_last(yyvsp[-1], yyvsp[0]); }
+#line 2123 "pars0grm.cc"
     break;
 
   case 105:
-#line 384 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_column_assignment(
-					static_cast<sym_node_t*>((yyvsp[-2])),
-					static_cast<que_node_t*>((yyvsp[0]))); }
-#line 2189 "pars0grm.cc" /* yacc.c:1646  */
+#line 419 "pars0grm.y"
+    { yyval = NULL; }
+#line 2129 "pars0grm.cc"
     break;
 
   case 106:
-#line 390 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); }
-#line 2195 "pars0grm.cc" /* yacc.c:1646  */
+#line 421 "pars0grm.y"
+    { yyval = yyvsp[0]; }
+#line 2135 "pars0grm.cc"
     break;
 
   case 107:
-#line 392 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); }
-#line 2201 "pars0grm.cc" /* yacc.c:1646  */
+#line 422 "pars0grm.y"
+    { yyval = yyvsp[0]; }
+#line 2141 "pars0grm.cc"
     break;
 
   case 108:
-#line 398 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]); }
-#line 2207 "pars0grm.cc" /* yacc.c:1646  */
+#line 429 "pars0grm.y"
+    { yyval = pars_if_statement(yyvsp[-5], yyvsp[-3], yyvsp[-2]); }
+#line 2147 "pars0grm.cc"
     break;
 
   case 109:
-#line 404 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_update_statement_start(
-					FALSE,
-					static_cast<sym_node_t*>((yyvsp[-2])),
-					static_cast<col_assign_node_t*>((yyvsp[0]))); }
-#line 2216 "pars0grm.cc" /* yacc.c:1646  */
+#line 435 "pars0grm.y"
+    { yyval = pars_while_statement(yyvsp[-4], yyvsp[-2]); }
+#line 2153 "pars0grm.cc"
     break;
 
   case 110:
-#line 412 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_update_statement(
-					static_cast<upd_node_t*>((yyvsp[-1])),
-					NULL,
-					static_cast<que_node_t*>((yyvsp[0]))); }
-#line 2225 "pars0grm.cc" /* yacc.c:1646  */
+#line 443 "pars0grm.y"
+    { yyval = pars_for_statement(
+					static_cast<sym_node_t*>(yyvsp[-8]),
+					yyvsp[-6], yyvsp[-4], yyvsp[-2]); }
+#line 2161 "pars0grm.cc"
     break;
 
   case 111:
-#line 420 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_update_statement(
-					static_cast<upd_node_t*>((yyvsp[-1])),
-					static_cast<sym_node_t*>((yyvsp[0])),
-					NULL); }
-#line 2234 "pars0grm.cc" /* yacc.c:1646  */
+#line 449 "pars0grm.y"
+    { yyval = pars_exit_statement(); }
+#line 2167 "pars0grm.cc"
     break;
 
   case 112:
-#line 428 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_update_statement_start(
-					TRUE,
-					static_cast<sym_node_t*>((yyvsp[0])), NULL); }
-#line 2242 "pars0grm.cc" /* yacc.c:1646  */
+#line 453 "pars0grm.y"
+    { yyval = pars_return_statement(); }
+#line 2173 "pars0grm.cc"
     break;
 
   case 113:
-#line 435 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_update_statement(
-					static_cast<upd_node_t*>((yyvsp[-1])),
-					NULL,
-					static_cast<que_node_t*>((yyvsp[0]))); }
-#line 2251 "pars0grm.cc" /* yacc.c:1646  */
+#line 458 "pars0grm.y"
+    { yyval = pars_open_statement(
+						ROW_SEL_OPEN_CURSOR,
+						static_cast<sym_node_t*>(yyvsp[0])); }
+#line 2181 "pars0grm.cc"
     break;
 
   case 114:
-#line 443 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_update_statement(
-					static_cast<upd_node_t*>((yyvsp[-1])),
-					static_cast<sym_node_t*>((yyvsp[0])),
-					NULL); }
-#line 2260 "pars0grm.cc" /* yacc.c:1646  */
+#line 465 "pars0grm.y"
+    { yyval = pars_open_statement(
+						ROW_SEL_CLOSE_CURSOR,
+						static_cast<sym_node_t*>(yyvsp[0])); }
+#line 2189 "pars0grm.cc"
     break;
 
   case 115:
-#line 451 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_row_printf_statement(
-					static_cast<sel_node_t*>((yyvsp[0]))); }
-#line 2267 "pars0grm.cc" /* yacc.c:1646  */
+#line 472 "pars0grm.y"
+    { yyval = pars_fetch_statement(
+					static_cast<sym_node_t*>(yyvsp[-2]),
+					static_cast<sym_node_t*>(yyvsp[0]), NULL); }
+#line 2197 "pars0grm.cc"
     break;
 
   case 116:
-#line 457 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_assignment_statement(
-					static_cast<sym_node_t*>((yyvsp[-2])),
-					static_cast<que_node_t*>((yyvsp[0]))); }
-#line 2275 "pars0grm.cc" /* yacc.c:1646  */
+#line 476 "pars0grm.y"
+    { yyval = pars_fetch_statement(
+					static_cast<sym_node_t*>(yyvsp[-2]),
+					NULL,
+					static_cast<sym_node_t*>(yyvsp[0])); }
+#line 2206 "pars0grm.cc"
     break;
 
   case 117:
-#line 465 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_elsif_element((yyvsp[-2]), (yyvsp[0])); }
-#line 2281 "pars0grm.cc" /* yacc.c:1646  */
+#line 484 "pars0grm.y"
+    { yyval = pars_column_def(
+					static_cast<sym_node_t*>(yyvsp[-3]),
+					static_cast<pars_res_word_t*>(yyvsp[-2]),
+					static_cast<sym_node_t*>(yyvsp[-1]),
+					yyvsp[0]); }
+#line 2216 "pars0grm.cc"
     break;
 
   case 118:
-#line 469 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); }
-#line 2287 "pars0grm.cc" /* yacc.c:1646  */
+#line 492 "pars0grm.y"
+    { yyval = que_node_list_add_last(NULL, yyvsp[0]); }
+#line 2222 "pars0grm.cc"
     break;
 
   case 119:
-#line 471 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last((yyvsp[-1]), (yyvsp[0])); }
-#line 2293 "pars0grm.cc" /* yacc.c:1646  */
+#line 494 "pars0grm.y"
+    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); }
+#line 2228 "pars0grm.cc"
     break;
 
   case 120:
-#line 475 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2299 "pars0grm.cc" /* yacc.c:1646  */
+#line 498 "pars0grm.y"
+    { yyval = NULL; }
+#line 2234 "pars0grm.cc"
     break;
 
   case 121:
-#line 477 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]); }
-#line 2305 "pars0grm.cc" /* yacc.c:1646  */
+#line 500 "pars0grm.y"
+    { yyval = yyvsp[-1]; }
+#line 2240 "pars0grm.cc"
     break;
 
   case 122:
-#line 478 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]); }
-#line 2311 "pars0grm.cc" /* yacc.c:1646  */
+#line 504 "pars0grm.y"
+    { yyval = NULL; }
+#line 2246 "pars0grm.cc"
     break;
 
   case 123:
-#line 485 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_if_statement((yyvsp[-5]), (yyvsp[-3]), (yyvsp[-2])); }
-#line 2317 "pars0grm.cc" /* yacc.c:1646  */
+#line 506 "pars0grm.y"
+    { yyval = &pars_int_token;
+					/* pass any non-NULL pointer */ }
+#line 2253 "pars0grm.cc"
     break;
 
   case 124:
-#line 491 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_while_statement((yyvsp[-4]), (yyvsp[-2])); }
-#line 2323 "pars0grm.cc" /* yacc.c:1646  */
+#line 513 "pars0grm.y"
+    { yyval = pars_create_table(
+					static_cast<sym_node_t*>(yyvsp[-3]),
+					static_cast<sym_node_t*>(yyvsp[-1])); }
+#line 2261 "pars0grm.cc"
     break;
 
   case 125:
-#line 499 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_for_statement(
-					static_cast<sym_node_t*>((yyvsp[-8])),
-					(yyvsp[-6]), (yyvsp[-4]), (yyvsp[-2])); }
-#line 2331 "pars0grm.cc" /* yacc.c:1646  */
+#line 519 "pars0grm.y"
+    { yyval = que_node_list_add_last(NULL, yyvsp[0]); }
+#line 2267 "pars0grm.cc"
     break;
 
   case 126:
-#line 505 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_exit_statement(); }
-#line 2337 "pars0grm.cc" /* yacc.c:1646  */
+#line 521 "pars0grm.y"
+    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); }
+#line 2273 "pars0grm.cc"
     break;
 
   case 127:
-#line 509 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_return_statement(); }
-#line 2343 "pars0grm.cc" /* yacc.c:1646  */
+#line 525 "pars0grm.y"
+    { yyval = NULL; }
+#line 2279 "pars0grm.cc"
     break;
 
   case 128:
-#line 514 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_open_statement(
-						ROW_SEL_OPEN_CURSOR,
-						static_cast<sym_node_t*>((yyvsp[0]))); }
-#line 2351 "pars0grm.cc" /* yacc.c:1646  */
+#line 526 "pars0grm.y"
+    { yyval = &pars_unique_token; }
+#line 2285 "pars0grm.cc"
     break;
 
   case 129:
-#line 521 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_open_statement(
-						ROW_SEL_CLOSE_CURSOR,
-						static_cast<sym_node_t*>((yyvsp[0]))); }
-#line 2359 "pars0grm.cc" /* yacc.c:1646  */
+#line 530 "pars0grm.y"
+    { yyval = NULL; }
+#line 2291 "pars0grm.cc"
     break;
 
   case 130:
-#line 528 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_fetch_statement(
-					static_cast<sym_node_t*>((yyvsp[-2])),
-					static_cast<sym_node_t*>((yyvsp[0])), NULL); }
-#line 2367 "pars0grm.cc" /* yacc.c:1646  */
+#line 531 "pars0grm.y"
+    { yyval = &pars_clustered_token; }
+#line 2297 "pars0grm.cc"
     break;
 
   case 131:
-#line 532 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_fetch_statement(
-					static_cast<sym_node_t*>((yyvsp[-2])),
-					NULL,
-					static_cast<sym_node_t*>((yyvsp[0]))); }
-#line 2376 "pars0grm.cc" /* yacc.c:1646  */
+#line 540 "pars0grm.y"
+    { yyval = pars_create_index(
+					static_cast<pars_res_word_t*>(yyvsp[-8]),
+					static_cast<pars_res_word_t*>(yyvsp[-7]),
+					static_cast<sym_node_t*>(yyvsp[-5]),
+					static_cast<sym_node_t*>(yyvsp[-3]),
+					static_cast<sym_node_t*>(yyvsp[-1])); }
+#line 2308 "pars0grm.cc"
     break;
 
   case 132:
-#line 540 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_column_def(
-					static_cast<sym_node_t*>((yyvsp[-4])),
-					static_cast<pars_res_word_t*>((yyvsp[-3])),
-					static_cast<sym_node_t*>((yyvsp[-2])),
-					(yyvsp[-1]), (yyvsp[0])); }
-#line 2386 "pars0grm.cc" /* yacc.c:1646  */
+#line 549 "pars0grm.y"
+    { yyval = yyvsp[0]; }
+#line 2314 "pars0grm.cc"
     break;
 
   case 133:
-#line 548 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); }
-#line 2392 "pars0grm.cc" /* yacc.c:1646  */
+#line 550 "pars0grm.y"
+    { yyval = yyvsp[0]; }
+#line 2320 "pars0grm.cc"
     break;
 
   case 134:
-#line 550 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); }
-#line 2398 "pars0grm.cc" /* yacc.c:1646  */
+#line 555 "pars0grm.y"
+    { yyval = pars_commit_statement(); }
+#line 2326 "pars0grm.cc"
     break;
 
   case 135:
-#line 554 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2404 "pars0grm.cc" /* yacc.c:1646  */
+#line 560 "pars0grm.y"
+    { yyval = pars_rollback_statement(); }
+#line 2332 "pars0grm.cc"
     break;
 
   case 136:
-#line 556 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[-1]); }
-#line 2410 "pars0grm.cc" /* yacc.c:1646  */
+#line 564 "pars0grm.y"
+    { yyval = &pars_int_token; }
+#line 2338 "pars0grm.cc"
     break;
 
   case 137:
-#line 560 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2416 "pars0grm.cc" /* yacc.c:1646  */
+#line 565 "pars0grm.y"
+    { yyval = &pars_bigint_token; }
+#line 2344 "pars0grm.cc"
     break;
 
   case 138:
-#line 562 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_int_token;
-					/* pass any non-NULL pointer */ }
-#line 2423 "pars0grm.cc" /* yacc.c:1646  */
+#line 566 "pars0grm.y"
+    { yyval = &pars_char_token; }
+#line 2350 "pars0grm.cc"
     break;
 
   case 139:
-#line 567 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2429 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 140:
-#line 569 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_int_token;
-					/* pass any non-NULL pointer */ }
-#line 2436 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 141:
-#line 574 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2442 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 142:
-#line 575 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_int_token;
-					/* pass any non-NULL pointer */ }
-#line 2449 "pars0grm.cc" /* yacc.c:1646  */
+#line 571 "pars0grm.y"
+    { yyval = pars_variable_declaration(
+					static_cast<sym_node_t*>(yyvsp[-2]),
+					static_cast<pars_res_word_t*>(yyvsp[-1])); }
+#line 2358 "pars0grm.cc"
     break;
 
   case 143:
-#line 580 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2455 "pars0grm.cc" /* yacc.c:1646  */
+#line 585 "pars0grm.y"
+    { yyval = pars_cursor_declaration(
+					static_cast<sym_node_t*>(yyvsp[-3]),
+					static_cast<sel_node_t*>(yyvsp[-1])); }
+#line 2366 "pars0grm.cc"
     break;
 
   case 144:
-#line 582 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]); }
-#line 2461 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 145:
-#line 589 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_create_table(
-					static_cast<sym_node_t*>((yyvsp[-5])),
-					static_cast<sym_node_t*>((yyvsp[-3])),
-					static_cast<sym_node_t*>((yyvsp[-1])),
-					static_cast<sym_node_t*>((yyvsp[0]))); }
-#line 2471 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 146:
-#line 597 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); }
-#line 2477 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 147:
-#line 599 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); }
-#line 2483 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 148:
-#line 603 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2489 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 149:
-#line 604 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_unique_token; }
-#line 2495 "pars0grm.cc" /* yacc.c:1646  */
+#line 592 "pars0grm.y"
+    { yyval = pars_function_declaration(
+					static_cast<sym_node_t*>(yyvsp[-1])); }
+#line 2373 "pars0grm.cc"
     break;
 
   case 150:
-#line 608 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2501 "pars0grm.cc" /* yacc.c:1646  */
+#line 614 "pars0grm.y"
+    { yyval = pars_procedure_definition(
+					static_cast<sym_node_t*>(yyvsp[-8]), yyvsp[-1]); }
+#line 2380 "pars0grm.cc"
     break;
 
-  case 151:
-#line 609 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_clustered_token; }
-#line 2507 "pars0grm.cc" /* yacc.c:1646  */
-    break;
 
-  case 152:
-#line 618 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_create_index(
-					static_cast<pars_res_word_t*>((yyvsp[-8])),
-					static_cast<pars_res_word_t*>((yyvsp[-7])),
-					static_cast<sym_node_t*>((yyvsp[-5])),
-					static_cast<sym_node_t*>((yyvsp[-3])),
-					static_cast<sym_node_t*>((yyvsp[-1]))); }
-#line 2518 "pars0grm.cc" /* yacc.c:1646  */
-    break;
+#line 2384 "pars0grm.cc"
 
-  case 153:
-#line 627 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]); }
-#line 2524 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 154:
-#line 628 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = (yyvsp[0]); }
-#line 2530 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 155:
-#line 633 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_commit_statement(); }
-#line 2536 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 156:
-#line 638 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_rollback_statement(); }
-#line 2542 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 157:
-#line 642 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_int_token; }
-#line 2548 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 158:
-#line 643 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_bigint_token; }
-#line 2554 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 159:
-#line 644 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_char_token; }
-#line 2560 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 160:
-#line 645 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_binary_token; }
-#line 2566 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 161:
-#line 646 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = &pars_blob_token; }
-#line 2572 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 162:
-#line 651 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_parameter_declaration(
-					static_cast<sym_node_t*>((yyvsp[-2])),
-					PARS_INPUT,
-					static_cast<pars_res_word_t*>((yyvsp[0]))); }
-#line 2581 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 163:
-#line 656 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_parameter_declaration(
-					static_cast<sym_node_t*>((yyvsp[-2])),
-					PARS_OUTPUT,
-					static_cast<pars_res_word_t*>((yyvsp[0]))); }
-#line 2590 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 164:
-#line 663 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = NULL; }
-#line 2596 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 165:
-#line 664 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); }
-#line 2602 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 166:
-#line 666 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); }
-#line 2608 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 167:
-#line 671 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_variable_declaration(
-					static_cast<sym_node_t*>((yyvsp[-2])),
-					static_cast<pars_res_word_t*>((yyvsp[-1]))); }
-#line 2616 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 171:
-#line 685 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_cursor_declaration(
-					static_cast<sym_node_t*>((yyvsp[-3])),
-					static_cast<sel_node_t*>((yyvsp[-1]))); }
-#line 2624 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 172:
-#line 692 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_function_declaration(
-					static_cast<sym_node_t*>((yyvsp[-1]))); }
-#line 2631 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-  case 178:
-#line 714 "pars0grm.y" /* yacc.c:1646  */
-    { (yyval) = pars_procedure_definition(
-					static_cast<sym_node_t*>((yyvsp[-9])),
-					static_cast<sym_node_t*>((yyvsp[-7])),
-					(yyvsp[-1])); }
-#line 2640 "pars0grm.cc" /* yacc.c:1646  */
-    break;
-
-
-#line 2644 "pars0grm.cc" /* yacc.c:1646  */
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -2665,14 +2406,13 @@ yyreduce:
   /* Now 'shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
      number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTOKENS];
+  {
+    const int yylhs = yyr1[yyn] - YYNTOKENS;
+    const int yyi = yypgoto[yylhs] + *yyssp;
+    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+               ? yytable[yyi]
+               : yydefgoto[yylhs]);
+  }
 
   goto yynewstate;
 
@@ -2755,12 +2495,10 @@ yyerrlab:
 | yyerrorlab -- error raised explicitly by YYERROR.  |
 `---------------------------------------------------*/
 yyerrorlab:
-
-  /* Pacify compilers like GCC when the user code never invokes
-     YYERROR and the label yyerrorlab therefore never appears in user
-     code.  */
-  if (/*CONSTCOND*/ 0)
-     goto yyerrorlab;
+  /* Pacify compilers when the user code never invokes YYERROR and the
+     label yyerrorlab therefore never appears in user code.  */
+  if (0)
+    YYERROR;
 
   /* Do not reclaim the symbols of the rule whose action triggered
      this YYERROR.  */
@@ -2822,6 +2560,7 @@ yyacceptlab:
   yyresult = 0;
   goto yyreturn;
 
+
 /*-----------------------------------.
 | yyabortlab -- YYABORT comes here.  |
 `-----------------------------------*/
@@ -2829,6 +2568,7 @@ yyabortlab:
   yyresult = 1;
   goto yyreturn;
 
+
 #if !defined yyoverflow || YYERROR_VERBOSE
 /*-------------------------------------------------.
 | yyexhaustedlab -- memory exhaustion comes here.  |
@@ -2839,6 +2579,10 @@ yyexhaustedlab:
   /* Fall through.  */
 #endif
 
+
+/*-----------------------------------------------------.
+| yyreturn -- parsing is finished, return the result.  |
+`-----------------------------------------------------*/
 yyreturn:
   if (yychar != YYEMPTY)
     {
@@ -2868,5 +2612,5 @@ yyreturn:
 #endif
   return yyresult;
 }
-#line 720 "pars0grm.y" /* yacc.c:1906  */
+#line 618 "pars0grm.y"
 
diff --git a/storage/innobase/pars/pars0grm.y b/storage/innobase/pars/pars0grm.y
index 27638e06a66..625ed41bbd4 100644
--- a/storage/innobase/pars/pars0grm.y
+++ b/storage/innobase/pars/pars0grm.y
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1997, 2014, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, MariaDB Corporation.
+Copyright (c) 2017, 2019, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -58,11 +58,7 @@ yylex(void);
 %token PARS_NE_TOKEN
 %token PARS_PROCEDURE_TOKEN
 %token PARS_IN_TOKEN
-%token PARS_OUT_TOKEN
-%token PARS_BINARY_TOKEN
-%token PARS_BLOB_TOKEN
 %token PARS_INT_TOKEN
-%token PARS_FLOAT_TOKEN
 %token PARS_CHAR_TOKEN
 %token PARS_IS_TOKEN
 %token PARS_BEGIN_TOKEN
@@ -75,14 +71,11 @@ yylex(void);
 %token PARS_WHILE_TOKEN
 %token PARS_RETURN_TOKEN
 %token PARS_SELECT_TOKEN
-%token PARS_SUM_TOKEN
 %token PARS_COUNT_TOKEN
-%token PARS_DISTINCT_TOKEN
 %token PARS_FROM_TOKEN
 %token PARS_WHERE_TOKEN
 %token PARS_FOR_TOKEN
 %token PARS_DDOT_TOKEN
-%token PARS_READ_TOKEN
 %token PARS_ORDER_TOKEN
 %token PARS_BY_TOKEN
 %token PARS_ASC_TOKEN
@@ -109,25 +102,14 @@ yylex(void);
 %token PARS_FETCH_TOKEN
 %token PARS_CLOSE_TOKEN
 %token PARS_NOTFOUND_TOKEN
-%token PARS_TO_CHAR_TOKEN
-%token PARS_TO_NUMBER_TOKEN
 %token PARS_TO_BINARY_TOKEN
-%token PARS_BINARY_TO_NUMBER_TOKEN
 %token PARS_SUBSTR_TOKEN
-%token PARS_REPLSTR_TOKEN
 %token PARS_CONCAT_TOKEN
 %token PARS_INSTR_TOKEN
 %token PARS_LENGTH_TOKEN
-%token PARS_SYSDATE_TOKEN
-%token PARS_PRINTF_TOKEN
-%token PARS_ASSERT_TOKEN
-%token PARS_RND_TOKEN
-%token PARS_RND_STR_TOKEN
-%token PARS_ROW_PRINTF_TOKEN
 %token PARS_COMMIT_TOKEN
 %token PARS_ROLLBACK_TOKEN
 %token PARS_WORK_TOKEN
-%token PARS_UNSIGNED_TOKEN
 %token PARS_EXIT_TOKEN
 %token PARS_FUNCTION_TOKEN
 %token PARS_LOCK_TOKEN
@@ -139,8 +121,6 @@ yylex(void);
 %token PARS_LIKE_TOKEN_SUFFIX
 %token PARS_LIKE_TOKEN_SUBSTR
 %token PARS_TABLE_NAME_TOKEN
-%token PARS_COMPACT_TOKEN
-%token PARS_BLOCK_SIZE_TOKEN
 %token PARS_BIGINT_TOKEN
 
 %left PARS_AND_TOKEN PARS_OR_TOKEN
@@ -161,7 +141,6 @@ top_statement:
 
 statement:
 	stored_procedure_call
-	| predefined_procedure_call ';'
 	| while_statement ';'
 	| for_statement ';'
 	| exit_statement ';'
@@ -170,7 +149,6 @@ statement:
 	| assignment_statement ';'
 	| select_statement ';'
 	| insert_statement ';'
-	| row_printf_statement ';'
 	| delete_statement_searched ';'
 	| delete_statement_positioned ';'
 	| update_statement_searched ';'
@@ -223,18 +201,11 @@ exp:
 ;
 
 function_name:
-	PARS_TO_CHAR_TOKEN	{ $$ = &pars_to_char_token; }
-	| PARS_TO_NUMBER_TOKEN	{ $$ = &pars_to_number_token; }
-	| PARS_TO_BINARY_TOKEN	{ $$ = &pars_to_binary_token; }
-	| PARS_BINARY_TO_NUMBER_TOKEN
-				{ $$ = &pars_binary_to_number_token; }
+	PARS_TO_BINARY_TOKEN	{ $$ = &pars_to_binary_token; }
 	| PARS_SUBSTR_TOKEN	{ $$ = &pars_substr_token; }
 	| PARS_CONCAT_TOKEN	{ $$ = &pars_concat_token; }
 	| PARS_INSTR_TOKEN	{ $$ = &pars_instr_token; }
 	| PARS_LENGTH_TOKEN	{ $$ = &pars_length_token; }
-	| PARS_SYSDATE_TOKEN	{ $$ = &pars_sysdate_token; }
-	| PARS_RND_TOKEN	{ $$ = &pars_rnd_token; }
-	| PARS_RND_STR_TOKEN	{ $$ = &pars_rnd_str_token; }
 ;
 
 question_mark_list:
@@ -249,17 +220,6 @@ stored_procedure_call:
 					static_cast<sym_node_t*>($2)); }
 ;
 
-predefined_procedure_call:
-	predefined_procedure_name '(' exp_list ')'
-				{ $$ = pars_procedure_call($1, $3); }
-;
-
-predefined_procedure_name:
-	PARS_REPLSTR_TOKEN	{ $$ = &pars_replstr_token; }
-	| PARS_PRINTF_TOKEN	{ $$ = &pars_printf_token; }
-	| PARS_ASSERT_TOKEN	{ $$ = &pars_assert_token; }
-;
-
 user_function_call:
 	PARS_ID_TOKEN '(' ')'	{ $$ = $1; }
 ;
@@ -287,19 +247,9 @@ select_item:
 	exp			{ $$ = $1; }
 	| PARS_COUNT_TOKEN '(' '*' ')'
 				{ $$ = pars_func(&pars_count_token,
-				          que_node_list_add_last(NULL,
+					  que_node_list_add_last(NULL,
 					    sym_tab_add_int_lit(
 						pars_sym_tab_global, 1))); }
-	| PARS_COUNT_TOKEN '(' PARS_DISTINCT_TOKEN PARS_ID_TOKEN ')'
-				{ $$ = pars_func(&pars_count_token,
-					    que_node_list_add_last(NULL,
-						pars_func(&pars_distinct_token,
-						     que_node_list_add_last(
-								NULL, $4)))); }
-	| PARS_SUM_TOKEN '(' exp ')'
-				{ $$ = pars_func(&pars_sum_token,
-						que_node_list_add_last(NULL,
-									$3)); }
 ;
 
 select_item_list:
@@ -446,12 +396,6 @@ delete_statement_positioned:
 					NULL); }
 ;
 
-row_printf_statement:
-	PARS_ROW_PRINTF_TOKEN select_statement
-				{ $$ = pars_row_printf_statement(
-					static_cast<sel_node_t*>($2)); }
-;
-
 assignment_statement:
 	PARS_ID_TOKEN PARS_ASSIGN_TOKEN exp
 				{ $$ = pars_assignment_statement(
@@ -536,12 +480,12 @@ fetch_statement:
 ;
 
 column_def:
-	PARS_ID_TOKEN type_name	opt_column_len opt_unsigned opt_not_null
+	PARS_ID_TOKEN type_name	opt_column_len opt_not_null
 				{ $$ = pars_column_def(
 					static_cast<sym_node_t*>($1),
 					static_cast<pars_res_word_t*>($2),
 					static_cast<sym_node_t*>($3),
-					$4, $5); }
+					$4); }
 ;
 
 column_def_list:
@@ -556,13 +500,6 @@ opt_column_len:
 				{ $$ = $2; }
 ;
 
-opt_unsigned:
-	/* Nothing */		{ $$ = NULL; }
-	| PARS_UNSIGNED_TOKEN
-				{ $$ = &pars_int_token;
-					/* pass any non-NULL pointer */ }
-;
-
 opt_not_null:
 	/* Nothing */		{ $$ = NULL; }
 	| PARS_NOT_TOKEN PARS_NULL_LIT
@@ -570,27 +507,12 @@ opt_not_null:
 					/* pass any non-NULL pointer */ }
 ;
 
-compact:
-	/* Nothing */		{ $$ = NULL; }
-	| PARS_COMPACT_TOKEN	{ $$ = &pars_int_token;
-					/* pass any non-NULL pointer */ }
-;
-
-block_size:
-	/* Nothing */		{ $$ = NULL; }
-	| PARS_BLOCK_SIZE_TOKEN	'=' PARS_INT_LIT
-			{ $$ = $3; }
-;
-
 create_table:
 	PARS_CREATE_TOKEN PARS_TABLE_TOKEN
 	table_name '(' column_def_list ')'
-	compact block_size
 				{ $$ = pars_create_table(
 					static_cast<sym_node_t*>($3),
-					static_cast<sym_node_t*>($5),
-					static_cast<sym_node_t*>($7),
-					static_cast<sym_node_t*>($8)); }
+					static_cast<sym_node_t*>($5)); }
 ;
 
 column_list:
@@ -642,28 +564,6 @@ type_name:
 	PARS_INT_TOKEN		{ $$ = &pars_int_token; }
 	| PARS_BIGINT_TOKEN	{ $$ = &pars_bigint_token; }
 	| PARS_CHAR_TOKEN	{ $$ = &pars_char_token; }
-	| PARS_BINARY_TOKEN	{ $$ = &pars_binary_token; }
-	| PARS_BLOB_TOKEN	{ $$ = &pars_blob_token; }
-;
-
-parameter_declaration:
-	PARS_ID_TOKEN PARS_IN_TOKEN type_name
-				{ $$ = pars_parameter_declaration(
-					static_cast<sym_node_t*>($1),
-					PARS_INPUT,
-					static_cast<pars_res_word_t*>($3)); }
-	| PARS_ID_TOKEN PARS_OUT_TOKEN type_name
-				{ $$ = pars_parameter_declaration(
-					static_cast<sym_node_t*>($1),
-					PARS_OUTPUT,
-					static_cast<pars_res_word_t*>($3)); }
-;
-
-parameter_declaration_list:
-	/* Nothing */		{ $$ = NULL; }
-	| parameter_declaration	{ $$ = que_node_list_add_last(NULL, $1); }
-	| parameter_declaration_list ',' parameter_declaration
-				{ $$ = que_node_list_add_last($1, $3); }
 ;
 
 variable_declaration:
@@ -705,16 +605,14 @@ declaration_list:
 ;
 
 procedure_definition:
-	PARS_PROCEDURE_TOKEN PARS_ID_TOKEN '(' parameter_declaration_list ')'
+	PARS_PROCEDURE_TOKEN PARS_ID_TOKEN '(' ')'
 	PARS_IS_TOKEN
 	variable_declaration_list
 	declaration_list
 	PARS_BEGIN_TOKEN
 	statement_list
 	PARS_END_TOKEN		{ $$ = pars_procedure_definition(
-					static_cast<sym_node_t*>($2),
-					static_cast<sym_node_t*>($4),
-					$10); }
+					static_cast<sym_node_t*>($2), $9); }
 ;
 
 %%
diff --git a/storage/innobase/pars/pars0lex.l b/storage/innobase/pars/pars0lex.l
index 2d0e56f400d..8b2df6b7940 100644
--- a/storage/innobase/pars/pars0lex.l
+++ b/storage/innobase/pars/pars0lex.l
@@ -249,30 +249,10 @@ In the state 'id', only two actions are possible (defined below). */
 			return(PARS_IN_TOKEN);
 }
 
-"OUT"		{
-			return(PARS_OUT_TOKEN);
-}
-
-"BINARY"	{
-			return(PARS_BINARY_TOKEN);
-}
-
-"BLOB"		{
-			return(PARS_BLOB_TOKEN);
-}
-
 "INT"		{
 			return(PARS_INT_TOKEN);
 }
 
-"INTEGER"	{
-			return(PARS_INT_TOKEN);
-}
-
-"FLOAT"		{
-			return(PARS_FLOAT_TOKEN);
-}
-
 "CHAR"		{
 			return(PARS_CHAR_TOKEN);
 }
@@ -321,18 +301,10 @@ In the state 'id', only two actions are possible (defined below). */
 			return(PARS_SELECT_TOKEN);
 }
 
-"SUM"		{
-			return(PARS_SUM_TOKEN);
-}
-
 "COUNT"		{
 			return(PARS_COUNT_TOKEN);
 }
 
-"DISTINCT"	{
-			return(PARS_DISTINCT_TOKEN);
-}
-
 "FROM"		{
 			return(PARS_FROM_TOKEN);
 }
@@ -345,10 +317,6 @@ In the state 'id', only two actions are possible (defined below). */
 			return(PARS_FOR_TOKEN);
 }
 
-"READ"		{
-			return(PARS_READ_TOKEN);
-}
-
 "ORDER"		{
 			return(PARS_ORDER_TOKEN);
 }
@@ -405,14 +373,6 @@ In the state 'id', only two actions are possible (defined below). */
 			return(PARS_TABLE_TOKEN);
 }
 
-"COMPACT"	{
-			return(PARS_COMPACT_TOKEN);
-}
-
-"BLOCK_SIZE"	{
-			return(PARS_BLOCK_SIZE_TOKEN);
-}
-
 "INDEX"		{
 			return(PARS_INDEX_TOKEN);
 }
@@ -453,30 +413,14 @@ In the state 'id', only two actions are possible (defined below). */
 			return(PARS_NOTFOUND_TOKEN);
 }
 
-"TO_CHAR"	{
-			return(PARS_TO_CHAR_TOKEN);
-}
-
-"TO_NUMBER"	{
-			return(PARS_TO_NUMBER_TOKEN);
-}
-
 "TO_BINARY"	{
 			return(PARS_TO_BINARY_TOKEN);
 }
 
-"BINARY_TO_NUMBER" {
-			return(PARS_BINARY_TO_NUMBER_TOKEN);
-}
-
 "SUBSTR"	{
 			return(PARS_SUBSTR_TOKEN);
 }
 
-"REPLSTR"	{
-			return(PARS_REPLSTR_TOKEN);
-}
-
 "CONCAT"	{
 			return(PARS_CONCAT_TOKEN);
 }
@@ -489,30 +433,6 @@ In the state 'id', only two actions are possible (defined below). */
 			return(PARS_LENGTH_TOKEN);
 }
 
-"SYSDATE"	{
-			return(PARS_SYSDATE_TOKEN);
-}
-
-"PRINTF"	{
-			return(PARS_PRINTF_TOKEN);
-}
-
-"ASSERT"	{
-			return(PARS_ASSERT_TOKEN);
-}
-
-"RND"		{
-			return(PARS_RND_TOKEN);
-}
-
-"RND_STR"	{
-			return(PARS_RND_STR_TOKEN);
-}
-
-"ROW_PRINTF"	{
-			return(PARS_ROW_PRINTF_TOKEN);
-}
-
 "COMMIT"	{
 			return(PARS_COMMIT_TOKEN);
 }
@@ -525,10 +445,6 @@ In the state 'id', only two actions are possible (defined below). */
 			return(PARS_WORK_TOKEN);
 }
 
-"UNSIGNED"	{
-			return(PARS_UNSIGNED_TOKEN);
-}
-
 "EXIT"		{
 			return(PARS_EXIT_TOKEN);
 }
diff --git a/storage/innobase/pars/pars0pars.cc b/storage/innobase/pars/pars0pars.cc
index b57753caa16..43f089e3bf7 100644
--- a/storage/innobase/pars/pars0pars.cc
+++ b/storage/innobase/pars/pars0pars.cc
@@ -50,29 +50,15 @@ sym_tab_t*	pars_sym_tab_global;
 /* Global variables used to denote certain reserved words, used in
 constructing the parsing tree */
 
-pars_res_word_t	pars_to_char_token = {PARS_TO_CHAR_TOKEN};
-pars_res_word_t	pars_to_number_token = {PARS_TO_NUMBER_TOKEN};
 pars_res_word_t	pars_to_binary_token = {PARS_TO_BINARY_TOKEN};
-pars_res_word_t	pars_binary_to_number_token = {PARS_BINARY_TO_NUMBER_TOKEN};
 pars_res_word_t	pars_substr_token = {PARS_SUBSTR_TOKEN};
-pars_res_word_t	pars_replstr_token = {PARS_REPLSTR_TOKEN};
 pars_res_word_t	pars_concat_token = {PARS_CONCAT_TOKEN};
 pars_res_word_t	pars_instr_token = {PARS_INSTR_TOKEN};
 pars_res_word_t	pars_length_token = {PARS_LENGTH_TOKEN};
-pars_res_word_t	pars_sysdate_token = {PARS_SYSDATE_TOKEN};
-pars_res_word_t	pars_printf_token = {PARS_PRINTF_TOKEN};
-pars_res_word_t	pars_assert_token = {PARS_ASSERT_TOKEN};
-pars_res_word_t	pars_rnd_token = {PARS_RND_TOKEN};
-pars_res_word_t	pars_rnd_str_token = {PARS_RND_STR_TOKEN};
 pars_res_word_t	pars_count_token = {PARS_COUNT_TOKEN};
-pars_res_word_t	pars_sum_token = {PARS_SUM_TOKEN};
-pars_res_word_t	pars_distinct_token = {PARS_DISTINCT_TOKEN};
-pars_res_word_t	pars_binary_token = {PARS_BINARY_TOKEN};
-pars_res_word_t	pars_blob_token = {PARS_BLOB_TOKEN};
 pars_res_word_t	pars_int_token = {PARS_INT_TOKEN};
 pars_res_word_t	pars_bigint_token = {PARS_BIGINT_TOKEN};
 pars_res_word_t	pars_char_token = {PARS_CHAR_TOKEN};
-pars_res_word_t	pars_float_token = {PARS_FLOAT_TOKEN};
 pars_res_word_t	pars_update_token = {PARS_UPDATE_TOKEN};
 pars_res_word_t	pars_asc_token = {PARS_ASC_TOKEN};
 pars_res_word_t	pars_desc_token = {PARS_DESC_TOKEN};
@@ -195,24 +181,15 @@ pars_func_get_class(
 	case PARS_AND_TOKEN: case PARS_OR_TOKEN: case PARS_NOT_TOKEN:
 		return(PARS_FUNC_LOGICAL);
 
-	case PARS_COUNT_TOKEN: case PARS_SUM_TOKEN:
+	case PARS_COUNT_TOKEN:
 		return(PARS_FUNC_AGGREGATE);
 
-	case PARS_TO_CHAR_TOKEN:
-	case PARS_TO_NUMBER_TOKEN:
 	case PARS_TO_BINARY_TOKEN:
-	case PARS_BINARY_TO_NUMBER_TOKEN:
 	case PARS_SUBSTR_TOKEN:
 	case PARS_CONCAT_TOKEN:
 	case PARS_LENGTH_TOKEN:
 	case PARS_INSTR_TOKEN:
-	case PARS_SYSDATE_TOKEN:
 	case PARS_NOTFOUND_TOKEN:
-	case PARS_PRINTF_TOKEN:
-	case PARS_ASSERT_TOKEN:
-	case PARS_RND_TOKEN:
-	case PARS_RND_STR_TOKEN:
-	case PARS_REPLSTR_TOKEN:
 		return(PARS_FUNC_PREDEFINED);
 
 	default:
@@ -499,7 +476,6 @@ pars_resolve_func_data_type(
 	arg = node->args;
 
 	switch (node->func) {
-	case PARS_SUM_TOKEN:
 	case '+': case '-': case '*': case '/':
 		/* Inherit the data type from the first argument (which must
 		not be the SQL null literal whose type is DATA_ERROR) */
@@ -516,13 +492,6 @@ pars_resolve_func_data_type(
 		dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4);
 		break;
 
-	case PARS_TO_CHAR_TOKEN:
-	case PARS_RND_STR_TOKEN:
-		ut_a(dtype_get_mtype(que_node_get_data_type(arg)) == DATA_INT);
-		dtype_set(que_node_get_data_type(node), DATA_VARCHAR,
-			  DATA_ENGLISH, 0);
-		break;
-
 	case PARS_TO_BINARY_TOKEN:
 		if (dtype_get_mtype(que_node_get_data_type(arg)) == DATA_INT) {
 			dtype_set(que_node_get_data_type(node), DATA_VARCHAR,
@@ -533,19 +502,12 @@ pars_resolve_func_data_type(
 		}
 		break;
 
-	case PARS_TO_NUMBER_TOKEN:
-	case PARS_BINARY_TO_NUMBER_TOKEN:
 	case PARS_LENGTH_TOKEN:
 	case PARS_INSTR_TOKEN:
 		ut_a(pars_is_string_type(que_node_get_data_type(arg)->mtype));
 		dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4);
 		break;
 
-	case PARS_SYSDATE_TOKEN:
-		ut_a(arg == NULL);
-		dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4);
-		break;
-
 	case PARS_SUBSTR_TOKEN:
 	case PARS_CONCAT_TOKEN:
 		ut_a(pars_is_string_type(que_node_get_data_type(arg)->mtype));
@@ -566,11 +528,6 @@ pars_resolve_func_data_type(
 		dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4);
 		break;
 
-	case PARS_RND_TOKEN:
-		ut_a(dtype_get_mtype(que_node_get_data_type(arg)) == DATA_INT);
-		dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4);
-		break;
-
 	case PARS_LIKE_TOKEN_EXACT:
 	case PARS_LIKE_TOKEN_PREFIX:
 	case PARS_LIKE_TOKEN_SUFFIX:
@@ -1355,9 +1312,7 @@ pars_set_dfield_type(
 	pars_res_word_t*	type,		/*!< in: pointer to a type
 						token */
 	ulint			len,		/*!< in: length, or 0 */
-	ibool			is_unsigned,	/*!< in: if TRUE, column is
-						UNSIGNED. */
-	ibool			is_not_null)	/*!< in: if TRUE, column is
+	bool			is_not_null)	/*!< in: whether the column is
 						NOT NULL. */
 {
 	ulint flags = 0;
@@ -1366,10 +1321,6 @@ pars_set_dfield_type(
 		flags |= DATA_NOT_NULL;
 	}
 
-	if (is_unsigned) {
-		flags |= DATA_UNSIGNED;
-	}
-
 	if (type == &pars_bigint_token) {
 		ut_a(len == 0);
 
@@ -1384,16 +1335,6 @@ pars_set_dfield_type(
 
 		dtype_set(dfield_get_type(dfield), DATA_VARCHAR,
 			  DATA_ENGLISH | flags, len);
-	} else if (type == &pars_binary_token) {
-		ut_a(len != 0);
-
-		dtype_set(dfield_get_type(dfield), DATA_FIXBINARY,
-			  DATA_BINARY_TYPE | flags, len);
-	} else if (type == &pars_blob_token) {
-		ut_a(len == 0);
-
-		dtype_set(dfield_get_type(dfield), DATA_BLOB,
-			  DATA_BINARY_TYPE | flags, 0);
 	} else {
 		ut_error;
 	}
@@ -1414,28 +1355,7 @@ pars_variable_declaration(
 
 	node->param_type = PARS_NOT_PARAM;
 
-	pars_set_dfield_type(que_node_get_val(node), type, 0, FALSE, FALSE);
-
-	return(node);
-}
-
-/*********************************************************************//**
-Parses a procedure parameter declaration.
-@return own: symbol table node of type SYM_VAR */
-sym_node_t*
-pars_parameter_declaration(
-/*=======================*/
-	sym_node_t*	node,	/*!< in: symbol table node allocated for the
-				id of the parameter */
-	ulint		param_type,
-				/*!< in: PARS_INPUT or PARS_OUTPUT */
-	pars_res_word_t* type)	/*!< in: pointer to a type token */
-{
-	ut_a((param_type == PARS_INPUT) || (param_type == PARS_OUTPUT));
-
-	pars_variable_declaration(node, type);
-
-	node->param_type = param_type;
+	pars_set_dfield_type(que_node_get_val(node), type, 0, false);
 
 	return(node);
 }
@@ -1821,8 +1741,6 @@ pars_column_def(
 	pars_res_word_t*	type,		/*!< in: data type */
 	sym_node_t*		len,		/*!< in: length of column, or
 						NULL */
-	void*			is_unsigned,	/*!< in: if not NULL, column
-						is of type UNSIGNED. */
 	void*			is_not_null)	/*!< in: if not NULL, column
 						is of type NOT NULL. */
 {
@@ -1835,7 +1753,7 @@ pars_column_def(
 	}
 
 	pars_set_dfield_type(que_node_get_val(sym_node), type, len2,
-			     is_unsigned != NULL, is_not_null != NULL);
+			     is_not_null != NULL);
 
 	return(sym_node);
 }
@@ -1848,9 +1766,7 @@ pars_create_table(
 /*==============*/
 	sym_node_t*	table_sym,	/*!< in: table name node in the symbol
 					table */
-	sym_node_t*	column_defs,	/*!< in: list of column names */
-	sym_node_t*	compact,	/* in: non-NULL if COMPACT table. */
-	sym_node_t*	block_size)	/* in: block size (can be NULL) */
+	sym_node_t*	column_defs)	/*!< in: list of column names */
 {
 	dict_table_t*	table;
 	sym_node_t*	column;
@@ -1858,57 +1774,11 @@ pars_create_table(
 	const dtype_t*	dtype;
 	ulint		n_cols;
 	ulint		flags = 0;
-	ulint		flags2 = 0;
-
-	if (compact != NULL) {
-
-		/* System tables currently only use the REDUNDANT row
-		format therefore the check for srv_file_per_table should be
-		safe for now. */
-
-		flags |= DICT_TF_COMPACT;
-
-		/* FIXME: Ideally this should be part of the SQL syntax
-		or use some other mechanism. We want to reduce dependency
-		on global variables. There is an inherent race here but
-		that has always existed around this variable. */
-		if (srv_file_per_table) {
-			flags2 |= DICT_TF2_USE_FILE_PER_TABLE;
-		}
-	}
-
-	if (block_size != NULL) {
-		ulint		size;
-		dfield_t*	dfield;
+	ulint		flags2 = DICT_TF2_FTS_AUX_HEX_NAME;
 
-		dfield = que_node_get_val(block_size);
-
-		ut_a(dfield_get_len(dfield) == 4);
-		size = mach_read_from_4(static_cast<byte*>(
-			dfield_get_data(dfield)));
-
-
-		switch (size) {
-		case 0:
-			break;
-
-		case 1: case 2: case 4: case 8: case 16:
-			flags |= DICT_TF_COMPACT;
-			/* FTS-FIXME: needs the zip changes */
-			/* flags |= size << DICT_TF_COMPRESSED_SHIFT; */
-			break;
-
-		default:
-			ut_error;
-		}
-	}
-
-	/* Set the flags2 when create table or alter tables */
-	flags2 |= DICT_TF2_FTS_AUX_HEX_NAME;
 	DBUG_EXECUTE_IF("innodb_test_wrong_fts_aux_table_name",
 			flags2 &= ~DICT_TF2_FTS_AUX_HEX_NAME;);
 
-
 	n_cols = que_node_list_get_len(column_defs);
 
 	table = dict_mem_table_create(
@@ -2005,7 +1875,6 @@ pars_procedure_definition(
 /*======================*/
 	sym_node_t*	sym_node,	/*!< in: procedure id node in the symbol
 					table */
-	sym_node_t*	param_list,	/*!< in: parameter declaration list */
 	que_node_t*	stat_list)	/*!< in: statement list */
 {
 	proc_node_t*	node;
@@ -2030,7 +1899,6 @@ pars_procedure_definition(
 	sym_node->resolved = TRUE;
 
 	node->proc_id = sym_node;
-	node->param_list = param_list;
 	node->stat_list = stat_list;
 
 	pars_set_parent_in_list(stat_list, node);
diff --git a/storage/innobase/rem/rem0cmp.cc b/storage/innobase/rem/rem0cmp.cc
index 2abcbb425c0..b093a8b5952 100644
--- a/storage/innobase/rem/rem0cmp.cc
+++ b/storage/innobase/rem/rem0cmp.cc
@@ -1,6 +1,7 @@
 /*****************************************************************************
 
-Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 1994, 2019, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -534,7 +535,7 @@ cmp_data(
 
 /** Compare a GIS data tuple to a physical record.
 @param[in] dtuple data tuple
-@param[in] rec B-tree record
+@param[in] rec R-tree record
 @param[in] offsets rec_get_offsets(rec)
 @param[in] mode compare mode
 @retval negative if dtuple is less than rec */
@@ -546,7 +547,7 @@ cmp_dtuple_rec_with_gis(
 				dtuple in some of the common fields, or which
 				has an equal number or more fields than
 				dtuple */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	page_cur_mode_t	mode)	/*!< in: compare mode */
 {
 	const dfield_t*	dtuple_field;	/* current field in logical record */
@@ -579,7 +580,7 @@ int
 cmp_dtuple_rec_with_gis_internal(
 	const dtuple_t*	dtuple,
 	const rec_t*	rec,
-	const ulint*	offsets)
+	const offset_t*	offsets)
 {
 	const dfield_t*	dtuple_field;	/* current field in logical record */
 	ulint		dtuple_f_len;	/* the length of the current field
@@ -650,7 +651,7 @@ int
 cmp_dtuple_rec_with_match_low(
 	const dtuple_t*	dtuple,
 	const rec_t*	rec,
-	const ulint*	offsets,
+	const offset_t*	offsets,
 	ulint		n_cmp,
 	ulint*		matched_fields)
 {
@@ -784,7 +785,7 @@ cmp_dtuple_rec_with_match_bytes(
 	const dtuple_t*		dtuple,
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	ulint*			matched_fields,
 	ulint*			matched_bytes)
 {
@@ -952,7 +953,7 @@ int
 cmp_dtuple_rec(
 	const dtuple_t*	dtuple,
 	const rec_t*	rec,
-	const ulint*	offsets)
+	const offset_t*	offsets)
 {
 	ulint	matched_fields	= 0;
 
@@ -970,7 +971,7 @@ cmp_dtuple_is_prefix_of_rec(
 /*========================*/
 	const dtuple_t*	dtuple,	/*!< in: data tuple */
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ulint	n_fields;
 	ulint	matched_fields	= 0;
@@ -998,8 +999,8 @@ cmp_rec_rec_simple_field(
 /*=====================*/
 	const rec_t*		rec1,	/*!< in: physical record */
 	const rec_t*		rec2,	/*!< in: physical record */
-	const ulint*		offsets1,/*!< in: rec_get_offsets(rec1, ...) */
-	const ulint*		offsets2,/*!< in: rec_get_offsets(rec2, ...) */
+	const offset_t*		offsets1,/*!< in: rec_get_offsets(rec1, ...) */
+	const offset_t*		offsets2,/*!< in: rec_get_offsets(rec2, ...) */
 	const dict_index_t*	index,	/*!< in: data dictionary index */
 	ulint			n)	/*!< in: field to compare */
 {
@@ -1029,8 +1030,8 @@ cmp_rec_rec_simple(
 /*===============*/
 	const rec_t*		rec1,	/*!< in: physical record */
 	const rec_t*		rec2,	/*!< in: physical record */
-	const ulint*		offsets1,/*!< in: rec_get_offsets(rec1, ...) */
-	const ulint*		offsets2,/*!< in: rec_get_offsets(rec2, ...) */
+	const offset_t*		offsets1,/*!< in: rec_get_offsets(rec1, ...) */
+	const offset_t*		offsets2,/*!< in: rec_get_offsets(rec2, ...) */
 	const dict_index_t*	index,	/*!< in: data dictionary index */
 	struct TABLE*		table)	/*!< in: MySQL table, for reporting
 					duplicate key value if applicable,
@@ -1096,42 +1097,40 @@ cmp_rec_rec_simple(
 	return(0);
 }
 
-/** Compare two B-tree records.
-@param[in] rec1 B-tree record
-@param[in] rec2 B-tree record
-@param[in] offsets1 rec_get_offsets(rec1, index)
-@param[in] offsets2 rec_get_offsets(rec2, index)
-@param[in] index B-tree index
-@param[in] nulls_unequal true if this is for index cardinality
-statistics estimation, and innodb_stats_method=nulls_unequal
-or innodb_stats_method=nulls_ignored
-@param[out] matched_fields number of completely matched fields
-within the first field not completely matched
-@return the comparison result
+/** Compare two B-tree or R-tree records.
+Only the common first fields are compared, and externally stored field
+are treated as equal.
+@param[in]	rec1		record (possibly not on an index page)
+@param[in]	rec2		B-tree or R-tree record in an index page
+@param[in]	offsets1	rec_get_offsets(rec1, index)
+@param[in]	offsets2	rec_get_offsets(rec2, index)
+@param[in]	nulls_unequal	true if this is for index cardinality
+				statistics estimation with
+				innodb_stats_method=nulls_unequal
+				or innodb_stats_method=nulls_ignored
+@param[out]	matched_fields	number of completely matched fields
+				within the first field not completely matched
 @retval 0 if rec1 is equal to rec2
 @retval negative if rec1 is less than rec2
-@retval positive if rec2 is greater than rec2 */
+@retval positive if rec1 is greater than rec2 */
 int
-cmp_rec_rec_with_match(
+cmp_rec_rec(
 	const rec_t*		rec1,
 	const rec_t*		rec2,
-	const ulint*		offsets1,
-	const ulint*		offsets2,
+	const offset_t*		offsets1,
+	const offset_t*		offsets2,
 	const dict_index_t*	index,
 	bool			nulls_unequal,
 	ulint*			matched_fields)
 {
-	ulint		rec1_n_fields;	/* the number of fields in rec */
 	ulint		rec1_f_len;	/* length of current field in rec */
 	const byte*	rec1_b_ptr;	/* pointer to the current byte
 					in rec field */
-	ulint		rec2_n_fields;	/* the number of fields in rec */
 	ulint		rec2_f_len;	/* length of current field in rec */
 	const byte*	rec2_b_ptr;	/* pointer to the current byte
 					in rec field */
 	ulint		cur_field = 0;	/* current field number */
 	int		ret = 0;	/* return value */
-	ulint		comp;
 
 	ut_ad(rec1 != NULL);
 	ut_ad(rec2 != NULL);
@@ -1139,10 +1138,12 @@ cmp_rec_rec_with_match(
 	ut_ad(rec_offs_validate(rec1, index, offsets1));
 	ut_ad(rec_offs_validate(rec2, index, offsets2));
 	ut_ad(rec_offs_comp(offsets1) == rec_offs_comp(offsets2));
+	ut_ad(fil_page_index_page_check(page_align(rec2)));
+	ut_ad(!!dict_index_is_spatial(index)
+	      == (fil_page_get_type(page_align(rec2)) == FIL_PAGE_RTREE));
 
-	comp = rec_offs_comp(offsets1);
-	rec1_n_fields = rec_offs_n_fields(offsets1);
-	rec2_n_fields = rec_offs_n_fields(offsets2);
+	ulint comp = rec_offs_comp(offsets1);
+	ulint n_fields;
 
 	/* Test if rec is the predefined minimum record */
 	if (UNIV_UNLIKELY(rec_get_info_bits(rec1, comp)
@@ -1158,37 +1159,41 @@ cmp_rec_rec_with_match(
 		goto order_resolved;
 	}
 
-	/* Match fields in a loop */
+	/* For non-leaf spatial index records, the
+	dict_index_get_n_unique_in_tree() does include the child page
+	number, because spatial index node pointers only contain
+	the MBR (minimum bounding rectangle) and the child page number.
 
-	for (; cur_field < rec1_n_fields && cur_field < rec2_n_fields;
-	     cur_field++) {
+	For B-tree node pointers, the key alone (secondary index
+	columns and PRIMARY KEY columns) must be unique, and there is
+	no need to compare the child page number. */
+	n_fields = std::min(rec_offs_n_fields(offsets1),
+			    rec_offs_n_fields(offsets2));
+	n_fields = std::min(n_fields, dict_index_get_n_unique_in_tree(index));
 
+	for (; cur_field < n_fields; cur_field++) {
 		ulint	mtype;
 		ulint	prtype;
 
-		/* If this is node-ptr records then avoid comparing node-ptr
-		field. Only key field needs to be compared. */
-		if (cur_field == dict_index_get_n_unique_in_tree(index)) {
-			break;
-		}
-
-		if (dict_index_is_ibuf(index)) {
+		if (UNIV_UNLIKELY(dict_index_is_ibuf(index))) {
 			/* This is for the insert buffer B-tree. */
 			mtype = DATA_BINARY;
 			prtype = 0;
 		} else {
-			const dict_col_t*	col;
-
-			col	= dict_index_get_nth_col(index, cur_field);
-
+			const dict_col_t* col = dict_index_get_nth_col(
+				index, cur_field);
 			mtype = col->mtype;
 			prtype = col->prtype;
 
-			/* If the index is spatial index, we mark the
-			prtype of the first field as MBR field. */
-			if (cur_field == 0 && dict_index_is_spatial(index)) {
+			if (UNIV_LIKELY(!dict_index_is_spatial(index))) {
+			} else if (cur_field == 0) {
 				ut_ad(DATA_GEOMETRY_MTYPE(mtype));
 				prtype |= DATA_GIS_MBR;
+			} else if (!page_rec_is_leaf(rec2)) {
+				/* Compare the child page number. */
+				ut_ad(cur_field == 1);
+				mtype = DATA_SYS_CHILD;
+				prtype = 0;
 			}
 		}
 
@@ -1226,8 +1231,10 @@ cmp_rec_rec_with_match(
 	to the common fields */
 	ut_ad(ret == 0);
 order_resolved:
-	*matched_fields = cur_field;
-	return(ret);
+	if (matched_fields) {
+		*matched_fields = cur_field;
+	}
+	return ret;
 }
 
 #ifdef UNIV_COMPILE_TEST_FUNCS
diff --git a/storage/innobase/rem/rem0rec.cc b/storage/innobase/rem/rem0rec.cc
index 7956c0fb62e..458457c52d5 100644
--- a/storage/innobase/rem/rem0rec.cc
+++ b/storage/innobase/rem/rem0rec.cc
@@ -277,13 +277,13 @@ void
 rec_init_offsets_comp_ordinary(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	ulint*			offsets,
+	offset_t*		offsets,
 	ulint			n_core,
 	const dict_col_t::def_t*def_val,
 	rec_leaf_format		format)
 {
-	ulint		offs		= 0;
-	ulint		any		= 0;
+	offset_t	offs		= 0;
+	offset_t	any		= 0;
 	const byte*	nulls		= rec;
 	const byte*	lens		= NULL;
 	ulint		n_fields	= n_core;
@@ -337,8 +337,8 @@ ordinary:
 	/* We cannot invoke rec_offs_make_valid() if format==REC_LEAF_TEMP.
 	Similarly, rec_offs_validate() will fail in that case, because
 	it invokes rec_get_status(). */
-	offsets[2] = (ulint) rec;
-	offsets[3] = (ulint) index;
+	memcpy(&offsets[RECORD_OFFSET], &rec, sizeof(rec));
+	memcpy(&offsets[INDEX_OFFSET], &index, sizeof(index));
 #endif /* UNIV_DEBUG */
 
 	/* read the lengths of fields 0..n_fields */
@@ -348,17 +348,17 @@ ordinary:
 			= dict_index_get_nth_field(index, i);
 		const dict_col_t*	col
 			= dict_field_get_col(field);
-		ulint			len;
+		offset_t		len;
 
 		/* set default value flag */
 		if (i < n_fields) {
 		} else if (def_val) {
 			const dict_col_t::def_t& d = def_val[i - n_core];
 			if (!d.data) {
-				len = offs | REC_OFFS_SQL_NULL;
+				len = combine(offs, SQL_NULL);
 				ut_ad(d.len == UNIV_SQL_NULL);
 			} else {
-				len = offs | REC_OFFS_DEFAULT;
+				len = combine(offs, DEFAULT);
 				any |= REC_OFFS_DEFAULT;
 			}
 
@@ -366,10 +366,10 @@ ordinary:
 		} else {
 			ulint dlen;
 			if (!index->instant_field_value(i, &dlen)) {
-				len = offs | REC_OFFS_SQL_NULL;
+				len = combine(offs, SQL_NULL);
 				ut_ad(dlen == UNIV_SQL_NULL);
 			} else {
-				len = offs | REC_OFFS_DEFAULT;
+				len = combine(offs, DEFAULT);
 				any |= REC_OFFS_DEFAULT;
 			}
 
@@ -391,7 +391,7 @@ ordinary:
 				We do not advance offs, and we set
 				the length to zero and enable the
 				SQL NULL flag in offsets[]. */
-				len = offs | REC_OFFS_SQL_NULL;
+				len = combine(offs, SQL_NULL);
 				goto resolved;
 			}
 			null_mask <<= 1;
@@ -414,11 +414,11 @@ ordinary:
 				len <<= 8;
 				len |= *lens--;
 
-				offs += len & 0x3fff;
+				offs += get_value(len);
 				if (UNIV_UNLIKELY(len & 0x4000)) {
 					ut_ad(dict_index_is_clust(index));
 					any |= REC_OFFS_EXTERNAL;
-					len = offs | REC_OFFS_EXTERNAL;
+					len = combine(offs, STORED_OFFPAGE);
 				} else {
 					len = offs;
 				}
@@ -435,7 +435,7 @@ resolved:
 	} while (++i < rec_offs_n_fields(offsets));
 
 	*rec_offs_base(offsets)
-		= ulint(rec - (lens + 1)) | REC_OFFS_COMPACT | any;
+		= static_cast<offset_t>(rec - (lens + 1)) | REC_OFFS_COMPACT | any;
 }
 
 #ifdef UNIV_DEBUG
@@ -449,7 +449,7 @@ rec_offs_make_valid(
 	const rec_t*		rec,
 	const dict_index_t*	index,
 	bool			leaf,
-	ulint*			offsets)
+	offset_t*		offsets)
 {
 	ut_ad(rec_offs_n_fields(offsets)
 	      <= (leaf
@@ -469,10 +469,10 @@ rec_offs_make_valid(
 	      || n >= rec_offs_n_fields(offsets));
 	for (; n < rec_offs_n_fields(offsets); n++) {
 		ut_ad(leaf);
-		ut_ad(rec_offs_base(offsets)[1 + n] & REC_OFFS_DEFAULT);
+		ut_ad(get_type(rec_offs_base(offsets)[1 + n]) == DEFAULT);
 	}
-	offsets[2] = ulint(rec);
-	offsets[3] = ulint(index);
+	memcpy(&offsets[RECORD_OFFSET], &rec, sizeof(rec));
+	memcpy(&offsets[INDEX_OFFSET], &index, sizeof(index));
 }
 
 /** Validate offsets returned by rec_get_offsets().
@@ -484,14 +484,14 @@ bool
 rec_offs_validate(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	const ulint*		offsets)
+	const offset_t*		offsets)
 {
 	ulint	i	= rec_offs_n_fields(offsets);
 	ulint	last	= ULINT_MAX;
 	ulint	comp	= *rec_offs_base(offsets) & REC_OFFS_COMPACT;
 
 	if (rec) {
-		ut_ad(ulint(rec) == offsets[2]);
+		ut_ad(!memcmp(&rec, &offsets[RECORD_OFFSET], sizeof(rec)));
 		if (!comp) {
 			const bool is_user_rec = rec_get_heap_no_old(rec)
 				>= PAGE_HEAP_NO_USER_LOW;
@@ -503,14 +503,14 @@ rec_offs_validate(
 			      || (n + (index->id == DICT_INDEXES_ID))
 			      >= index->n_core_fields);
 			for (; n < i; n++) {
-				ut_ad(rec_offs_base(offsets)[1 + n]
-				      & REC_OFFS_DEFAULT);
+				ut_ad(get_type(rec_offs_base(offsets)[1 + n])
+				      == DEFAULT);
 			}
 		}
 	}
 	if (index) {
 		ulint max_n_fields;
-		ut_ad(ulint(index) == offsets[3]);
+		ut_ad(!memcmp(&index, &offsets[INDEX_OFFSET], sizeof(index)));
 		max_n_fields = ut_max(
 			dict_index_get_n_fields(index),
 			dict_index_get_n_unique_in_tree(index) + 1);
@@ -536,7 +536,7 @@ rec_offs_validate(
 		ut_a(!index->n_def || i <= max_n_fields);
 	}
 	while (i--) {
-		ulint	curr = rec_offs_base(offsets)[1 + i] & REC_OFFS_MASK;
+		ulint curr = get_value(rec_offs_base(offsets)[1 + i]);
 		ut_a(curr <= last);
 		last = curr;
 	}
@@ -553,10 +553,9 @@ to the extra size (if REC_OFFS_COMPACT is set, the record is in the
 new format; if REC_OFFS_EXTERNAL is set, the record contains externally
 stored columns), and rec_offs_base(offsets)[1..n_fields] will be set to
 offsets past the end of fields 0..n_fields, or to the beginning of
-fields 1..n_fields+1.  When the high-order bit of the offset at [i+1]
-is set (REC_OFFS_SQL_NULL), the field i is NULL.  When the second
-high-order bit of the offset at [i+1] is set (REC_OFFS_EXTERNAL), the
-field i is being stored externally.
+fields 1..n_fields+1.  When the type of the offset at [i+1]
+is (SQL_NULL), the field i is NULL. When the type of the offset at [i+1]
+is (STORED_OFFPAGE), the field i is stored externally.
 @param[in]	rec	record
 @param[in]	index	the index that the record belongs in
 @param[in]	leaf	whether the record resides in a leaf page
@@ -567,14 +566,14 @@ rec_init_offsets(
 	const rec_t*		rec,
 	const dict_index_t*	index,
 	bool			leaf,
-	ulint*			offsets)
+	offset_t*		offsets)
 {
 	ulint	i	= 0;
-	ulint	offs;
+	offset_t	offs;
 
 	ut_ad(index->n_core_null_bytes <= UT_BITS_IN_BYTES(index->n_nullable));
-	ut_d(offsets[2] = ulint(rec));
-	ut_d(offsets[3] = ulint(index));
+	ut_d(memcpy(&offsets[RECORD_OFFSET], &rec, sizeof(rec)));
+	ut_d(memcpy(&offsets[INDEX_OFFSET], &index, sizeof(index)));
 
 	if (dict_table_is_comp(index->table)) {
 		const byte*	nulls;
@@ -632,7 +631,7 @@ rec_init_offsets(
 
 		/* read the lengths of fields 0..n */
 		do {
-			ulint	len;
+			offset_t len;
 			if (UNIV_UNLIKELY(i == n_node_ptr_field)) {
 				len = offs += REC_NODE_PTR_SIZE;
 				goto resolved;
@@ -654,7 +653,7 @@ rec_init_offsets(
 					We do not advance offs, and we set
 					the length to zero and enable the
 					SQL NULL flag in offsets[]. */
-					len = offs | REC_OFFS_SQL_NULL;
+					len = combine(offs, SQL_NULL);
 					goto resolved;
 				}
 				null_mask <<= 1;
@@ -686,7 +685,7 @@ rec_init_offsets(
 						stored columns.  Thus
 						the "e" flag must be 0. */
 						ut_a(!(len & 0x4000));
-						offs += len & 0x3fff;
+						offs += get_value(len);
 						len = offs;
 
 						goto resolved;
@@ -702,39 +701,40 @@ resolved:
 		} while (++i < rec_offs_n_fields(offsets));
 
 		*rec_offs_base(offsets)
-			= ulint(rec - (lens + 1)) | REC_OFFS_COMPACT;
+			= static_cast<offset_t>(rec - (lens + 1))
+			  | REC_OFFS_COMPACT;
 	} else {
 		/* Old-style record: determine extra size and end offsets */
 		offs = REC_N_OLD_EXTRA_BYTES;
 		const ulint n_fields = rec_get_n_fields_old(rec);
 		const ulint n = std::min(n_fields, rec_offs_n_fields(offsets));
-		ulint any;
+		offset_t any;
 
 		if (rec_get_1byte_offs_flag(rec)) {
-			offs += n_fields;
+			offs += static_cast<offset_t>(n_fields);
 			any = offs;
 			/* Determine offsets to fields */
 			do {
 				offs = rec_1_get_field_end_info(rec, i);
 				if (offs & REC_1BYTE_SQL_NULL_MASK) {
 					offs &= ~REC_1BYTE_SQL_NULL_MASK;
-					offs |= REC_OFFS_SQL_NULL;
+					set_type(offs, SQL_NULL);
 				}
 				rec_offs_base(offsets)[1 + i] = offs;
 			} while (++i < n);
 		} else {
-			offs += 2 * n_fields;
+			offs += 2 * static_cast<offset_t>(n_fields);
 			any = offs;
 			/* Determine offsets to fields */
 			do {
 				offs = rec_2_get_field_end_info(rec, i);
 				if (offs & REC_2BYTE_SQL_NULL_MASK) {
 					offs &= ~REC_2BYTE_SQL_NULL_MASK;
-					offs |= REC_OFFS_SQL_NULL;
+					set_type(offs, SQL_NULL);
 				}
 				if (offs & REC_2BYTE_EXTERN_MASK) {
 					offs &= ~REC_2BYTE_EXTERN_MASK;
-					offs |= REC_OFFS_EXTERNAL;
+					set_type(offs, STORED_OFFPAGE);
 					any |= REC_OFFS_EXTERNAL;
 				}
 				rec_offs_base(offsets)[1 + i] = offs;
@@ -746,8 +746,8 @@ resolved:
 			      || i + (index->id == DICT_INDEXES_ID)
 			      == rec_offs_n_fields(offsets));
 
-			offs = (rec_offs_base(offsets)[i] & REC_OFFS_MASK)
-				| REC_OFFS_DEFAULT;
+			ut_ad(i != 0);
+			offs = combine(rec_offs_base(offsets)[i], DEFAULT);
 
 			do {
 				rec_offs_base(offsets)[1 + i] = offs;
@@ -770,11 +770,11 @@ resolved:
 				(ULINT_UNDEFINED to compute all offsets)
 @param[in,out]	heap		memory heap
 @return the new offsets */
-ulint*
+offset_t*
 rec_get_offsets_func(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	ulint*			offsets,
+	offset_t*		offsets,
 	bool			leaf,
 	ulint			n_fields,
 #ifdef UNIV_DEBUG
@@ -856,11 +856,11 @@ rec_get_offsets_func(
 	if (UNIV_UNLIKELY(!offsets)
 	    || UNIV_UNLIKELY(rec_offs_get_n_alloc(offsets) < size)) {
 		if (UNIV_UNLIKELY(!*heap)) {
-			*heap = mem_heap_create_at(size * sizeof(ulint),
+			*heap = mem_heap_create_at(size * sizeof(*offsets),
 						   file, line);
 		}
-		offsets = static_cast<ulint*>(
-			mem_heap_alloc(*heap, size * sizeof(ulint)));
+		offsets = static_cast<offset_t*>(
+			mem_heap_alloc(*heap, size * sizeof(*offsets)));
 
 		rec_offs_set_n_alloc(offsets, size);
 	}
@@ -883,13 +883,13 @@ rec_get_offsets_reverse(
 	const dict_index_t*	index,	/*!< in: record descriptor */
 	ulint			node_ptr,/*!< in: nonzero=node pointer,
 					0=leaf node */
-	ulint*			offsets)/*!< in/out: array consisting of
+	offset_t*		offsets)/*!< in/out: array consisting of
 					offsets[0] allocated elements */
 {
 	ulint		n;
 	ulint		i;
-	ulint		offs;
-	ulint		any_ext;
+	offset_t	offs;
+	offset_t	any_ext = 0;
 	const byte*	nulls;
 	const byte*	lens;
 	dict_field_t*	field;
@@ -915,11 +915,10 @@ rec_get_offsets_reverse(
 	lens = nulls + UT_BITS_IN_BYTES(index->n_nullable);
 	i = offs = 0;
 	null_mask = 1;
-	any_ext = 0;
 
 	/* read the lengths of fields 0..n */
 	do {
-		ulint	len;
+		offset_t len;
 		if (UNIV_UNLIKELY(i == n_node_ptr_field)) {
 			len = offs += REC_NODE_PTR_SIZE;
 			goto resolved;
@@ -940,7 +939,7 @@ rec_get_offsets_reverse(
 				We do not advance offs, and we set
 				the length to zero and enable the
 				SQL NULL flag in offsets[]. */
-				len = offs | REC_OFFS_SQL_NULL;
+				len = combine(offs, SQL_NULL);
 				goto resolved;
 			}
 			null_mask <<= 1;
@@ -964,10 +963,11 @@ rec_get_offsets_reverse(
 					len <<= 8;
 					len |= *lens++;
 
-					offs += len & 0x3fff;
+					offs += get_value(len);
 					if (UNIV_UNLIKELY(len & 0x4000)) {
 						any_ext = REC_OFFS_EXTERNAL;
-						len = offs | REC_OFFS_EXTERNAL;
+						len = combine(offs,
+							      STORED_OFFPAGE);
 					} else {
 						len = offs;
 					}
@@ -978,15 +978,16 @@ rec_get_offsets_reverse(
 
 			len = offs += len;
 		} else {
-			len = offs += field->fixed_len;
+			len = offs += static_cast<offset_t>(field->fixed_len);
 		}
 resolved:
 		rec_offs_base(offsets)[i + 1] = len;
 	} while (++i < rec_offs_n_fields(offsets));
 
 	ut_ad(lens >= extra);
-	*rec_offs_base(offsets) = (ulint(lens - extra) + REC_N_NEW_EXTRA_BYTES)
-		| REC_OFFS_COMPACT | any_ext;
+	*rec_offs_base(offsets)
+		= static_cast<offset_t>(lens - extra + REC_N_NEW_EXTRA_BYTES)
+		  | REC_OFFS_COMPACT | any_ext;
 }
 
 /************************************************************//**
@@ -1681,7 +1682,7 @@ void
 rec_init_offsets_temp(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	ulint*			offsets,
+	offset_t*		offsets,
 	ulint			n_core,
 	const dict_col_t::def_t*def_val,
 	rec_comp_status_t	status)
@@ -1707,7 +1708,7 @@ void
 rec_init_offsets_temp(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	ulint*			offsets)
+	offset_t*		offsets)
 {
 	ut_ad(!index->is_instant());
 	rec_init_offsets_comp_ordinary(rec, index, offsets,
@@ -1750,8 +1751,8 @@ rec_copy_prefix_to_dtuple(
 	ulint			n_fields,
 	mem_heap_t*		heap)
 {
-	ulint	offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*	offsets	= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets	= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(is_leaf || n_fields
@@ -2047,7 +2048,7 @@ ibool
 rec_validate(
 /*=========*/
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ulint		len;
 	ulint		n_fields;
@@ -2156,7 +2157,7 @@ rec_print_comp(
 /*===========*/
 	FILE*		file,	/*!< in: file where to print */
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ulint	i;
 
@@ -2282,7 +2283,7 @@ rec_print_mbr_rec(
 /*==============*/
 	FILE*		file,	/*!< in: file where to print */
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ut_ad(rec_offs_validate(rec, NULL, offsets));
 	ut_ad(!rec_offs_any_default(offsets));
@@ -2350,7 +2351,7 @@ rec_print_new(
 /*==========*/
 	FILE*		file,	/*!< in: file where to print */
 	const rec_t*	rec,	/*!< in: physical record */
-	const ulint*	offsets)/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets)/*!< in: array returned by rec_get_offsets() */
 {
 	ut_ad(rec_offs_validate(rec, NULL, offsets));
 
@@ -2390,7 +2391,7 @@ rec_print(
 		return;
 	} else {
 		mem_heap_t*	heap	= NULL;
-		ulint		offsets_[REC_OFFS_NORMAL_SIZE];
+		offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
 		rec_offs_init(offsets_);
 
 		rec_print_new(file, rec,
@@ -2413,7 +2414,7 @@ rec_print(
 	std::ostream&	o,
 	const rec_t*	rec,
 	ulint		info,
-	const ulint*	offsets)
+	const offset_t*	offsets)
 {
 	const ulint	comp	= rec_offs_comp(offsets);
 	const ulint	n	= rec_offs_n_fields(offsets);
@@ -2470,7 +2471,7 @@ std::ostream&
 operator<<(std::ostream& o, const rec_index_print& r)
 {
 	mem_heap_t*	heap	= NULL;
-	ulint*		offsets	= rec_get_offsets(
+	offset_t*	offsets	= rec_get_offsets(
 		r.m_rec, r.m_index, NULL, page_rec_is_leaf(r.m_rec),
 		ULINT_UNDEFINED, &heap);
 	rec_print(o, r.m_rec,
@@ -2508,9 +2509,9 @@ rec_get_trx_id(
 	const byte*	trx_id;
 	ulint		len;
 	mem_heap_t*	heap		= NULL;
-	ulint offsets_[REC_OFFS_HEADER_SIZE + MAX_REF_PARTS + 2];
+	offset_t offsets_[REC_OFFS_HEADER_SIZE + MAX_REF_PARTS + 2];
 	rec_offs_init(offsets_);
-	ulint* offsets = offsets_;
+	offset_t* offsets = offsets_;
 
 	ut_ad(trx_id_col <= MAX_REF_PARTS);
 	ut_ad(dict_index_is_clust(index));
@@ -2537,11 +2538,11 @@ rec_get_trx_id(
 @param[in]	n		nth field */
 void
 rec_offs_make_nth_extern(
-	ulint*		offsets,
+	offset_t*	offsets,
 	const ulint	n)
 {
 	ut_ad(!rec_offs_nth_sql_null(offsets, n));
-	rec_offs_base(offsets)[1 + n] |= REC_OFFS_EXTERNAL;
+	set_type(rec_offs_base(offsets)[1 + n], STORED_OFFPAGE);
 }
 #ifdef WITH_WSREP
 # include "ha_prototypes.h"
@@ -2561,8 +2562,8 @@ wsrep_rec_get_foreign_key(
 	ulint		i;
 	uint            key_parts;
 	mem_heap_t*	heap	= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-        const ulint*    offsets;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	const offset_t* offsets;
 
 	ut_ad(index_for);
 	ut_ad(index_ref);
diff --git a/storage/innobase/row/row0ftsort.cc b/storage/innobase/row/row0ftsort.cc
index f40d6772536..d439d7563d9 100644
--- a/storage/innobase/row/row0ftsort.cc
+++ b/storage/innobase/row/row0ftsort.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2010, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2015, 2019, MariaDB Corporation.
+Copyright (c) 2015, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -1372,7 +1372,7 @@ row_fts_sel_tree_propagate(
 	ulint		propogated,	/*<! in: tree node propagated */
 	int*		sel_tree,	/*<! in: selection tree */
 	const mrec_t**	mrec,		/*<! in: sort record */
-	ulint**		offsets,	/*<! in: record offsets */
+	offset_t**	offsets,	/*<! in: record offsets */
 	dict_index_t*	index)		/*<! in/out: FTS index */
 {
 	ulint	parent;
@@ -1422,7 +1422,7 @@ row_fts_sel_tree_update(
 	ulint		propagated,	/*<! in: node to propagate up */
 	ulint		height,		/*<! in: tree height */
 	const mrec_t**	mrec,		/*<! in: sort record */
-	ulint**		offsets,	/*<! in: record offsets */
+	offset_t**	offsets,	/*<! in: record offsets */
 	dict_index_t*	index)		/*<! in: index dictionary */
 {
 	ulint	i;
@@ -1444,7 +1444,7 @@ row_fts_build_sel_tree_level(
 	int*		sel_tree,	/*<! in/out: selection tree */
 	ulint		level,		/*<! in: selection tree level */
 	const mrec_t**	mrec,		/*<! in: sort record */
-	ulint**		offsets,	/*<! in: record offsets */
+	offset_t**	offsets,	/*<! in: record offsets */
 	dict_index_t*	index)		/*<! in: index dictionary */
 {
 	ulint	start;
@@ -1504,7 +1504,7 @@ row_fts_build_sel_tree(
 /*===================*/
 	int*		sel_tree,	/*<! in/out: selection tree */
 	const mrec_t**	mrec,		/*<! in: sort record */
-	ulint**		offsets,	/*<! in: record offsets */
+	offset_t**	offsets,	/*<! in: record offsets */
 	dict_index_t*	index)		/*<! in: index dictionary */
 {
 	ulint	treelevel = 1;
@@ -1554,7 +1554,7 @@ row_fts_merge_insert(
 	mem_heap_t*		heap;
 	dberr_t			error = DB_SUCCESS;
 	ulint*			foffs;
-	ulint**			offsets;
+	offset_t**		offsets;
 	fts_tokenizer_word_t	new_word;
 	ib_vector_t*		positions;
 	doc_id_t		last_doc_id;
@@ -1593,7 +1593,7 @@ row_fts_merge_insert(
 		heap, sizeof (*b) * fts_sort_pll_degree);
 	foffs = (ulint*) mem_heap_alloc(
 		heap, sizeof(*foffs) * fts_sort_pll_degree);
-	offsets = (ulint**) mem_heap_alloc(
+	offsets = (offset_t**) mem_heap_alloc(
 		heap, sizeof(*offsets) * fts_sort_pll_degree);
 	buf = (mrec_buf_t**) mem_heap_alloc(
 		heap, sizeof(*buf) * fts_sort_pll_degree);
@@ -1617,10 +1617,10 @@ row_fts_merge_insert(
 
 		num = 1 + REC_OFFS_HEADER_SIZE
 			+ dict_index_get_n_fields(index);
-		offsets[i] = static_cast<ulint*>(mem_heap_zalloc(
+		offsets[i] = static_cast<offset_t*>(mem_heap_zalloc(
 			heap, num * sizeof *offsets[i]));
-		offsets[i][0] = num;
-		offsets[i][1] = dict_index_get_n_fields(index);
+		rec_offs_set_n_alloc(offsets[i], num);
+		rec_offs_set_n_fields(offsets[i], dict_index_get_n_fields(index));
 		block[i] = psort_info[i].merge_block[id];
 		crypt_block[i] = psort_info[i].crypt_block[id];
 		b[i] = psort_info[i].merge_block[id];
@@ -1722,7 +1722,6 @@ row_fts_merge_insert(
 	corresponding FTS index auxiliary tables */
 	for (;;) {
 		dtuple_t*	dtuple;
-		ulint		n_ext;
 		int		min_rec = 0;
 
 		if (fts_sort_pll_degree <= 2) {
@@ -1765,7 +1764,7 @@ row_fts_merge_insert(
 		}
 
 		dtuple = row_rec_to_index_entry_low(
-			mrec[min_rec], index, offsets[min_rec], &n_ext,
+			mrec[min_rec], index, offsets[min_rec],
 			tuple_heap);
 
 		row_fts_insert_tuple(
diff --git a/storage/innobase/row/row0import.cc b/storage/innobase/row/row0import.cc
index 2fc28364b74..268d196036a 100644
--- a/storage/innobase/row/row0import.cc
+++ b/storage/innobase/row/row0import.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2012, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2015, 2019, MariaDB Corporation.
+Copyright (c) 2015, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -264,7 +264,7 @@ public:
 	bool remove(
 		const dict_index_t*	index,
 		page_zip_des_t*		page_zip,
-		ulint*			offsets) UNIV_NOTHROW
+		offset_t*		offsets) UNIV_NOTHROW
 	{
 		/* We can't end up with an empty page unless it is root. */
 		if (page_get_n_recs(m_cur.block->frame) <= 1) {
@@ -846,7 +846,7 @@ private:
 	@return DB_SUCCESS or error code */
 	dberr_t	adjust_cluster_index_blob_column(
 		rec_t*		rec,
-		const ulint*	offsets,
+		const offset_t*	offsets,
 		ulint		i) UNIV_NOTHROW;
 
 	/** Adjusts the BLOB reference in the clustered index row for all
@@ -856,7 +856,7 @@ private:
 	@return DB_SUCCESS or error code */
 	dberr_t	adjust_cluster_index_blob_columns(
 		rec_t*		rec,
-		const ulint*	offsets) UNIV_NOTHROW;
+		const offset_t*	offsets) UNIV_NOTHROW;
 
 	/** In the clustered index, adjist the BLOB pointers as needed.
 	Also update the BLOB reference, write the new space id.
@@ -865,7 +865,7 @@ private:
 	@return DB_SUCCESS or error code */
 	dberr_t	adjust_cluster_index_blob_ref(
 		rec_t*		rec,
-		const ulint*	offsets) UNIV_NOTHROW;
+		const offset_t*	offsets) UNIV_NOTHROW;
 
 	/** Purge delete-marked records, only if it is possible to do
 	so without re-organising the B+tree.
@@ -878,7 +878,7 @@ private:
 	@return DB_SUCCESS or error code. */
 	dberr_t	adjust_cluster_record(
 		rec_t*			rec,
-		const ulint*		offsets) UNIV_NOTHROW;
+		const offset_t*		offsets) UNIV_NOTHROW;
 
 	/** Find an index with the matching id.
 	@return row_index_t* instance or 0 */
@@ -912,10 +912,10 @@ private:
 	RecIterator		m_rec_iter;
 
 	/** Record offset */
-	ulint			m_offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t		m_offsets_[REC_OFFS_NORMAL_SIZE];
 
 	/** Pointer to m_offsets_ */
-	ulint*			m_offsets;
+	offset_t*		m_offsets;
 
 	/** Memory heap for the record offsets */
 	mem_heap_t*		m_heap;
@@ -1152,60 +1152,82 @@ row_import::match_table_columns(
 
 			if (cfg_col->prtype != col->prtype) {
 				ib_errf(thd,
-					 IB_LOG_LEVEL_ERROR,
-					 ER_TABLE_SCHEMA_MISMATCH,
-					 "Column %s precise type mismatch.",
-					 col_name);
+					IB_LOG_LEVEL_ERROR,
+					ER_TABLE_SCHEMA_MISMATCH,
+					"Column %s precise type mismatch,"
+					" it's 0X%X in the table and 0X%X"
+					" in the tablespace meta file",
+					col_name, col->prtype, cfg_col->prtype);
 				err = DB_ERROR;
 			}
 
 			if (cfg_col->mtype != col->mtype) {
 				ib_errf(thd,
-					 IB_LOG_LEVEL_ERROR,
-					 ER_TABLE_SCHEMA_MISMATCH,
-					 "Column %s main type mismatch.",
-					 col_name);
+					IB_LOG_LEVEL_ERROR,
+					ER_TABLE_SCHEMA_MISMATCH,
+					"Column %s main type mismatch,"
+					" it's 0X%X in the table and 0X%X"
+					" in the tablespace meta file",
+					col_name, col->mtype, cfg_col->mtype);
 				err = DB_ERROR;
 			}
 
 			if (cfg_col->len != col->len) {
 				ib_errf(thd,
-					 IB_LOG_LEVEL_ERROR,
-					 ER_TABLE_SCHEMA_MISMATCH,
-					 "Column %s length mismatch.",
-					 col_name);
+					IB_LOG_LEVEL_ERROR,
+					ER_TABLE_SCHEMA_MISMATCH,
+					"Column %s length mismatch,"
+					" it's %u in the table and %u"
+					" in the tablespace meta file",
+					col_name, col->len, cfg_col->len);
 				err = DB_ERROR;
 			}
 
 			if (cfg_col->mbminlen != col->mbminlen
 			    || cfg_col->mbmaxlen != col->mbmaxlen) {
 				ib_errf(thd,
-					 IB_LOG_LEVEL_ERROR,
-					 ER_TABLE_SCHEMA_MISMATCH,
-					 "Column %s multi-byte len mismatch.",
-					 col_name);
+					IB_LOG_LEVEL_ERROR,
+					ER_TABLE_SCHEMA_MISMATCH,
+					"Column %s multi-byte len mismatch,"
+					" it's %u-%u in the table and %u-%u"
+					" in the tablespace meta file",
+					col_name, col->mbminlen, col->mbmaxlen,
+					cfg_col->mbminlen, cfg_col->mbmaxlen);
 				err = DB_ERROR;
 			}
 
 			if (cfg_col->ind != col->ind) {
+				ib_errf(thd,
+					IB_LOG_LEVEL_ERROR,
+					ER_TABLE_SCHEMA_MISMATCH,
+					"Column %s position mismatch,"
+					" it's %u in the table and %u"
+					" in the tablespace meta file",
+					col_name, col->ind, cfg_col->ind);
 				err = DB_ERROR;
 			}
 
 			if (cfg_col->ord_part != col->ord_part) {
 				ib_errf(thd,
-					 IB_LOG_LEVEL_ERROR,
-					 ER_TABLE_SCHEMA_MISMATCH,
-					 "Column %s ordering mismatch.",
-					 col_name);
+					IB_LOG_LEVEL_ERROR,
+					ER_TABLE_SCHEMA_MISMATCH,
+					"Column %s ordering mismatch,"
+					" it's %u in the table and %u"
+					" in the tablespace meta file",
+					col_name, col->ord_part,
+					cfg_col->ord_part);
 				err = DB_ERROR;
 			}
 
 			if (cfg_col->max_prefix != col->max_prefix) {
 				ib_errf(thd,
-					 IB_LOG_LEVEL_ERROR,
-					 ER_TABLE_SCHEMA_MISMATCH,
-					 "Column %s max prefix mismatch.",
-					 col_name);
+					IB_LOG_LEVEL_ERROR,
+					ER_TABLE_SCHEMA_MISMATCH,
+					"Column %s max prefix mismatch"
+					" it's %u in the table and %u"
+					" in the tablespace meta file",
+					col_name, col->max_prefix,
+					cfg_col->max_prefix);
 				err = DB_ERROR;
 			}
 		}
@@ -1504,13 +1526,70 @@ IndexPurge::next() UNIV_NOTHROW
 	mtr_set_log_mode(&m_mtr, MTR_LOG_NO_REDO);
 
 	btr_pcur_restore_position(BTR_MODIFY_LEAF, &m_pcur, &m_mtr);
+	/* The following is based on btr_pcur_move_to_next_user_rec(). */
+	m_pcur.old_stored = false;
+	ut_ad(m_pcur.latch_mode == BTR_MODIFY_LEAF);
+	do {
+		if (btr_pcur_is_after_last_on_page(&m_pcur)) {
+			if (btr_pcur_is_after_last_in_tree(&m_pcur)) {
+				return DB_END_OF_INDEX;
+			}
 
-	if (!btr_pcur_move_to_next_user_rec(&m_pcur, &m_mtr)) {
+			buf_block_t* block = btr_pcur_get_block(&m_pcur);
+			uint32_t next_page = btr_page_get_next(block->frame);
 
-		return(DB_END_OF_INDEX);
-	}
+			/* MDEV-13542 FIXME: Make these checks part of
+			btr_pcur_move_to_next_page(), and introduce a
+			return status that will be checked in all callers! */
+			switch (next_page) {
+			default:
+				if (next_page != block->page.id.page_no()) {
+					break;
+				}
+				/* MDEV-20931 FIXME: Check that
+				next_page is within the tablespace
+				bounds! Also check that it is not a
+				change buffer bitmap page. */
+				/* fall through */
+			case 0:
+			case 1:
+			case FIL_NULL:
+				return DB_CORRUPTION;
+			}
 
-	return(DB_SUCCESS);
+			dict_index_t* index = m_pcur.btr_cur.index;
+			buf_block_t* next_block = btr_block_get(
+				page_id_t(block->page.id.space(), next_page),
+				block->page.size, BTR_MODIFY_LEAF, index,
+				&m_mtr);
+
+			if (UNIV_UNLIKELY(!next_block
+					  || !fil_page_index_page_check(
+						  next_block->frame)
+					  || !!dict_index_is_spatial(index)
+					  != (fil_page_get_type(
+						      next_block->frame)
+					      == FIL_PAGE_RTREE)
+					  || page_is_comp(next_block->frame)
+					  != page_is_comp(block->frame)
+					  || btr_page_get_prev(
+						  next_block->frame)
+					  != block->page.id.page_no())) {
+				return DB_CORRUPTION;
+			}
+
+			btr_leaf_page_release(block, BTR_MODIFY_LEAF, &m_mtr);
+
+			page_cur_set_before_first(next_block,
+						  &m_pcur.btr_cur.page_cur);
+
+			ut_d(page_check_dir(next_block->frame));
+		} else {
+			btr_pcur_move_to_next_on_page(&m_pcur);
+		}
+	} while (!btr_pcur_is_on_user_rec(&m_pcur));
+
+	return DB_SUCCESS;
 }
 
 /**
@@ -1563,7 +1642,7 @@ inline
 dberr_t
 PageConverter::adjust_cluster_index_blob_column(
 	rec_t*		rec,
-	const ulint*	offsets,
+	const offset_t*	offsets,
 	ulint		i) UNIV_NOTHROW
 {
 	ulint		len;
@@ -1607,7 +1686,7 @@ inline
 dberr_t
 PageConverter::adjust_cluster_index_blob_columns(
 	rec_t*		rec,
-	const ulint*	offsets) UNIV_NOTHROW
+	const offset_t*	offsets) UNIV_NOTHROW
 {
 	ut_ad(rec_offs_any_extern(offsets));
 
@@ -1640,7 +1719,7 @@ inline
 dberr_t
 PageConverter::adjust_cluster_index_blob_ref(
 	rec_t*		rec,
-	const ulint*	offsets) UNIV_NOTHROW
+	const offset_t*	offsets) UNIV_NOTHROW
 {
 	if (rec_offs_any_extern(offsets)) {
 		dberr_t	err;
@@ -1683,7 +1762,7 @@ inline
 dberr_t
 PageConverter::adjust_cluster_record(
 	rec_t*			rec,
-	const ulint*		offsets) UNIV_NOTHROW
+	const offset_t*		offsets) UNIV_NOTHROW
 {
 	dberr_t	err;
 
@@ -2281,8 +2360,8 @@ row_import_set_sys_max_row_id(
 		ulint		len;
 		const byte*	field;
 		mem_heap_t*	heap = NULL;
-		ulint		offsets_[1 + REC_OFFS_HEADER_SIZE];
-		ulint*		offsets;
+		offset_t	offsets_[1 + REC_OFFS_HEADER_SIZE];
+		offset_t*	offsets;
 
 		rec_offs_init(offsets_);
 
diff --git a/storage/innobase/row/row0ins.cc b/storage/innobase/row/row0ins.cc
index 0fb994b547a..c494ae519ca 100644
--- a/storage/innobase/row/row0ins.cc
+++ b/storage/innobase/row/row0ins.cc
@@ -223,7 +223,7 @@ row_ins_sec_index_entry_by_modify(
 				depending on whether mtr holds just a leaf
 				latch or also a tree latch */
 	btr_cur_t*	cursor,	/*!< in: B-tree cursor */
-	ulint**		offsets,/*!< in/out: offsets on cursor->page_cur.rec */
+	offset_t**	offsets,/*!< in/out: offsets on cursor->page_cur.rec */
 	mem_heap_t*	offsets_heap,
 				/*!< in/out: memory heap that can be emptied */
 	mem_heap_t*	heap,	/*!< in/out: memory heap */
@@ -318,7 +318,7 @@ row_ins_clust_index_entry_by_modify(
 	ulint		mode,	/*!< in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
 				depending on whether mtr holds just a leaf
 				latch or also a tree latch */
-	ulint**		offsets,/*!< out: offsets on cursor->page_cur.rec */
+	offset_t**	offsets,/*!< out: offsets on cursor->page_cur.rec */
 	mem_heap_t**	offsets_heap,
 				/*!< in/out: pointer to memory heap that can
 				be emptied, or NULL */
@@ -940,9 +940,9 @@ row_ins_foreign_fill_virtual(
 {
 	THD*		thd = current_thd;
 	row_ext_t*	ext;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
 	rec_offs_init(offsets_);
-	const ulint*	offsets =
+	const offset_t*	offsets =
 		rec_get_offsets(rec, index, offsets_, true,
 				ULINT_UNDEFINED, &cascade->heap);
 	mem_heap_t*	v_heap = NULL;
@@ -1492,7 +1492,7 @@ row_ins_set_shared_rec_lock(
 	const buf_block_t*	block,	/*!< in: buffer block of rec */
 	const rec_t*		rec,	/*!< in: record */
 	dict_index_t*		index,	/*!< in: index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	que_thr_t*		thr)	/*!< in: query thread */
 {
 	dberr_t	err;
@@ -1523,7 +1523,7 @@ row_ins_set_exclusive_rec_lock(
 	const buf_block_t*	block,	/*!< in: buffer block of rec */
 	const rec_t*		rec,	/*!< in: record */
 	dict_index_t*		index,	/*!< in: index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	que_thr_t*		thr)	/*!< in: query thread */
 {
 	dberr_t	err;
@@ -1570,8 +1570,8 @@ row_ins_check_foreign_constraint(
 	mtr_t		mtr;
 	trx_t*		trx		= thr_get_trx(thr);
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 
 	bool		skip_gap_lock;
 
@@ -2074,7 +2074,7 @@ row_ins_dupl_error_with_rec(
 				the record! */
 	const dtuple_t*	entry,	/*!< in: entry to insert */
 	dict_index_t*	index,	/*!< in: index */
-	const ulint*	offsets)/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets)/*!< in: rec_get_offsets(rec, index) */
 {
 	ulint	matched_fields;
 	ulint	n_unique;
@@ -2133,9 +2133,11 @@ row_ins_scan_sec_index_for_duplicate(
 	btr_pcur_t	pcur;
 	dberr_t		err		= DB_SUCCESS;
 	ulint		allow_duplicates;
-	ulint*		offsets		= NULL;
+	offset_t	offsets_[REC_OFFS_SEC_INDEX_SIZE];
+	offset_t*	offsets		= offsets_;
 	DBUG_ENTER("row_ins_scan_sec_index_for_duplicate");
 
+	rec_offs_init(offsets_);
 
 	ut_ad(s_latch == rw_lock_own_flagged(
 			&index->lock, RW_LOCK_FLAG_S | RW_LOCK_FLAG_SX));
@@ -2265,7 +2267,7 @@ row_ins_duplicate_online(
 	ulint		n_uniq,	/*!< in: offset of DB_TRX_ID */
 	const dtuple_t*	entry,	/*!< in: entry that is being inserted */
 	const rec_t*	rec,	/*!< in: clustered index record */
-	ulint*		offsets)/*!< in/out: rec_get_offsets(rec) */
+	offset_t*	offsets)/*!< in/out: rec_get_offsets(rec) */
 {
 	ulint	fields	= 0;
 
@@ -2304,7 +2306,7 @@ row_ins_duplicate_error_in_clust_online(
 	ulint		n_uniq,	/*!< in: offset of DB_TRX_ID */
 	const dtuple_t*	entry,	/*!< in: entry that is being inserted */
 	const btr_cur_t*cursor,	/*!< in: cursor on insert position */
-	ulint**		offsets,/*!< in/out: rec_get_offsets(rec) */
+	offset_t**	offsets,/*!< in/out: rec_get_offsets(rec) */
 	mem_heap_t**	heap)	/*!< in/out: heap for offsets */
 {
 	dberr_t		err	= DB_SUCCESS;
@@ -2353,8 +2355,8 @@ row_ins_duplicate_error_in_clust(
 	ulint	n_unique;
 	trx_t*	trx		= thr_get_trx(thr);
 	mem_heap_t*heap		= NULL;
-	ulint	offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*	offsets		= offsets_;
+	offset_t offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t* offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(dict_index_is_clust(cursor->index));
@@ -2527,7 +2529,7 @@ dberr_t
 row_ins_index_entry_big_rec(
 	const dtuple_t*		entry,
 	const big_rec_t*	big_rec,
-	ulint*			offsets,
+	offset_t*		offsets,
 	mem_heap_t**		heap,
 	dict_index_t*		index,
 	const void*		thd __attribute__((unused)))
@@ -2602,8 +2604,8 @@ row_ins_clust_index_entry_low(
 	mtr_t		mtr;
 	ib_uint64_t	auto_inc	= 0;
 	mem_heap_t*	offsets_heap	= NULL;
-	ulint           offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*          offsets         = offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets         = offsets_;
 	rec_offs_init(offsets_);
 
 	DBUG_ENTER("row_ins_clust_index_entry_low");
@@ -2917,8 +2919,8 @@ row_ins_sec_index_entry_low(
 	dberr_t		err		= DB_SUCCESS;
 	ulint		n_unique;
 	mtr_t		mtr;
-	ulint           offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*          offsets         = offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets         = offsets_;
 	rec_offs_init(offsets_);
 	rtr_info_t	rtr_info;
 
diff --git a/storage/innobase/row/row0log.cc b/storage/innobase/row/row0log.cc
index e2f6450e38d..f6d0657ad5a 100644
--- a/storage/innobase/row/row0log.cc
+++ b/storage/innobase/row/row0log.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2011, 2018, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, 2019, MariaDB Corporation.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -643,7 +643,7 @@ row_log_table_delete(
 				page X-latched */
 	dict_index_t*	index,	/*!< in/out: clustered index, S-latched
 				or X-latched */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec,index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec,index) */
 	const byte*	sys)	/*!< in: DB_TRX_ID,DB_ROLL_PTR that should
 				be logged, or NULL to use those in rec */
 {
@@ -934,7 +934,7 @@ row_log_table_low(
 				page X-latched */
 	dict_index_t*	index,	/*!< in/out: clustered index, S-latched
 				or X-latched */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec,index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec,index) */
 	bool		insert,	/*!< in: true if insert, false if update */
 	const dtuple_t*	old_pk)	/*!< in: old PRIMARY KEY value (if !insert
 				and a PRIMARY KEY is being created) */
@@ -1103,7 +1103,7 @@ row_log_table_update(
 				page X-latched */
 	dict_index_t*	index,	/*!< in/out: clustered index, S-latched
 				or X-latched */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec,index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec,index) */
 	const dtuple_t*	old_pk)	/*!< in: row_log_table_get_pk()
 				before the update */
 {
@@ -1153,7 +1153,7 @@ row_log_table_get_pk_col(
 	dfield_t*		dfield,
 	mem_heap_t*		heap,
 	const rec_t*		rec,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	ulint			i,
 	const page_size_t&	page_size,
 	ulint			max_len,
@@ -1223,7 +1223,7 @@ row_log_table_get_pk(
 				page X-latched */
 	dict_index_t*	index,	/*!< in/out: clustered index, S-latched
 				or X-latched */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec,index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec,index) */
 	byte*		sys,	/*!< out: DB_TRX_ID,DB_ROLL_PTR for
 				row_log_table_delete(), or NULL */
 	mem_heap_t**	heap)	/*!< in/out: memory heap where allocated */
@@ -1430,7 +1430,7 @@ row_log_table_insert(
 				page X-latched */
 	dict_index_t*	index,	/*!< in/out: clustered index, S-latched
 				or X-latched */
-	const ulint*	offsets)/*!< in: rec_get_offsets(rec,index) */
+	const offset_t*	offsets)/*!< in: rec_get_offsets(rec,index) */
 {
 	row_log_table_low(rec, index, offsets, true, NULL);
 }
@@ -1521,7 +1521,7 @@ row_log_table_apply_convert_mrec(
 /*=============================*/
 	const mrec_t*		mrec,		/*!< in: merge record */
 	dict_index_t*		index,		/*!< in: index of mrec */
-	const ulint*		offsets,	/*!< in: offsets of mrec */
+	const offset_t*		offsets,	/*!< in: offsets of mrec */
 	row_log_t*		log,		/*!< in: rebuild context */
 	mem_heap_t*		heap,		/*!< in/out: memory heap */
 	dberr_t*		error)		/*!< out: DB_SUCCESS or
@@ -1767,7 +1767,7 @@ row_log_table_apply_insert(
 /*=======================*/
 	que_thr_t*		thr,		/*!< in: query graph */
 	const mrec_t*		mrec,		/*!< in: record to insert */
-	const ulint*		offsets,	/*!< in: offsets of mrec */
+	const offset_t*		offsets,	/*!< in: offsets of mrec */
 	mem_heap_t*		offsets_heap,	/*!< in/out: memory heap
 						that can be emptied */
 	mem_heap_t*		heap,		/*!< in/out: memory heap */
@@ -1819,7 +1819,7 @@ row_log_table_apply_delete_low(
 /*===========================*/
 	btr_pcur_t*		pcur,		/*!< in/out: B-tree cursor,
 						will be trashed */
-	const ulint*		offsets,	/*!< in: offsets on pcur */
+	const offset_t*		offsets,	/*!< in: offsets on pcur */
 	mem_heap_t*		heap,		/*!< in/out: memory heap */
 	mtr_t*			mtr)		/*!< in/out: mini-transaction,
 						will be committed */
@@ -1912,7 +1912,7 @@ row_log_table_apply_delete(
 						DB_TRX_ID in the new
 						clustered index */
 	const mrec_t*		mrec,		/*!< in: merge record */
-	const ulint*		moffsets,	/*!< in: offsets of mrec */
+	const offset_t*		moffsets,	/*!< in: offsets of mrec */
 	mem_heap_t*		offsets_heap,	/*!< in/out: memory heap
 						that can be emptied */
 	mem_heap_t*		heap,		/*!< in/out: memory heap */
@@ -1923,7 +1923,7 @@ row_log_table_apply_delete(
 	dtuple_t*	old_pk;
 	mtr_t		mtr;
 	btr_pcur_t	pcur;
-	ulint*		offsets;
+	offset_t*	offsets;
 
 	ut_ad(rec_offs_n_fields(moffsets)
 	      == dict_index_get_n_unique(index) + 2);
@@ -2035,7 +2035,7 @@ row_log_table_apply_update(
 						DB_TRX_ID in the new
 						clustered index */
 	const mrec_t*		mrec,		/*!< in: new value */
-	const ulint*		offsets,	/*!< in: offsets of mrec */
+	const offset_t*		offsets,	/*!< in: offsets of mrec */
 	mem_heap_t*		offsets_heap,	/*!< in/out: memory heap
 						that can be emptied */
 	mem_heap_t*		heap,		/*!< in/out: memory heap */
@@ -2173,7 +2173,7 @@ func_exit_committed:
 	}
 
 	/* Prepare to update (or delete) the record. */
-	ulint*		cur_offsets	= rec_get_offsets(
+	offset_t*		cur_offsets	= rec_get_offsets(
 		btr_pcur_get_rec(&pcur), index, NULL, true,
 		ULINT_UNDEFINED, &offsets_heap);
 
@@ -2411,7 +2411,7 @@ row_log_table_apply_op(
 	mem_heap_t*		heap,		/*!< in/out: memory heap */
 	const mrec_t*		mrec,		/*!< in: merge record */
 	const mrec_t*		mrec_end,	/*!< in: end of buffer */
-	ulint*			offsets)	/*!< in/out: work area
+	offset_t*		offsets)	/*!< in/out: work area
 						for parsing mrec */
 {
 	row_log_t*	log	= dup->index->online_log;
@@ -2745,7 +2745,7 @@ row_log_table_apply_ops(
 	const mrec_t*	next_mrec_end;
 	mem_heap_t*	heap;
 	mem_heap_t*	offsets_heap;
-	ulint*		offsets;
+	offset_t*	offsets;
 	bool		has_index_lock;
 	dict_index_t*	index		= const_cast<dict_index_t*>(
 		dup->index);
@@ -2772,9 +2772,9 @@ row_log_table_apply_ops(
 
 	UNIV_MEM_INVALID(&mrec_end, sizeof mrec_end);
 
-	offsets = static_cast<ulint*>(ut_malloc_nokey(i * sizeof *offsets));
-	offsets[0] = i;
-	offsets[1] = dict_index_get_n_fields(index);
+	offsets = static_cast<offset_t*>(ut_malloc_nokey(i * sizeof *offsets));
+	rec_offs_set_n_alloc(offsets, i);
+	rec_offs_set_n_fields(offsets, dict_index_get_n_fields(index));
 
 	heap = mem_heap_create(srv_page_size);
 	offsets_heap = mem_heap_create(srv_page_size);
@@ -3318,7 +3318,7 @@ row_log_apply_op_low(
 {
 	mtr_t		mtr;
 	btr_cur_t	cursor;
-	ulint*		offsets = NULL;
+	offset_t*	offsets = NULL;
 
 	ut_ad(!dict_index_is_clust(index));
 
@@ -3552,14 +3552,13 @@ row_log_apply_op(
 					in exclusive mode */
 	const mrec_t*	mrec,		/*!< in: merge record */
 	const mrec_t*	mrec_end,	/*!< in: end of buffer */
-	ulint*		offsets)	/*!< in/out: work area for
+	offset_t*	offsets)	/*!< in/out: work area for
 					rec_init_offsets_temp() */
 
 {
 	enum row_op	op;
 	ulint		extra_size;
 	ulint		data_size;
-	ulint		n_ext;
 	dtuple_t*	entry;
 	trx_id_t	trx_id;
 
@@ -3637,10 +3636,10 @@ corrupted:
 	}
 
 	entry = row_rec_to_index_entry_low(
-		mrec - data_size, index, offsets, &n_ext, heap);
+		mrec - data_size, index, offsets, heap);
 	/* Online index creation is only implemented for secondary
 	indexes, which never contain off-page columns. */
-	ut_ad(n_ext == 0);
+	ut_ad(dtuple_get_n_ext(entry) == 0);
 
 	row_log_apply_op_low(index, dup, error, offsets_heap,
 			     has_index_lock, op, trx_id, entry);
@@ -3671,7 +3670,7 @@ row_log_apply_ops(
 	const mrec_t*	next_mrec_end;
 	mem_heap_t*	offsets_heap;
 	mem_heap_t*	heap;
-	ulint*		offsets;
+	offset_t*	offsets;
 	bool		has_index_lock;
 	const ulint	i	= 1 + REC_OFFS_HEADER_SIZE
 		+ dict_index_get_n_fields(index);
@@ -3682,9 +3681,9 @@ row_log_apply_ops(
 	ut_ad(index->online_log);
 	UNIV_MEM_INVALID(&mrec_end, sizeof mrec_end);
 
-	offsets = static_cast<ulint*>(ut_malloc_nokey(i * sizeof *offsets));
-	offsets[0] = i;
-	offsets[1] = dict_index_get_n_fields(index);
+	offsets = static_cast<offset_t*>(ut_malloc_nokey(i * sizeof *offsets));
+	rec_offs_set_n_alloc(offsets, i);
+	rec_offs_set_n_fields(offsets, dict_index_get_n_fields(index));
 
 	offsets_heap = mem_heap_create(srv_page_size);
 	heap = mem_heap_create(srv_page_size);
diff --git a/storage/innobase/row/row0merge.cc b/storage/innobase/row/row0merge.cc
index e488560b97f..68166705a3b 100644
--- a/storage/innobase/row/row0merge.cc
+++ b/storage/innobase/row/row0merge.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2005, 2017, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2014, 2019, MariaDB Corporation.
+Copyright (c) 2014, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -120,7 +120,7 @@ public:
 		btr_cur_t       ins_cur;
 		mtr_t           mtr;
 		rtr_info_t      rtr_info;
-		ulint*		ins_offsets = NULL;
+		offset_t*	ins_offsets = NULL;
 		dberr_t		error = DB_SUCCESS;
 		dtuple_t*	dtuple;
 		ulint		count = 0;
@@ -1046,8 +1046,8 @@ row_merge_heap_create(
 /*==================*/
 	const dict_index_t*	index,		/*!< in: record descriptor */
 	mrec_buf_t**		buf,		/*!< out: 3 buffers */
-	ulint**			offsets1,	/*!< out: offsets */
-	ulint**			offsets2)	/*!< out: offsets */
+	offset_t**		offsets1,	/*!< out: offsets */
+	offset_t**		offsets2)	/*!< out: offsets */
 {
 	ulint		i	= 1 + REC_OFFS_HEADER_SIZE
 		+ dict_index_get_n_fields(index);
@@ -1056,13 +1056,15 @@ row_merge_heap_create(
 
 	*buf = static_cast<mrec_buf_t*>(
 		mem_heap_alloc(heap, 3 * sizeof **buf));
-	*offsets1 = static_cast<ulint*>(
+	*offsets1 = static_cast<offset_t*>(
 		mem_heap_alloc(heap, i * sizeof **offsets1));
-	*offsets2 = static_cast<ulint*>(
+	*offsets2 = static_cast<offset_t*>(
 		mem_heap_alloc(heap, i * sizeof **offsets2));
 
-	(*offsets1)[0] = (*offsets2)[0] = i;
-	(*offsets1)[1] = (*offsets2)[1] = dict_index_get_n_fields(index);
+	rec_offs_set_n_alloc(*offsets1, i);
+	rec_offs_set_n_alloc(*offsets2, i);
+	rec_offs_set_n_fields(*offsets1, dict_index_get_n_fields(index));
+	rec_offs_set_n_fields(*offsets2, dict_index_get_n_fields(index));
 
 	return(heap);
 }
@@ -1178,7 +1180,7 @@ row_merge_read_rec(
 	const mrec_t**		mrec,	/*!< out: pointer to merge record,
 					or NULL on end of list
 					(non-NULL on I/O error) */
-	ulint*			offsets,/*!< out: offsets of mrec */
+	offset_t*		offsets,/*!< out: offsets of mrec */
 	row_merge_block_t*	crypt_block, /*!< in: crypt buf or NULL */
 	ulint			space) /*!< in: space id */
 {
@@ -1189,7 +1191,7 @@ row_merge_read_rec(
 	ut_ad(b >= &block[0]);
 	ut_ad(b < &block[srv_sort_buf_size]);
 
-	ut_ad(*offsets == 1 + REC_OFFS_HEADER_SIZE
+	ut_ad(rec_offs_get_n_alloc(offsets) == 1 + REC_OFFS_HEADER_SIZE
 	      + dict_index_get_n_fields(index));
 
 	DBUG_ENTER("row_merge_read_rec");
@@ -1296,12 +1298,7 @@ err_exit:
 	memcpy(*buf, b, avail_size);
 	*mrec = *buf + extra_size;
 
-	/* We cannot invoke rec_offs_make_valid() here, because there
-	are no REC_N_NEW_EXTRA_BYTES between extra_size and data_size.
-	Similarly, rec_offs_validate() would fail, because it invokes
-	rec_get_status(). */
-	ut_d(offsets[2] = (ulint) *mrec);
-	ut_d(offsets[3] = (ulint) index);
+	rec_init_offsets_temp(*mrec, index, offsets);
 
 	if (!row_merge_read(fd, ++(*foffs), block,
 			    crypt_block,
@@ -1340,7 +1337,7 @@ row_merge_write_rec_low(
 	ulint		foffs,	/*!< in: file offset */
 #endif /* !DBUG_OFF */
 	const mrec_t*	mrec,	/*!< in: record to write */
-	const ulint*	offsets)/*!< in: offsets of mrec */
+	const offset_t*	offsets)/*!< in: offsets of mrec */
 #ifdef DBUG_OFF
 # define row_merge_write_rec_low(b, e, size, fd, foffs, mrec, offsets)	\
 	row_merge_write_rec_low(b, e, mrec, offsets)
@@ -1382,7 +1379,7 @@ row_merge_write_rec(
 	const pfs_os_file_t&	fd,	/*!< in: file descriptor */
 	ulint*			foffs,	/*!< in/out: file offset */
 	const mrec_t*		mrec,	/*!< in: record to write */
-	const ulint*            offsets,/*!< in: offsets of mrec */
+	const offset_t*         offsets,/*!< in: offsets of mrec */
 	row_merge_block_t*	crypt_block, /*!< in: crypt buf or NULL */
 	ulint			space)	   /*!< in: space id */
 {
@@ -1929,7 +1926,7 @@ row_merge_read_clustered_index(
 
 		const rec_t*	rec;
 		trx_id_t	rec_trx_id;
-		ulint*		offsets;
+		offset_t*	offsets;
 		dtuple_t*	row;
 		row_ext_t*	ext;
 		page_cur_t*	cur	= btr_pcur_get_page_cur(&pcur);
@@ -2963,8 +2960,8 @@ row_merge_blocks(
 	const mrec_t*	mrec0;	/*!< merge rec, points to block[0] or buf[0] */
 	const mrec_t*	mrec1;	/*!< merge rec, points to
 				block[srv_sort_buf_size] or buf[1] */
-	ulint*		offsets0;/* offsets of mrec0 */
-	ulint*		offsets1;/* offsets of mrec1 */
+	offset_t*	offsets0;/* offsets of mrec0 */
+	offset_t*	offsets1;/* offsets of mrec1 */
 
 	DBUG_ENTER("row_merge_blocks");
 	DBUG_LOG("ib_merge_sort",
@@ -3081,8 +3078,8 @@ row_merge_blocks_copy(
 	const byte*	b0;	/*!< pointer to block[0] */
 	byte*		b2;	/*!< pointer to block[2 * srv_sort_buf_size] */
 	const mrec_t*	mrec0;	/*!< merge rec, points to block[0] */
-	ulint*		offsets0;/* offsets of mrec0 */
-	ulint*		offsets1;/* dummy offsets */
+	offset_t*	offsets0;/* offsets of mrec0 */
+	offset_t*	offsets1;/* dummy offsets */
 
 	DBUG_ENTER("row_merge_blocks_copy");
 	DBUG_LOG("ib_merge_sort",
@@ -3421,7 +3418,7 @@ static
 void
 row_merge_copy_blobs(
 	const mrec_t*		mrec,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	const page_size_t&	page_size,
 	dtuple_t*		tuple,
 	mem_heap_t*		heap)
@@ -3530,7 +3527,7 @@ row_merge_insert_index_tuples(
 	mem_heap_t*		tuple_heap;
 	dberr_t			error = DB_SUCCESS;
 	ulint			foffs = 0;
-	ulint*			offsets;
+	offset_t*		offsets;
 	mrec_buf_t*		buf;
 	ulint			n_rows = 0;
 	dtuple_t*		dtuple;
@@ -3538,7 +3535,6 @@ row_merge_insert_index_tuples(
 	double			curr_progress = 0;
 	dict_index_t*		old_index = NULL;
 	const mrec_t*		mrec  = NULL;
-	ulint			n_ext = 0;
 	mtr_t			mtr;
 
 
@@ -3558,10 +3554,10 @@ row_merge_insert_index_tuples(
 		ulint i	= 1 + REC_OFFS_HEADER_SIZE
 			+ dict_index_get_n_fields(index);
 		heap = mem_heap_create(sizeof *buf + i * sizeof *offsets);
-		offsets = static_cast<ulint*>(
+		offsets = static_cast<offset_t*>(
 			mem_heap_alloc(heap, i * sizeof *offsets));
-		offsets[0] = i;
-		offsets[1] = dict_index_get_n_fields(index);
+		rec_offs_set_n_alloc(offsets, i);
+		rec_offs_set_n_fields(offsets, dict_index_get_n_fields(index));
 	}
 
 	if (row_buf != NULL) {
@@ -3604,8 +3600,6 @@ row_merge_insert_index_tuples(
 			row buffer to data tuple record */
 			row_merge_mtuple_to_dtuple(
 				index, dtuple, &row_buf->tuples[n_rows]);
-
-			n_ext = dtuple_get_n_ext(dtuple);
 			n_rows++;
 			/* BLOB pointers must be copied from dtuple */
 			mrec = NULL;
@@ -3624,7 +3618,7 @@ row_merge_insert_index_tuples(
 			}
 
 			dtuple = row_rec_to_index_entry_low(
-				mrec, index, offsets, &n_ext, tuple_heap);
+				mrec, index, offsets, tuple_heap);
 		}
 
 		old_index	= dict_table_get_first_index(old_table);
@@ -3637,10 +3631,7 @@ row_merge_insert_index_tuples(
 			}
 		}
 
-		if (!n_ext) {
-			/* There are no externally stored columns. */
-		} else {
-			ut_ad(dict_index_is_clust(index));
+		if (dict_index_is_clust(index) && dtuple_get_n_ext(dtuple)) {
 			/* Off-page columns can be fetched safely
 			when concurrent modifications to the table
 			are disabled. (Purge can process delete-marked
diff --git a/storage/innobase/row/row0mysql.cc b/storage/innobase/row/row0mysql.cc
index fbd37216ed4..6bdc8ce4904 100644
--- a/storage/innobase/row/row0mysql.cc
+++ b/storage/innobase/row/row0mysql.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2000, 2018, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2015, 2019, MariaDB Corporation.
+Copyright (c) 2015, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -2063,8 +2063,8 @@ row_unlock_for_mysql(
 						     + index->trx_id_offset);
 		} else {
 			mem_heap_t*	heap			= NULL;
-			ulint	offsets_[REC_OFFS_NORMAL_SIZE];
-			ulint*	offsets				= offsets_;
+			offset_t offsets_[REC_OFFS_NORMAL_SIZE];
+			offset_t* offsets				= offsets_;
 
 			rec_offs_init(offsets_);
 			offsets = rec_get_offsets(rec, index, offsets, true,
@@ -3142,6 +3142,16 @@ row_discard_tablespace_for_mysql(
 	} else {
 		ut_ad(!table->n_foreign_key_checks_running);
 
+		bool fts_exist = (dict_table_has_fts_index(table)
+				  || DICT_TF2_FLAG_IS_SET(
+					  table, DICT_TF2_FTS_HAS_DOC_ID));
+
+		if (fts_exist) {
+			row_mysql_unlock_data_dictionary(trx);
+			fts_optimize_remove_table(table);
+			row_mysql_lock_data_dictionary(trx);
+		}
+
 		/* Do foreign key constraint checks. */
 
 		err = row_discard_tablespace_foreign_key_checks(trx, table);
@@ -3149,6 +3159,10 @@ row_discard_tablespace_for_mysql(
 		if (err == DB_SUCCESS) {
 			err = row_discard_tablespace(trx, table);
 		}
+
+		if (fts_exist && err != DB_SUCCESS) {
+			fts_optimize_add_table(table);
+		}
 	}
 
 	return(row_discard_tablespace_end(trx, table, err));
@@ -3842,6 +3856,11 @@ funct_exit_all_freed:
 			trx_commit_for_mysql(trx);
 		}
 
+		/* Add the table to fts queue if drop table fails */
+		if (err != DB_SUCCESS && table->fts) {
+			fts_optimize_add_table(table);
+		}
+
 		row_mysql_unlock_data_dictionary(trx);
 	}
 
@@ -4681,9 +4700,8 @@ row_scan_index_for_mysql(
 	ulint		i;
 	ulint		cnt;
 	mem_heap_t*	heap		= NULL;
-	ulint		n_ext;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets;
 	rec_offs_init(offsets_);
 
 	*n_rows = 0;
@@ -4816,14 +4834,14 @@ not_ok:
 
 			tmp_heap = mem_heap_create(size);
 
-			offsets = static_cast<ulint*>(
+			offsets = static_cast<offset_t*>(
 				mem_heap_dup(tmp_heap, offsets, size));
 		}
 
 		mem_heap_empty(heap);
 
 		prev_entry = row_rec_to_index_entry(
-			rec, index, offsets, &n_ext, heap);
+			rec, index, offsets, heap);
 
 		if (UNIV_LIKELY_NULL(tmp_heap)) {
 			mem_heap_free(tmp_heap);
diff --git a/storage/innobase/row/row0purge.cc b/storage/innobase/row/row0purge.cc
index b71f8491787..bca6d802a53 100644
--- a/storage/innobase/row/row0purge.cc
+++ b/storage/innobase/row/row0purge.cc
@@ -108,8 +108,8 @@ row_purge_remove_clust_if_poss_low(
 	mtr_t			mtr;
 	rec_t*			rec;
 	mem_heap_t*		heap		= NULL;
-	ulint*			offsets;
-	ulint			offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*		offsets;
+	offset_t		offsets_[REC_OFFS_NORMAL_SIZE];
 	rec_offs_init(offsets_);
 
 	ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_S)
@@ -801,9 +801,9 @@ static void row_purge_reset_trx_id(purge_node_t* node, mtr_t* mtr)
 		mem_heap_t*	heap = NULL;
 		/* Reserve enough offsets for the PRIMARY KEY and 2 columns
 		so that we can access DB_TRX_ID, DB_ROLL_PTR. */
-		ulint	offsets_[REC_OFFS_HEADER_SIZE + MAX_REF_PARTS + 2];
+		offset_t offsets_[REC_OFFS_HEADER_SIZE + MAX_REF_PARTS + 2];
 		rec_offs_init(offsets_);
-		ulint*	offsets = rec_get_offsets(
+		offset_t*	offsets = rec_get_offsets(
 			rec, index, offsets_, true, trx_id_pos + 2, &heap);
 		ut_ad(heap == NULL);
 
@@ -1381,7 +1381,7 @@ purge_node_t::validate_pcur()
 
 	dict_index_t*	clust_index = pcur.btr_cur.index;
 
-	ulint*	offsets = rec_get_offsets(
+	offset_t* offsets = rec_get_offsets(
 		pcur.old_rec, clust_index, NULL, true,
 		pcur.old_n_fields, &heap);
 
diff --git a/storage/innobase/row/row0row.cc b/storage/innobase/row/row0row.cc
index a2eb6ea6cf4..c19aa42b48e 100644
--- a/storage/innobase/row/row0row.cc
+++ b/storage/innobase/row/row0row.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1996, 2018, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2018, 2019, MariaDB Corporation.
+Copyright (c) 2018, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -393,7 +393,7 @@ row_build_low(
 	ulint			type,
 	const dict_index_t*	index,
 	const rec_t*		rec,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	const dict_table_t*	col_table,
 	const dtuple_t*		defaults,
 	const dict_add_v_col_t*	add_v,
@@ -409,7 +409,7 @@ row_build_low(
 	byte*			buf;
 	ulint			j;
 	mem_heap_t*		tmp_heap	= NULL;
-	ulint			offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t		offsets_[REC_OFFS_NORMAL_SIZE];
 	rec_offs_init(offsets_);
 
 	ut_ad(index != NULL);
@@ -457,7 +457,7 @@ row_build_low(
 	}
 
 	/* Avoid a debug assertion in rec_offs_validate(). */
-	rec_offs_make_valid(copy, index, true, const_cast<ulint*>(offsets));
+	rec_offs_make_valid(copy, index, true, const_cast<offset_t*>(offsets));
 
 	if (!col_table) {
 		ut_ad(!col_map);
@@ -551,7 +551,7 @@ row_build_low(
 		}
 	}
 
-	rec_offs_make_valid(rec, index, true, const_cast<ulint*>(offsets));
+	rec_offs_make_valid(rec, index, true, const_cast<offset_t*>(offsets));
 
 	ut_ad(dtuple_check_typed(row));
 
@@ -604,7 +604,7 @@ row_build(
 					this record must be at least
 					s-latched and the latch held
 					as long as the row dtuple is used! */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec,index)
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec,index)
 					or NULL, in which case this function
 					will invoke rec_get_offsets() */
 	const dict_table_t*	col_table,
@@ -657,7 +657,7 @@ row_build_w_add_vcol(
 	ulint			type,
 	const dict_index_t*	index,
 	const rec_t*		rec,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	const dict_table_t*	col_table,
 	const dtuple_t*		defaults,
 	const dict_add_v_col_t*	add_v,
@@ -684,8 +684,7 @@ dtuple_t*
 row_rec_to_index_entry_impl(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	const ulint*		offsets,
-	ulint*			n_ext,
+	const offset_t*		offsets,
 	mem_heap_t*		heap)
 {
 	dtuple_t*	entry;
@@ -703,8 +702,6 @@ row_rec_to_index_entry_impl(
 	/* Because this function may be invoked by row0merge.cc
 	on a record whose header is in different format, the check
 	rec_offs_validate(rec, index, offsets) must be avoided here. */
-	ut_ad(n_ext);
-	*n_ext = 0;
 
 	rec_len = rec_offs_n_fields(offsets);
 
@@ -731,7 +728,6 @@ row_rec_to_index_entry_impl(
 
 		if (rec_offs_nth_extern(offsets, i)) {
 			dfield_set_ext(dfield);
-			(*n_ext)++;
 		}
 	}
 
@@ -743,18 +739,15 @@ row_rec_to_index_entry_impl(
 @param[in]	rec	index record
 @param[in]	index	index
 @param[in]	offsets	rec_get_offsets(rec, index)
-@param[out]	n_ext	number of externally stored columns
 @param[in,out]	heap	memory heap for allocations */
 dtuple_t*
 row_rec_to_index_entry_low(
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	const ulint*		offsets,
-	ulint*			n_ext,
+	const offset_t*		offsets,
 	mem_heap_t*		heap)
 {
-	return row_rec_to_index_entry_impl<false>(
-		rec, index, offsets, n_ext, heap);
+	return row_rec_to_index_entry_impl<false>(rec, index, offsets, heap);
 }
 
 /*******************************************************************//**
@@ -766,9 +759,7 @@ row_rec_to_index_entry(
 /*===================*/
 	const rec_t*		rec,	/*!< in: record in the index */
 	const dict_index_t*	index,	/*!< in: index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec) */
-	ulint*			n_ext,	/*!< out: number of externally
-					stored columns */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec) */
 	mem_heap_t*		heap)	/*!< in: memory heap from which
 					the memory needed is allocated */
 {
@@ -788,11 +779,11 @@ row_rec_to_index_entry(
 	copy_rec = rec_copy(buf, rec, offsets);
 
 	rec_offs_make_valid(copy_rec, index, true,
-			    const_cast<ulint*>(offsets));
+			    const_cast<offset_t*>(offsets));
 	entry = row_rec_to_index_entry_impl<true>(
-		copy_rec, index, offsets, n_ext, heap);
+		copy_rec, index, offsets, heap);
 	rec_offs_make_valid(rec, index, true,
-			    const_cast<ulint*>(offsets));
+			    const_cast<offset_t*>(offsets));
 
 	dtuple_set_info_bits(entry,
 			     rec_get_info_bits(rec, rec_offs_comp(offsets)));
@@ -834,8 +825,8 @@ row_build_row_ref(
 	ulint		clust_col_prefix_len;
 	ulint		i;
 	mem_heap_t*	tmp_heap	= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(index != NULL);
@@ -930,7 +921,7 @@ row_build_row_ref_in_tuple(
 					held as long as the row
 					reference is used! */
 	const dict_index_t*	index,	/*!< in: secondary index */
-	ulint*			offsets)/*!< in: rec_get_offsets(rec, index)
+	offset_t*		offsets)/*!< in: rec_get_offsets(rec, index)
 					or NULL */
 {
 	const dict_index_t*	clust_index;
@@ -942,7 +933,7 @@ row_build_row_ref_in_tuple(
 	ulint			clust_col_prefix_len;
 	ulint			i;
 	mem_heap_t*		heap		= NULL;
-	ulint			offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t		offsets_[REC_OFFS_NORMAL_SIZE];
 	rec_offs_init(offsets_);
 
 	ut_ad(!dict_index_is_clust(index));
diff --git a/storage/innobase/row/row0sel.cc b/storage/innobase/row/row0sel.cc
index f3a17302864..c2b23caa513 100644
--- a/storage/innobase/row/row0sel.cc
+++ b/storage/innobase/row/row0sel.cc
@@ -171,10 +171,10 @@ row_sel_sec_rec_is_for_clust_rec(
 	ulint		n;
 	ulint		i;
 	mem_heap_t*	heap		= NULL;
-	ulint		clust_offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint		sec_offsets_[REC_OFFS_SMALL_SIZE];
-	ulint*		clust_offs	= clust_offsets_;
-	ulint*		sec_offs	= sec_offsets_;
+	offset_t	clust_offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t	sec_offsets_[REC_OFFS_SMALL_SIZE];
+	offset_t*	clust_offs	= clust_offsets_;
+	offset_t*	sec_offs	= sec_offsets_;
 	ibool		is_equal	= TRUE;
 	VCOL_STORAGE*	vcol_storage= 0;
 	byte*		record;
@@ -493,7 +493,7 @@ row_sel_fetch_columns(
 	dict_index_t*	index,	/*!< in: record index */
 	const rec_t*	rec,	/*!< in: record in a clustered or non-clustered
 				index; must be protected by a page latch */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	sym_node_t*	column)	/*!< in: first column in a column list, or
 				NULL */
 {
@@ -759,7 +759,7 @@ row_sel_build_prev_vers(
 	ReadView*	read_view,	/*!< in: read view */
 	dict_index_t*	index,		/*!< in: plan node for table */
 	rec_t*		rec,		/*!< in: record in a clustered index */
-	ulint**		offsets,	/*!< in/out: offsets returned by
+	offset_t**	offsets,	/*!< in/out: offsets returned by
 					rec_get_offsets(rec, plan->index) */
 	mem_heap_t**	offset_heap,	/*!< in/out: memory heap from which
 					the offsets are allocated */
@@ -794,7 +794,7 @@ row_sel_build_committed_vers_for_mysql(
 	dict_index_t*	clust_index,	/*!< in: clustered index */
 	row_prebuilt_t*	prebuilt,	/*!< in: prebuilt struct */
 	const rec_t*	rec,		/*!< in: record in a clustered index */
-	ulint**		offsets,	/*!< in/out: offsets returned by
+	offset_t**	offsets,	/*!< in/out: offsets returned by
 					rec_get_offsets(rec, clust_index) */
 	mem_heap_t**	offset_heap,	/*!< in/out: memory heap from which
 					the offsets are allocated */
@@ -908,8 +908,8 @@ row_sel_get_clust_rec(
 	rec_t*		old_vers;
 	dberr_t		err;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	*out_rec = NULL;
@@ -1068,7 +1068,7 @@ sel_set_rtr_rec_lock(
 	btr_pcur_t*		pcur,	/*!< in: cursor */
 	const rec_t*		first_rec,/*!< in: record */
 	dict_index_t*		index,	/*!< in: index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	ulint			mode,	/*!< in: lock mode */
 	ulint			type,	/*!< in: LOCK_ORDINARY, LOCK_GAP, or
 					LOC_REC_NOT_GAP */
@@ -1080,8 +1080,8 @@ sel_set_rtr_rec_lock(
 	dberr_t		err = DB_SUCCESS;
 	trx_t*		trx = thr_get_trx(thr);
 	buf_block_t*	cur_block = btr_pcur_get_block(pcur);
-	ulint           offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*          my_offsets = const_cast<ulint*>(offsets);
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	my_offsets = const_cast<offset_t*>(offsets);
 	rec_t*		rec = const_cast<rec_t*>(first_rec);
 	rtr_rec_vector*	match_rec;
 	rtr_rec_vector::iterator end;
@@ -1234,7 +1234,7 @@ sel_set_rec_lock(
 	btr_pcur_t*		pcur,	/*!< in: cursor */
 	const rec_t*		rec,	/*!< in: record */
 	dict_index_t*		index,	/*!< in: index */
-	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*		offsets,/*!< in: rec_get_offsets(rec, index) */
 	ulint			mode,	/*!< in: lock mode */
 	ulint			type,	/*!< in: LOCK_ORDINARY, LOCK_GAP, or
 					LOC_REC_NOT_GAP */
@@ -1509,8 +1509,8 @@ exhausted:
 	a previous version of the record */
 
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 	offsets = rec_get_offsets(rec, index, offsets, true,
 				  ULINT_UNDEFINED, &heap);
@@ -1593,8 +1593,8 @@ row_sel(
 	to the next non-clustered record */
 	dberr_t		err;
 	mem_heap_t*	heap				= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets				= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets				= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(thr->run_node == node);
@@ -2701,7 +2701,7 @@ row_sel_store_row_id_to_prebuilt(
 	row_prebuilt_t*		prebuilt,	/*!< in/out: prebuilt */
 	const rec_t*		index_rec,	/*!< in: record */
 	const dict_index_t*	index,		/*!< in: index of the record */
-	const ulint*		offsets)	/*!< in: rec_get_offsets
+	const offset_t*		offsets)	/*!< in: rec_get_offsets
 						(index_rec, index) */
 {
 	const byte*	data;
@@ -2927,7 +2927,7 @@ row_sel_store_mysql_field(
 	row_prebuilt_t*		prebuilt,
 	const rec_t*		rec,
 	const dict_index_t*	index,
-	const ulint*		offsets,
+	const offset_t*		offsets,
 	ulint			field_no,
 	const mysql_row_templ_t*templ)
 {
@@ -3083,7 +3083,7 @@ static bool row_sel_store_mysql_rec(
 	const dtuple_t*	vrow,
 	bool		rec_clust,
 	const dict_index_t* index,
-	const ulint*	offsets)
+	const offset_t*	offsets)
 {
 	DBUG_ENTER("row_sel_store_mysql_rec");
 
@@ -3214,7 +3214,7 @@ row_sel_build_prev_vers_for_mysql(
 	dict_index_t*	clust_index,	/*!< in: clustered index */
 	row_prebuilt_t*	prebuilt,	/*!< in: prebuilt struct */
 	const rec_t*	rec,		/*!< in: record in a clustered index */
-	ulint**		offsets,	/*!< in/out: offsets returned by
+	offset_t**	offsets,	/*!< in/out: offsets returned by
 					rec_get_offsets(rec, clust_index) */
 	mem_heap_t**	offset_heap,	/*!< in/out: memory heap from which
 					the offsets are allocated */
@@ -3252,7 +3252,7 @@ public:
 
 	dberr_t operator()(row_prebuilt_t *prebuilt, dict_index_t *sec_index,
 			const rec_t *rec, que_thr_t *thr, const rec_t **out_rec,
-			ulint **offsets, mem_heap_t **offset_heap,
+			offset_t **offsets, mem_heap_t **offset_heap,
 			dtuple_t **vrow, mtr_t *mtr);
 };
 
@@ -3275,7 +3275,7 @@ Row_sel_get_clust_rec_for_mysql::operator()(
 				it, NULL if the old version did not exist
 				in the read view, i.e., it was a fresh
 				inserted version */
-	ulint**		offsets,/*!< in: offsets returned by
+	offset_t**	offsets,/*!< in: offsets returned by
 				rec_get_offsets(rec, sec_index);
 				out: offsets returned by
 				rec_get_offsets(out_rec, clust_index) */
@@ -3856,7 +3856,7 @@ row_sel_try_search_shortcut_for_mysql(
 /*==================================*/
 	const rec_t**	out_rec,/*!< out: record if found */
 	row_prebuilt_t*	prebuilt,/*!< in: prebuilt struct */
-	ulint**		offsets,/*!< in/out: for rec_get_offsets(*out_rec) */
+	offset_t**	offsets,/*!< in/out: for rec_get_offsets(*out_rec) */
 	mem_heap_t**	heap,	/*!< in/out: heap for rec_get_offsets() */
 	mtr_t*		mtr)	/*!< in: started mtr */
 {
@@ -3930,7 +3930,7 @@ row_search_idx_cond_check(
 	row_prebuilt_t*		prebuilt,	/*!< in/out: prebuilt struct
 						for the table handle */
 	const rec_t*		rec,		/*!< in: InnoDB record */
-	const ulint*		offsets)	/*!< in: rec_get_offsets() */
+	const offset_t*		offsets)	/*!< in: rec_get_offsets() */
 {
 	ICP_RESULT	result;
 	ulint		i;
@@ -4018,8 +4018,8 @@ row_sel_fill_vrow(
 	dtuple_t**		vrow,
 	mem_heap_t*		heap)
 {
-	ulint           offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets	= offsets_;
+	offset_t offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t* offsets	= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(!(*vrow));
@@ -4073,7 +4073,7 @@ rec_field_len_in_chars(
 	const dict_col_t*	col,
 	const ulint		field_no,
 	const rec_t*		rec,
-	const ulint*		offsets)
+	const offset_t*		offsets)
 {
 	const ulint cset = dtype_get_charset_coll(col->prtype);
 	const CHARSET_INFO* cs = all_charsets[cset];
@@ -4100,7 +4100,7 @@ static
 bool row_search_with_covering_prefix(
 	row_prebuilt_t*	prebuilt,
 	const rec_t*	rec,
-	const ulint*	offsets)
+	const offset_t*	offsets)
 {
 	const dict_index_t*	index = prebuilt->index;
 	ut_ad(!dict_index_is_clust(index));
@@ -4230,8 +4230,8 @@ row_search_mvcc(
 	ibool		same_user_rec;
 	mtr_t		mtr;
 	mem_heap_t*	heap				= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets				= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets				= offsets_;
 	ibool		table_lock_waited		= FALSE;
 	byte*		next_buf			= 0;
 	bool		spatial_search			= false;
@@ -4272,7 +4272,7 @@ row_search_mvcc(
 		    || prebuilt->m_read_virtual_key);
 
 	/* Reset the new record lock info if srv_locks_unsafe_for_binlog
-	is set or session is using a READ COMMITED isolation level. Then
+	is set or session is using a READ COMMITTED isolation level. Then
 	we are able to remove the record locks set here on an individual
 	row. */
 	prebuilt->new_rec_locks = 0;
@@ -4979,7 +4979,7 @@ wrong_offs:
 		existence with LOCK_REC_NOT_GAP. */
 
 		/* If innodb_locks_unsafe_for_binlog option is used
-		or this session is using a READ COMMITED isolation
+		or this session is using a READ COMMITTED isolation
 		level we lock only the record, i.e., next-key locking is
 		not used. */
 
@@ -5931,8 +5931,8 @@ row_search_autoinc_read_column(
 	const byte*	data;
 	ib_uint64_t	value;
 	mem_heap_t*	heap = NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets	= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets	= offsets_;
 
 	rec_offs_init(offsets_);
 	ut_ad(page_rec_is_leaf(rec));
diff --git a/storage/innobase/row/row0uins.cc b/storage/innobase/row/row0uins.cc
index 46b70b48f17..1c24e7bd177 100644
--- a/storage/innobase/row/row0uins.cc
+++ b/storage/innobase/row/row0uins.cc
@@ -115,7 +115,7 @@ row_undo_ins_remove_clust_rec(
 	if (online && dict_index_is_online_ddl(index)) {
 		const rec_t*	rec	= btr_cur_get_rec(btr_cur);
 		mem_heap_t*	heap	= NULL;
-		const ulint*	offsets	= rec_get_offsets(
+		const offset_t*	offsets	= rec_get_offsets(
 			rec, index, NULL, true, ULINT_UNDEFINED, &heap);
 		row_log_table_delete(rec, index, offsets, NULL);
 		mem_heap_free(heap);
diff --git a/storage/innobase/row/row0umod.cc b/storage/innobase/row/row0umod.cc
index 0172d47b8e2..11de19ba62c 100644
--- a/storage/innobase/row/row0umod.cc
+++ b/storage/innobase/row/row0umod.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1997, 2017, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, 2019, MariaDB Corporation.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -76,7 +76,7 @@ dberr_t
 row_undo_mod_clust_low(
 /*===================*/
 	undo_node_t*	node,	/*!< in: row undo node */
-	ulint**		offsets,/*!< out: rec_get_offsets() on the record */
+	offset_t**	offsets,/*!< out: rec_get_offsets() on the record */
 	mem_heap_t**	offsets_heap,
 				/*!< in/out: memory heap that can be emptied */
 	mem_heap_t*	heap,	/*!< in/out: memory heap */
@@ -159,11 +159,11 @@ static ulint row_trx_id_offset(const rec_t* rec, const dict_index_t* index)
 	if (!trx_id_offset) {
 		/* Reserve enough offsets for the PRIMARY KEY and 2 columns
 		so that we can access DB_TRX_ID, DB_ROLL_PTR. */
-		ulint	offsets_[REC_OFFS_HEADER_SIZE + MAX_REF_PARTS + 2];
+		offset_t offsets_[REC_OFFS_HEADER_SIZE + MAX_REF_PARTS + 2];
 		rec_offs_init(offsets_);
 		mem_heap_t* heap = NULL;
 		const ulint trx_id_pos = index->n_uniq ? index->n_uniq : 1;
-		ulint* offsets = rec_get_offsets(rec, index, offsets_, true,
+		offset_t* offsets = rec_get_offsets(rec, index, offsets_, true,
 						 trx_id_pos + 1, &heap);
 		ut_ad(!heap);
 		ulint len;
@@ -186,6 +186,7 @@ static bool row_undo_mod_must_purge(undo_node_t* node, mtr_t* mtr)
 
 	btr_cur_t* btr_cur = btr_pcur_get_btr_cur(&node->pcur);
 	ut_ad(btr_cur->index->is_primary());
+	DEBUG_SYNC_C("rollback_purge_clust");
 
 	mtr->s_lock(&purge_sys.latch, __FILE__, __LINE__);
 
@@ -243,7 +244,7 @@ row_undo_mod_clust(
 
 	mem_heap_t*	heap		= mem_heap_create(1024);
 	mem_heap_t*	offsets_heap	= NULL;
-	ulint*		offsets		= NULL;
+	offset_t*	offsets		= NULL;
 	const dtuple_t*	rebuilt_old_pk;
 	byte		sys[DATA_TRX_ID_LEN + DATA_ROLL_PTR_LEN];
 
@@ -319,6 +320,7 @@ row_undo_mod_clust(
 	      == node->new_trx_id);
 
 	btr_pcur_commit_specify_mtr(pcur, &mtr);
+	DEBUG_SYNC_C("rollback_undo_pk");
 
 	if (err != DB_SUCCESS) {
 		goto func_exit;
@@ -403,7 +405,7 @@ row_undo_mod_clust(
 		ut_ad(index->n_uniq <= MAX_REF_PARTS);
 		/* Reserve enough offsets for the PRIMARY KEY and 2 columns
 		so that we can access DB_TRX_ID, DB_ROLL_PTR. */
-		ulint	offsets_[REC_OFFS_HEADER_SIZE + MAX_REF_PARTS + 2];
+		offset_t offsets_[REC_OFFS_HEADER_SIZE + MAX_REF_PARTS + 2];
 		rec_offs_init(offsets_);
 		offsets = rec_get_offsets(
 			rec, index, offsets_, true, trx_id_pos + 2, &heap);
@@ -696,7 +698,7 @@ try_again:
 	switch (search_result) {
 		mem_heap_t*	heap;
 		mem_heap_t*	offsets_heap;
-		ulint*		offsets;
+		offset_t*	offsets;
 	case ROW_BUFFERED:
 	case ROW_NOT_DELETED_REF:
 		/* These are invalid outcomes, because the mode passed
diff --git a/storage/innobase/row/row0undo.cc b/storage/innobase/row/row0undo.cc
index 2c67c2c3442..a8d09b71dc2 100644
--- a/storage/innobase/row/row0undo.cc
+++ b/storage/innobase/row/row0undo.cc
@@ -168,8 +168,8 @@ row_undo_search_clust_to_pcur(
 	row_ext_t**	ext;
 	const rec_t*	rec;
 	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets		= offsets_;
 	rec_offs_init(offsets_);
 
 	ut_ad(!node->table->skip_alter_undo);
diff --git a/storage/innobase/row/row0upd.cc b/storage/innobase/row/row0upd.cc
index 06cd1e93166..aff8ae125b5 100644
--- a/storage/innobase/row/row0upd.cc
+++ b/storage/innobase/row/row0upd.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1996, 2017, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2015, 2019, MariaDB Corporation.
+Copyright (c) 2015, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -214,7 +214,7 @@ row_upd_check_references_constraints(
 				cursor position is lost in this function! */
 	dict_table_t*	table,	/*!< in: table in question */
 	dict_index_t*	index,	/*!< in: index of the cursor */
-	ulint*		offsets,/*!< in/out: rec_get_offsets(pcur.rec, index) */
+	offset_t*	offsets,/*!< in/out: rec_get_offsets(pcur.rec, index) */
 	que_thr_t*	thr,	/*!< in: query thread */
 	mtr_t*		mtr)	/*!< in: mtr */
 {
@@ -223,7 +223,6 @@ row_upd_check_references_constraints(
 	dtuple_t*	entry;
 	trx_t*		trx;
 	const rec_t*	rec;
-	ulint		n_ext;
 	dberr_t		err;
 	ibool		got_s_lock	= FALSE;
 
@@ -240,7 +239,7 @@ row_upd_check_references_constraints(
 
 	heap = mem_heap_create(500);
 
-	entry = row_rec_to_index_entry(rec, index, offsets, &n_ext, heap);
+	entry = row_rec_to_index_entry(rec, index, offsets, heap);
 
 	mtr_commit(mtr);
 
@@ -332,7 +331,7 @@ wsrep_row_upd_check_foreign_constraints(
 				cursor position is lost in this function! */
 	dict_table_t*	table,	/*!< in: table in question */
 	dict_index_t*	index,	/*!< in: index of the cursor */
-	ulint*		offsets,/*!< in/out: rec_get_offsets(pcur.rec, index) */
+	offset_t*	offsets,/*!< in/out: rec_get_offsets(pcur.rec, index) */
 	que_thr_t*	thr,	/*!< in: query thread */
 	mtr_t*		mtr)	/*!< in: mtr */
 {
@@ -341,7 +340,6 @@ wsrep_row_upd_check_foreign_constraints(
 	dtuple_t*	entry;
 	trx_t*		trx;
 	const rec_t*	rec;
-	ulint		n_ext;
 	dberr_t		err;
 	ibool		got_s_lock	= FALSE;
 	ibool		opened     	= FALSE;
@@ -359,8 +357,7 @@ wsrep_row_upd_check_foreign_constraints(
 
 	heap = mem_heap_create(500);
 
-	entry = row_rec_to_index_entry(rec, index, offsets,
-				       &n_ext, heap);
+	entry = row_rec_to_index_entry(rec, index, offsets, heap);
 
 	mtr_commit(mtr);
 
@@ -473,7 +470,7 @@ row_upd_rec_sys_fields_in_recovery(
 /*===============================*/
 	rec_t*		rec,	/*!< in/out: record */
 	page_zip_des_t*	page_zip,/*!< in/out: compressed page, or NULL */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	ulint		pos,	/*!< in: TRX_ID position in rec */
 	trx_id_t	trx_id,	/*!< in: transaction id */
 	roll_ptr_t	roll_ptr)/*!< in: roll ptr of the undo log record */
@@ -537,7 +534,7 @@ ibool
 row_upd_changes_field_size_or_external(
 /*===================================*/
 	dict_index_t*	index,	/*!< in: index */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	const upd_t*	update)	/*!< in: update vector */
 {
 	const upd_field_t*	upd_field;
@@ -662,7 +659,7 @@ row_upd_rec_in_place(
 /*=================*/
 	rec_t*		rec,	/*!< in/out: record where replaced */
 	dict_index_t*	index,	/*!< in: the index the record belongs to */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	const upd_t*	update,	/*!< in: update vector */
 	page_zip_des_t*	page_zip)/*!< in: compressed page with enough space
 				available, or NULL */
@@ -961,7 +958,7 @@ row_upd_build_sec_rec_difference_binary(
 /*====================================*/
 	const rec_t*	rec,	/*!< in: secondary index record */
 	dict_index_t*	index,	/*!< in: index */
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec, index) */
 	const dtuple_t*	entry,	/*!< in: entry to insert */
 	mem_heap_t*	heap)	/*!< in: memory heap from which allocated */
 {
@@ -1042,7 +1039,7 @@ row_upd_build_difference_binary(
 	dict_index_t*	index,
 	const dtuple_t*	entry,
 	const rec_t*	rec,
-	const ulint*	offsets,
+	const offset_t*	offsets,
 	bool		no_sys,
 	trx_t*		trx,
 	mem_heap_t*	heap,
@@ -1053,7 +1050,7 @@ row_upd_build_difference_binary(
 	upd_t*		update;
 	ulint		n_diff;
 	ulint		trx_id_pos;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
 	const ulint	n_v_fld = dtuple_get_n_v_fields(entry);
 	rec_offs_init(offsets_);
 
@@ -2072,7 +2069,7 @@ void
 row_upd_copy_columns(
 /*=================*/
 	rec_t*		rec,	/*!< in: record in a clustered index */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	const offset_t*	offsets,/*!< in: array returned by rec_get_offsets() */
 	const dict_index_t*	index, /*!< in: index of rec */
 	sym_node_t*	column)	/*!< in: first column in a column list, or
 				NULL */
@@ -2224,8 +2221,8 @@ row_upd_store_row(
 	rec_t*		rec;
 	mem_heap_t*	heap		= NULL;
 	row_ext_t**	ext;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	const ulint*	offsets;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	const offset_t*	offsets;
 	rec_offs_init(offsets_);
 
 	ut_ad(node->pcur->latch_mode != BTR_NO_LATCHES);
@@ -2464,7 +2461,7 @@ row_upd_sec_index_entry(
 			    && wsrep_must_process_fk(node, trx)
 			    && !wsrep_thd_is_BF(trx->mysql_thd, FALSE)) {
 
-				ulint*	offsets = rec_get_offsets(
+				offset_t* offsets = rec_get_offsets(
 					rec, index, NULL, true,
 					ULINT_UNDEFINED, &heap);
 
@@ -2509,7 +2506,7 @@ row_upd_sec_index_entry(
 
 		if (referenced) {
 
-			ulint*	offsets;
+			offset_t* offsets;
 
 			offsets = rec_get_offsets(
 				rec, index, NULL, true, ULINT_UNDEFINED,
@@ -2591,7 +2588,7 @@ row_upd_clust_rec_by_insert_inherit_func(
 /*=====================================*/
 	const rec_t*	rec,	/*!< in: old record, or NULL */
 #ifdef UNIV_DEBUG
-	const ulint*	offsets,/*!< in: rec_get_offsets(rec), or NULL */
+	const offset_t*	offsets,/*!< in: rec_get_offsets(rec), or NULL */
 #endif /* UNIV_DEBUG */
 	dtuple_t*	entry,	/*!< in/out: updated entry to be
 				inserted into the clustered index */
@@ -2692,10 +2689,13 @@ row_upd_clust_rec_by_insert(
 	dtuple_t*	entry;
 	dberr_t		err;
 	rec_t*		rec;
-	ulint*		offsets			= NULL;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets			= offsets_;
 
 	ut_ad(dict_index_is_clust(index));
 
+	rec_offs_init(offsets_);
+
 	trx = thr_get_trx(thr);
 	table = node->table;
 	pcur = node->pcur;
@@ -2724,7 +2724,7 @@ row_upd_clust_rec_by_insert(
 		we update the primary key.  Delete-mark the old record
 		in the clustered index and prepare to insert a new entry. */
 		rec = btr_cur_get_rec(btr_cur);
-		offsets = rec_get_offsets(rec, index, NULL, true,
+		offsets = rec_get_offsets(rec, index, offsets, true,
 					  ULINT_UNDEFINED, &heap);
 		ut_ad(page_rec_is_user_rec(rec));
 
@@ -2809,9 +2809,9 @@ check_fk:
 
 	mtr_commit(mtr);
 
-	err = row_ins_clust_index_entry(
-		index, entry, thr,
-		node->upd_ext ? node->upd_ext->n_ext : 0);
+	err = row_ins_clust_index_entry(index, entry, thr, node->upd_ext
+					? node->upd_ext->n_ext
+					: dtuple_get_n_ext(entry));
 	node->state = UPD_NODE_INSERT_CLUSTERED;
 
 	mem_heap_free(heap);
@@ -2831,7 +2831,7 @@ row_upd_clust_rec(
 	ulint		flags,  /*!< in: undo logging and locking flags */
 	upd_node_t*	node,	/*!< in: row update node */
 	dict_index_t*	index,	/*!< in: clustered index */
-	ulint*		offsets,/*!< in: rec_get_offsets() on node->pcur */
+	offset_t*	offsets,/*!< in: rec_get_offsets() on node->pcur */
 	mem_heap_t**	offsets_heap,
 				/*!< in/out: memory heap, can be emptied */
 	que_thr_t*	thr,	/*!< in: query thread */
@@ -2962,7 +2962,7 @@ row_upd_del_mark_clust_rec(
 /*=======================*/
 	upd_node_t*	node,	/*!< in: row update node */
 	dict_index_t*	index,	/*!< in: clustered index */
-	ulint*		offsets,/*!< in/out: rec_get_offsets() for the
+	offset_t*	offsets,/*!< in/out: rec_get_offsets() for the
 				record under the cursor */
 	que_thr_t*	thr,	/*!< in: query thread */
 	ibool		referenced,
@@ -3057,8 +3057,8 @@ row_upd_clust_step(
 	mtr_t		mtr;
 	rec_t*		rec;
 	mem_heap_t*	heap	= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets;
+	offset_t	offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	offsets;
 	ibool		referenced;
 	ulint		flags;
 	trx_t*		trx = thr_get_trx(thr);
diff --git a/storage/innobase/row/row0vers.cc b/storage/innobase/row/row0vers.cc
index b662ce92f28..5935b0a11ca 100644
--- a/storage/innobase/row/row0vers.cc
+++ b/storage/innobase/row/row0vers.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1997, 2017, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, 2019, MariaDB Corporation.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -87,17 +87,20 @@ row_vers_impl_x_locked_low(
 	dict_index_t*	clust_index,
 	const rec_t*	rec,
 	dict_index_t*	index,
-	const ulint*	offsets,
+	const offset_t*	offsets,
 	mtr_t*		mtr)
 {
 	trx_id_t	trx_id;
 	rec_t*		prev_version = NULL;
-	ulint*		clust_offsets;
+	offset_t	clust_offsets_[REC_OFFS_NORMAL_SIZE];
+	offset_t*	clust_offsets = clust_offsets_;
 	mem_heap_t*	heap;
 	dtuple_t*	ientry = NULL;
 	mem_heap_t*	v_heap = NULL;
 	dtuple_t*	cur_vrow = NULL;
 
+	rec_offs_init(clust_offsets_);
+
 	DBUG_ENTER("row_vers_impl_x_locked_low");
 
 	ut_ad(rec_offs_validate(rec, index, offsets));
@@ -112,8 +115,8 @@ row_vers_impl_x_locked_low(
 
 	heap = mem_heap_create(1024);
 
-	clust_offsets = rec_get_offsets(
-		clust_rec, clust_index, NULL, true, ULINT_UNDEFINED, &heap);
+	clust_offsets = rec_get_offsets(clust_rec, clust_index, clust_offsets,
+					true, ULINT_UNDEFINED, &heap);
 
 	trx_id = row_get_rec_trx_id(clust_rec, clust_index, clust_offsets);
 	if (trx_id == 0) {
@@ -150,15 +153,13 @@ row_vers_impl_x_locked_low(
 	const ulint rec_del = rec_get_deleted_flag(rec, comp);
 
 	if (dict_index_has_virtual(index)) {
-		ulint	n_ext;
 		ulint	est_size = DTUPLE_EST_ALLOC(index->n_fields);
 
 		/* Allocate the dtuple for virtual columns extracted from undo
 		log with its own heap, so to avoid it being freed as we
 		iterating in the version loop below. */
 		v_heap = mem_heap_create(est_size);
-		ientry = row_rec_to_index_entry(
-			rec, index, offsets, &n_ext, v_heap);
+		ientry = row_rec_to_index_entry(rec, index, offsets, v_heap);
 	}
 
 	/* We look up if some earlier version, which was modified by
@@ -203,7 +204,7 @@ row_vers_impl_x_locked_low(
 		ut_ad(committed || prev_version
 		      || !rec_get_deleted_flag(version, comp));
 
-		/* Free version and clust_offsets. */
+		/* Free version. */
 		mem_heap_free(old_heap);
 
 		if (committed) {
@@ -238,7 +239,7 @@ not_locked:
 		}
 
 		clust_offsets = rec_get_offsets(
-			prev_version, clust_index, NULL, true,
+			prev_version, clust_index, clust_offsets, true,
 			ULINT_UNDEFINED, &heap);
 
 		vers_del = rec_get_deleted_flag(prev_version, comp);
@@ -387,7 +388,7 @@ row_vers_impl_x_locked(
 	trx_t*		caller_trx,
 	const rec_t*	rec,
 	dict_index_t*	index,
-	const ulint*	offsets)
+	const offset_t*	offsets)
 {
 	mtr_t		mtr;
 	trx_t*		trx;
@@ -519,7 +520,7 @@ row_vers_build_cur_vrow_low(
 	bool			in_purge,
 	const rec_t*		rec,
 	dict_index_t*		clust_index,
-	ulint*			clust_offsets,
+	offset_t*		clust_offsets,
 	dict_index_t*		index,
 	roll_ptr_t		roll_ptr,
 	trx_id_t		trx_id,
@@ -635,7 +636,7 @@ row_vers_vc_matches_cluster(
 	const rec_t*	rec,
 	const dtuple_t* icentry,
 	dict_index_t*	clust_index,
-	ulint*		clust_offsets,
+	offset_t*	clust_offsets,
 	dict_index_t*	index,
 	const dtuple_t* ientry,
 	roll_ptr_t	roll_ptr,
@@ -810,7 +811,7 @@ row_vers_build_cur_vrow(
 	bool			in_purge,
 	const rec_t*		rec,
 	dict_index_t*		clust_index,
-	ulint**			clust_offsets,
+	offset_t**		clust_offsets,
 	dict_index_t*		index,
 	roll_ptr_t		roll_ptr,
 	trx_id_t		trx_id,
@@ -894,7 +895,7 @@ row_vers_old_has_index_entry(
 	const rec_t*	version;
 	rec_t*		prev_version;
 	dict_index_t*	clust_index;
-	ulint*		clust_offsets;
+	offset_t*	clust_offsets;
 	mem_heap_t*	heap;
 	mem_heap_t*	heap2;
 	dtuple_t*	row;
@@ -1151,7 +1152,7 @@ row_vers_build_for_consistent_read(
 				of this records */
 	mtr_t*		mtr,	/*!< in: mtr holding the latch on rec */
 	dict_index_t*	index,	/*!< in: the clustered index */
-	ulint**		offsets,/*!< in/out: offsets returned by
+	offset_t**	offsets,/*!< in/out: offsets returned by
 				rec_get_offsets(rec, index) */
 	ReadView*	view,	/*!< in: the consistent read view */
 	mem_heap_t**	offset_heap,/*!< in/out: memory heap from which
@@ -1267,7 +1268,7 @@ row_vers_build_for_semi_consistent_read(
 				of this records */
 	mtr_t*		mtr,	/*!< in: mtr holding the latch on rec */
 	dict_index_t*	index,	/*!< in: the clustered index */
-	ulint**		offsets,/*!< in/out: offsets returned by
+	offset_t**	offsets,/*!< in/out: offsets returned by
 				rec_get_offsets(rec, index) */
 	mem_heap_t**	offset_heap,/*!< in/out: memory heap from which
 				the offsets are allocated */
diff --git a/storage/innobase/srv/srv0mon.cc b/storage/innobase/srv/srv0mon.cc
index b56ffe99624..0404335574a 100644
--- a/storage/innobase/srv/srv0mon.cc
+++ b/storage/innobase/srv/srv0mon.cc
@@ -423,7 +423,7 @@ static monitor_info_t	innodb_counter_info[] =
 	 MONITOR_DEFAULT_START, MONITOR_FLUSH_AVG_TIME},
 
 	{"buffer_flush_adaptive_avg_pass", "buffer",
-	 "Numner of adaptive flushes passed during the recent Avg period.",
+	 "Number of adaptive flushes passed during the recent Avg period.",
 	 MONITOR_NONE,
 	 MONITOR_DEFAULT_START, MONITOR_FLUSH_ADAPTIVE_AVG_PASS},
 
diff --git a/storage/innobase/srv/srv0srv.cc b/storage/innobase/srv/srv0srv.cc
index 556329e138e..6e7b3e5939f 100644
--- a/storage/innobase/srv/srv0srv.cc
+++ b/storage/innobase/srv/srv0srv.cc
@@ -3,7 +3,7 @@
 Copyright (c) 1995, 2017, Oracle and/or its affiliates. All Rights Reserved.
 Copyright (c) 2008, 2009 Google Inc.
 Copyright (c) 2009, Percona Inc.
-Copyright (c) 2013, 2019, MariaDB Corporation.
+Copyright (c) 2013, 2020, MariaDB Corporation.
 
 Portions of this file contain modifications contributed and copyrighted by
 Google, Inc. Those modifications are gratefully acknowledged and are described
@@ -487,7 +487,9 @@ current_time % 60 == 0 and no tasks will be performed when
 current_time % 5 != 0. */
 
 # define	SRV_MASTER_CHECKPOINT_INTERVAL		(7)
-# define	SRV_MASTER_PURGE_INTERVAL		(10)
+#ifdef MEM_PERIODIC_CHECK
+# define	SRV_MASTER_MEM_VALIDATE_INTERVAL	(13)
+#endif /* MEM_PERIODIC_CHECK */
 # define	SRV_MASTER_DICT_LRU_INTERVAL		(47)
 
 /** Simulate compression failures. */
diff --git a/storage/innobase/sync/sync0debug.cc b/storage/innobase/sync/sync0debug.cc
index 15c0a952cb0..b4bfde46b8f 100644
--- a/storage/innobase/sync/sync0debug.cc
+++ b/storage/innobase/sync/sync0debug.cc
@@ -1562,7 +1562,7 @@ struct CreateTracker {
 	~CreateTracker()
 		UNIV_NOTHROW
 	{
-		ut_d(m_files.empty());
+		ut_ad(m_files.empty());
 
 		m_mutex.destroy();
 	}
diff --git a/storage/innobase/trx/trx0i_s.cc b/storage/innobase/trx/trx0i_s.cc
index a39fb5d2e95..c45c4f6a182 100644
--- a/storage/innobase/trx/trx0i_s.cc
+++ b/storage/innobase/trx/trx0i_s.cc
@@ -599,7 +599,7 @@ put_nth_field(
 	ulint			n,	/*!< in: number of field */
 	const dict_index_t*	index,	/*!< in: index */
 	const rec_t*		rec,	/*!< in: record */
-	const ulint*		offsets)/*!< in: record offsets, returned
+	const offset_t*		offsets)/*!< in: record offsets, returned
 					by rec_get_offsets() */
 {
 	const byte*	data;
@@ -680,8 +680,8 @@ fill_lock_data(
 	const dict_index_t*	index;
 	ulint			n_fields;
 	mem_heap_t*		heap;
-	ulint			offsets_onstack[REC_OFFS_NORMAL_SIZE];
-	ulint*			offsets;
+	offset_t		offsets_onstack[REC_OFFS_NORMAL_SIZE];
+	offset_t*		offsets;
 	char			buf[TRX_I_S_LOCK_DATA_MAX_LEN];
 	ulint			buf_used;
 	ulint			i;
diff --git a/storage/innobase/trx/trx0rec.cc b/storage/innobase/trx/trx0rec.cc
index 901dd90c005..ab17dd03a43 100644
--- a/storage/innobase/trx/trx0rec.cc
+++ b/storage/innobase/trx/trx0rec.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
-Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, 2019, MariaDB Corporation.
+Copyright (c) 1996, 2019, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -868,7 +868,7 @@ trx_undo_page_report_modify(
 					delete marking is done */
 	const rec_t*	rec,		/*!< in: clustered index record which
 					has NOT yet been modified */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec, index) */
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec, index) */
 	const upd_t*	update,		/*!< in: update vector which tells the
 					columns to be updated; in the case of
 					a delete, this should be set to NULL */
@@ -1967,7 +1967,7 @@ trx_undo_report_row_operation(
 	const rec_t*	rec,		/*!< in: case of an update or delete
 					marking, the record in the clustered
 					index; NULL if insert */
-	const ulint*	offsets,	/*!< in: rec_get_offsets(rec) */
+	const offset_t*	offsets,	/*!< in: rec_get_offsets(rec) */
 	roll_ptr_t*	roll_ptr)	/*!< out: DB_ROLL_PTR to the
 					undo log record */
 {
@@ -2225,7 +2225,7 @@ trx_undo_prev_version_build(
 				index_rec page and purge_view */
 	const rec_t*	rec,	/*!< in: version of a clustered index record */
 	dict_index_t*	index,	/*!< in: clustered index */
-	ulint*		offsets,/*!< in/out: rec_get_offsets(rec, index) */
+	offset_t*	offsets,/*!< in/out: rec_get_offsets(rec, index) */
 	mem_heap_t*	heap,	/*!< in: memory heap from which the memory
 				needed is allocated */
 	rec_t**		old_vers,/*!< out, own: previous version, or NULL if
@@ -2335,8 +2335,6 @@ trx_undo_prev_version_build(
 	ut_a(ptr);
 
 	if (row_upd_changes_field_size_or_external(index, offsets, update)) {
-		ulint	n_ext;
-
 		/* We should confirm the existence of disowned external data,
 		if the previous version record is delete marked. If the trx_id
 		of the previous record is seen by purge view, we should treat
@@ -2377,14 +2375,15 @@ trx_undo_prev_version_build(
 		those fields that update updates to become externally stored
 		fields. Store the info: */
 
-		entry = row_rec_to_index_entry(
-			rec, index, offsets, &n_ext, heap);
-		n_ext += btr_push_update_extern_fields(entry, update, heap);
+		entry = row_rec_to_index_entry(rec, index, offsets, heap);
 		/* The page containing the clustered index record
 		corresponding to entry is latched in mtr.  Thus the
 		following call is safe. */
 		row_upd_index_replace_new_col_vals(entry, index, update, heap);
 
+		/* Get number of externally stored columns in updated record */
+		const ulint n_ext = dtuple_get_n_ext(entry);
+
 		buf = static_cast<byte*>(mem_heap_alloc(
 			heap, rec_get_converted_size(index, entry, n_ext)));
 
@@ -2407,8 +2406,10 @@ trx_undo_prev_version_build(
 	}
 
 #if defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG
+	offset_t offsets_dbg[REC_OFFS_NORMAL_SIZE];
+	rec_offs_init(offsets_dbg);
 	ut_a(!rec_offs_any_null_extern(
-		*old_vers, rec_get_offsets(*old_vers, index, NULL, true,
+		*old_vers, rec_get_offsets(*old_vers, index, offsets_dbg, true,
 					   ULINT_UNDEFINED, &heap)));
 #endif // defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG
 
diff --git a/storage/innobase/trx/trx0undo.cc b/storage/innobase/trx/trx0undo.cc
index 7a0accf889f..2c061965e34 100644
--- a/storage/innobase/trx/trx0undo.cc
+++ b/storage/innobase/trx/trx0undo.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2014, 2018, MariaDB Corporation.
+Copyright (c) 2014, 2019, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -1607,7 +1607,7 @@ trx_undo_commit_cleanup(trx_undo_t* undo, bool is_temp)
 
 		/* Delete first the undo log segment in the file */
 		mutex_exit(&rseg->mutex);
-		trx_undo_seg_free(undo, true);
+		trx_undo_seg_free(undo, is_temp);
 		mutex_enter(&rseg->mutex);
 
 		ut_ad(rseg->curr_size > undo->size);
diff --git a/storage/innobase/ut/ut0rnd.cc b/storage/innobase/ut/ut0rnd.cc
index 3c1e51536a1..8265121ef2e 100644
--- a/storage/innobase/ut/ut0rnd.cc
+++ b/storage/innobase/ut/ut0rnd.cc
@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
+Copyright (c) 2019, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -25,6 +26,9 @@ Created 5/11/1994 Heikki Tuuri
 
 #include "ut0rnd.h"
 
+/** Seed value of ut_rnd_gen() */
+int32 ut_rnd_current;
+
 /** These random numbers are used in ut_find_prime */
 /*@{*/
 #define	UT_RANDOM_1	1.0412321
@@ -32,9 +36,6 @@ Created 5/11/1994 Heikki Tuuri
 #define UT_RANDOM_3	1.0132677
 /*@}*/
 
-/** Seed value of ut_rnd_gen_ulint(). */
-ulint	ut_rnd_ulint_counter = 65654363;
-
 /***********************************************************//**
 Looks for a prime number slightly greater than the given argument.
 The prime is chosen so that it is not near any power of 2.
diff --git a/storage/maria/ha_maria.cc b/storage/maria/ha_maria.cc
index 71456666fbe..1745e1fa653 100644
--- a/storage/maria/ha_maria.cc
+++ b/storage/maria/ha_maria.cc
@@ -1157,7 +1157,7 @@ int ha_maria::open(const char *name, int mode, uint test_if_locked)
 
   /*
     For static size rows, tell MariaDB that we will access all bytes
-    in the record when writing it.  This signals MariaDB to initalize
+    in the record when writing it.  This signals MariaDB to initialize
     the full row to ensure we don't get any errors from valgrind and
     that all bytes in the row is properly reset.
   */
diff --git a/storage/maria/ma_check.c b/storage/maria/ma_check.c
index eadac5b04eb..101c33b7802 100644
--- a/storage/maria/ma_check.c
+++ b/storage/maria/ma_check.c
@@ -6183,7 +6183,7 @@ end:
 }
 
 
-	/* write suffix to data file if neaded */
+/* Write suffix to data file if needed */
 
 int maria_write_data_suffix(MARIA_SORT_INFO *sort_info, my_bool fix_datafile)
 {
diff --git a/storage/maria/ma_close.c b/storage/maria/ma_close.c
index 44f65230c5d..2716f3b5c42 100644
--- a/storage/maria/ma_close.c
+++ b/storage/maria/ma_close.c
@@ -37,7 +37,7 @@ int maria_close(register MARIA_HA *info)
 
   /* Check that we have unlocked key delete-links properly */
   DBUG_ASSERT(info->key_del_used == 0);
-  /* Check that file is not part of any uncommited transactions */
+  /* Check that file is not part of any uncommitted transactions */
   DBUG_ASSERT(info->trn == 0 || info->trn == &dummy_transaction_object);
 
   if (share->reopen == 1)
diff --git a/storage/maria/ma_page.c b/storage/maria/ma_page.c
index 41278597b0c..2c628184b28 100644
--- a/storage/maria/ma_page.c
+++ b/storage/maria/ma_page.c
@@ -112,7 +112,7 @@ my_bool _ma_fetch_keypage(MARIA_PAGE *page, MARIA_HA *info,
 
   if (lock != PAGECACHE_LOCK_LEFT_UNLOCKED)
   {
-    DBUG_ASSERT(lock == PAGECACHE_LOCK_WRITE || PAGECACHE_LOCK_READ);
+    DBUG_ASSERT(lock == PAGECACHE_LOCK_WRITE || lock == PAGECACHE_LOCK_READ);
     page_link.unlock= (lock == PAGECACHE_LOCK_WRITE ?
                        PAGECACHE_LOCK_WRITE_UNLOCK :
                        PAGECACHE_LOCK_READ_UNLOCK);
diff --git a/storage/maria/maria_pack.c b/storage/maria/maria_pack.c
index 9ae982a6bd7..3e9d002ea43 100644
--- a/storage/maria/maria_pack.c
+++ b/storage/maria/maria_pack.c
@@ -782,27 +782,29 @@ static HUFF_COUNTS *init_huff_count(MARIA_HA *info,my_off_t records)
     for (i=0 ; i < info->s->base.fields ; i++)
     {
       enum en_fieldtype type;
-      count[i].field_length=info->s->columndef[i].length;
-      type= count[i].field_type= (enum en_fieldtype) info->s->columndef[i].type;
+      uint col_nr = info->s->columndef[i].column_nr;
+      count[col_nr].field_length=info->s->columndef[i].length;
+      type= count[col_nr].field_type=
+        (enum en_fieldtype) info->s->columndef[i].type;
       if (type == FIELD_INTERVALL ||
 	  type == FIELD_CONSTANT ||
 	  type == FIELD_ZERO)
 	type = FIELD_NORMAL;
-      if (count[i].field_length <= 8 &&
+      if (count[col_nr].field_length <= 8 &&
 	  (type == FIELD_NORMAL ||
 	   type == FIELD_SKIP_ZERO))
-	count[i].max_zero_fill= count[i].field_length;
+	count[col_nr].max_zero_fill= count[col_nr].field_length;
       /*
         For every column initialize a tree, which is used to detect distinct
         column values. 'int_tree' works together with 'tree_buff' and
         'tree_pos'. It's keys are implemented by pointers into 'tree_buff'.
         This is accomplished by '-1' as the element size.
       */
-      init_tree(&count[i].int_tree,0,0,-1,(qsort_cmp2) compare_tree, NULL,
+      init_tree(&count[col_nr].int_tree,0,0,-1,(qsort_cmp2) compare_tree, NULL,
 		NULL, MYF(0));
       if (records && type != FIELD_BLOB && type != FIELD_VARCHAR)
-	count[i].tree_pos=count[i].tree_buff =
-	  my_malloc(count[i].field_length > 1 ? tree_buff_length : 2,
+	count[col_nr].tree_pos=count[col_nr].tree_buff =
+	  my_malloc(count[col_nr].field_length > 1 ? tree_buff_length : 2,
 		    MYF(MY_WME));
     }
   }
diff --git a/storage/maria/trnman.c b/storage/maria/trnman.c
index 744ca86412e..85a87e928b9 100644
--- a/storage/maria/trnman.c
+++ b/storage/maria/trnman.c
@@ -307,7 +307,7 @@ TRN *trnman_new_trn(WT_THD *wt)
   if (!(trn= tmp.trn))
   {
     /*
-      trn should be completely initalized at create time to allow
+      trn should be completely initialized at create time to allow
       one to keep a known state on it.
       (Like redo_lns, which is assumed to be 0 at start of row handling
       and reset to zero before end of row handling)
diff --git a/storage/myisam/ha_myisam.cc b/storage/myisam/ha_myisam.cc
index 9b4dff68683..fd2e8fd9425 100644
--- a/storage/myisam/ha_myisam.cc
+++ b/storage/myisam/ha_myisam.cc
@@ -859,7 +859,7 @@ int ha_myisam::open(const char *name, int mode, uint test_if_locked)
 
   /*
     For static size rows, tell MariaDB that we will access all bytes
-    in the record when writing it.  This signals MariaDB to initalize
+    in the record when writing it.  This signals MariaDB to initialize
     the full row to ensure we don't get any errors from valgrind and
     that all bytes in the row is properly reset.
   */
diff --git a/storage/perfschema/CMakeLists.txt b/storage/perfschema/CMakeLists.txt
index 7db67700fac..e1839bc5b00 100644
--- a/storage/perfschema/CMakeLists.txt
+++ b/storage/perfschema/CMakeLists.txt
@@ -1,13 +1,20 @@
-# Copyright (c) 2009, 2015, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2009, 2019, Oracle and/or its affiliates. All rights reserved.
 #
 # This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; version 2 of the License.
+# it under the terms of the GNU General Public License, version 2.0,
+# as published by the Free Software Foundation.
+#
+# This program is also distributed with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation.  The authors of MySQL hereby grant you an additional
+# permission to link the program and your derivative works with the
+# separately licensed software that they have included with MySQL.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
+# GNU General Public License, version 2.0, for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/cursor_by_account.cc b/storage/perfschema/cursor_by_account.cc
index 2e75b8d51bd..f26318c42fc 100644
--- a/storage/perfschema/cursor_by_account.cc
+++ b/storage/perfschema/cursor_by_account.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/cursor_by_account.h b/storage/perfschema/cursor_by_account.h
index 150615b9c54..c14a563b712 100644
--- a/storage/perfschema/cursor_by_account.h
+++ b/storage/perfschema/cursor_by_account.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/cursor_by_host.cc b/storage/perfschema/cursor_by_host.cc
index d16f8b24b8e..c3397234e2e 100644
--- a/storage/perfschema/cursor_by_host.cc
+++ b/storage/perfschema/cursor_by_host.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/cursor_by_host.h b/storage/perfschema/cursor_by_host.h
index db33bbad808..ac68acf3945 100644
--- a/storage/perfschema/cursor_by_host.h
+++ b/storage/perfschema/cursor_by_host.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/cursor_by_thread.cc b/storage/perfschema/cursor_by_thread.cc
index 2fa9202fcf0..afdc9010b1f 100644
--- a/storage/perfschema/cursor_by_thread.cc
+++ b/storage/perfschema/cursor_by_thread.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/cursor_by_thread.h b/storage/perfschema/cursor_by_thread.h
index 5a77edf325f..db130088920 100644
--- a/storage/perfschema/cursor_by_thread.h
+++ b/storage/perfschema/cursor_by_thread.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/cursor_by_thread_connect_attr.cc b/storage/perfschema/cursor_by_thread_connect_attr.cc
index 2d5399cdac1..90a200b809a 100644
--- a/storage/perfschema/cursor_by_thread_connect_attr.cc
+++ b/storage/perfschema/cursor_by_thread_connect_attr.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/cursor_by_thread_connect_attr.h b/storage/perfschema/cursor_by_thread_connect_attr.h
index b5059918f7f..69d1b5ec0c0 100644
--- a/storage/perfschema/cursor_by_thread_connect_attr.h
+++ b/storage/perfschema/cursor_by_thread_connect_attr.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/cursor_by_user.cc b/storage/perfschema/cursor_by_user.cc
index 37ecbf17fee..273d186b01c 100644
--- a/storage/perfschema/cursor_by_user.cc
+++ b/storage/perfschema/cursor_by_user.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/cursor_by_user.h b/storage/perfschema/cursor_by_user.h
index d6e997766b6..06554ebb228 100644
--- a/storage/perfschema/cursor_by_user.h
+++ b/storage/perfschema/cursor_by_user.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/gen_pfs_lex_token.cc b/storage/perfschema/gen_pfs_lex_token.cc
index dcf25c79706..5a51a8aeb2f 100644
--- a/storage/perfschema/gen_pfs_lex_token.cc
+++ b/storage/perfschema/gen_pfs_lex_token.cc
@@ -2,13 +2,20 @@
    Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; version 2 of the License.
+   it under the terms of the GNU General Public License, version 2.0,
+   as published by the Free Software Foundation.
+
+   This program is also distributed with certain software (including
+   but not limited to OpenSSL) that is licensed under separate terms,
+   as designated in a particular file or component or in included license
+   documentation.  The authors of MySQL hereby grant you an additional
+   permission to link the program and your derivative works with the
+   separately licensed software that they have included with MySQL.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
+   GNU General Public License, version 2.0, for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/ha_perfschema.cc b/storage/perfschema/ha_perfschema.cc
index cb5805db5da..0754bb5a7e7 100644
--- a/storage/perfschema/ha_perfschema.cc
+++ b/storage/perfschema/ha_perfschema.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/ha_perfschema.h b/storage/perfschema/ha_perfschema.h
index 4aad6a3beef..dd57ff31088 100644
--- a/storage/perfschema/ha_perfschema.h
+++ b/storage/perfschema/ha_perfschema.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs.cc b/storage/perfschema/pfs.cc
index 165ac3f9812..2f1081b3836 100644
--- a/storage/perfschema/pfs.cc
+++ b/storage/perfschema/pfs.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs.h b/storage/perfschema/pfs.h
index 230aea6d4b8..3649143f8fa 100644
--- a/storage/perfschema/pfs.h
+++ b/storage/perfschema/pfs.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_account.cc b/storage/perfschema/pfs_account.cc
index 5ac16b7636e..be2153e84ae 100644
--- a/storage/perfschema/pfs_account.cc
+++ b/storage/perfschema/pfs_account.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_account.h b/storage/perfschema/pfs_account.h
index 544abf913ae..cd7b1520df5 100644
--- a/storage/perfschema/pfs_account.h
+++ b/storage/perfschema/pfs_account.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_atomic.h b/storage/perfschema/pfs_atomic.h
index def9339d06d..00d1197970b 100644
--- a/storage/perfschema/pfs_atomic.h
+++ b/storage/perfschema/pfs_atomic.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_autosize.cc b/storage/perfschema/pfs_autosize.cc
index c8cc78198e9..e15a85fe2d6 100644
--- a/storage/perfschema/pfs_autosize.cc
+++ b/storage/perfschema/pfs_autosize.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_column_types.h b/storage/perfschema/pfs_column_types.h
index ef657b38707..09fce551402 100644
--- a/storage/perfschema/pfs_column_types.h
+++ b/storage/perfschema/pfs_column_types.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_column_values.cc b/storage/perfschema/pfs_column_values.cc
index fc2889a560d..043c8fd2f38 100644
--- a/storage/perfschema/pfs_column_values.cc
+++ b/storage/perfschema/pfs_column_values.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_column_values.h b/storage/perfschema/pfs_column_values.h
index a5e651ddd3d..44f23527881 100644
--- a/storage/perfschema/pfs_column_values.h
+++ b/storage/perfschema/pfs_column_values.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_con_slice.cc b/storage/perfschema/pfs_con_slice.cc
index bce4918ae9e..9f9deb0919c 100644
--- a/storage/perfschema/pfs_con_slice.cc
+++ b/storage/perfschema/pfs_con_slice.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_con_slice.h b/storage/perfschema/pfs_con_slice.h
index f83764339c3..ed17de5f2b0 100644
--- a/storage/perfschema/pfs_con_slice.h
+++ b/storage/perfschema/pfs_con_slice.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_defaults.cc b/storage/perfschema/pfs_defaults.cc
index 4171786ea68..8c56ceba682 100644
--- a/storage/perfschema/pfs_defaults.cc
+++ b/storage/perfschema/pfs_defaults.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_defaults.h b/storage/perfschema/pfs_defaults.h
index d95c4914e9d..7751b55b83b 100644
--- a/storage/perfschema/pfs_defaults.h
+++ b/storage/perfschema/pfs_defaults.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_digest.cc b/storage/perfschema/pfs_digest.cc
index 7b175762477..0ddb4c90eb3 100644
--- a/storage/perfschema/pfs_digest.cc
+++ b/storage/perfschema/pfs_digest.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_digest.h b/storage/perfschema/pfs_digest.h
index 06f8fc31de2..c11852a1510 100644
--- a/storage/perfschema/pfs_digest.h
+++ b/storage/perfschema/pfs_digest.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_engine_table.cc b/storage/perfschema/pfs_engine_table.cc
index b133988e908..08ad7d31c88 100644
--- a/storage/perfschema/pfs_engine_table.cc
+++ b/storage/perfschema/pfs_engine_table.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_engine_table.h b/storage/perfschema/pfs_engine_table.h
index b29a9c54754..52ad203db24 100644
--- a/storage/perfschema/pfs_engine_table.h
+++ b/storage/perfschema/pfs_engine_table.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_events.h b/storage/perfschema/pfs_events.h
index 09c3935816f..ca2fd8582ad 100644
--- a/storage/perfschema/pfs_events.h
+++ b/storage/perfschema/pfs_events.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_events_stages.cc b/storage/perfschema/pfs_events_stages.cc
index 673d2cb95f5..a68b0729e96 100644
--- a/storage/perfschema/pfs_events_stages.cc
+++ b/storage/perfschema/pfs_events_stages.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_events_stages.h b/storage/perfschema/pfs_events_stages.h
index ea879bcd211..f61a7c3c077 100644
--- a/storage/perfschema/pfs_events_stages.h
+++ b/storage/perfschema/pfs_events_stages.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_events_statements.cc b/storage/perfschema/pfs_events_statements.cc
index 66a98e3f7d8..1942787665a 100644
--- a/storage/perfschema/pfs_events_statements.cc
+++ b/storage/perfschema/pfs_events_statements.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_events_statements.h b/storage/perfschema/pfs_events_statements.h
index a56423d3863..e47e2e79280 100644
--- a/storage/perfschema/pfs_events_statements.h
+++ b/storage/perfschema/pfs_events_statements.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_events_waits.cc b/storage/perfschema/pfs_events_waits.cc
index f99a1f31bd9..c3961461f34 100644
--- a/storage/perfschema/pfs_events_waits.cc
+++ b/storage/perfschema/pfs_events_waits.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_events_waits.h b/storage/perfschema/pfs_events_waits.h
index 25784fd52ba..702f7e3ce07 100644
--- a/storage/perfschema/pfs_events_waits.h
+++ b/storage/perfschema/pfs_events_waits.h
@@ -2,13 +2,20 @@
    Copyright (c) 2017, MariaDB Corporation.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_global.cc b/storage/perfschema/pfs_global.cc
index 4f8928e7e84..e1b5e3400ca 100644
--- a/storage/perfschema/pfs_global.cc
+++ b/storage/perfschema/pfs_global.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_global.h b/storage/perfschema/pfs_global.h
index 81cab38b000..58db39e607d 100644
--- a/storage/perfschema/pfs_global.h
+++ b/storage/perfschema/pfs_global.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_host.cc b/storage/perfschema/pfs_host.cc
index 2d24a5f4b97..d6461ef3851 100644
--- a/storage/perfschema/pfs_host.cc
+++ b/storage/perfschema/pfs_host.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_host.h b/storage/perfschema/pfs_host.h
index 4e6b24bf6c6..d52207d3571 100644
--- a/storage/perfschema/pfs_host.h
+++ b/storage/perfschema/pfs_host.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_instr.cc b/storage/perfschema/pfs_instr.cc
index f90c6475f22..ca9e0385021 100644
--- a/storage/perfschema/pfs_instr.cc
+++ b/storage/perfschema/pfs_instr.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_instr.h b/storage/perfschema/pfs_instr.h
index 007ef3d6435..81bc52d1d75 100644
--- a/storage/perfschema/pfs_instr.h
+++ b/storage/perfschema/pfs_instr.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_instr_class.cc b/storage/perfschema/pfs_instr_class.cc
index bde0836a250..d44644eee9d 100644
--- a/storage/perfschema/pfs_instr_class.cc
+++ b/storage/perfschema/pfs_instr_class.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_instr_class.h b/storage/perfschema/pfs_instr_class.h
index 038814b07e2..9d256fac78a 100644
--- a/storage/perfschema/pfs_instr_class.h
+++ b/storage/perfschema/pfs_instr_class.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_lock.h b/storage/perfschema/pfs_lock.h
index 4011cba2070..b74131c79e1 100644
--- a/storage/perfschema/pfs_lock.h
+++ b/storage/perfschema/pfs_lock.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2009, 2016, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_server.cc b/storage/perfschema/pfs_server.cc
index f39c80bbb71..f3f22bbcf4f 100644
--- a/storage/perfschema/pfs_server.cc
+++ b/storage/perfschema/pfs_server.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_server.h b/storage/perfschema/pfs_server.h
index 0def07b49a5..3457a91d376 100644
--- a/storage/perfschema/pfs_server.h
+++ b/storage/perfschema/pfs_server.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_setup_actor.cc b/storage/perfschema/pfs_setup_actor.cc
index 42c32b12411..c4cec6c9ff8 100644
--- a/storage/perfschema/pfs_setup_actor.cc
+++ b/storage/perfschema/pfs_setup_actor.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_setup_actor.h b/storage/perfschema/pfs_setup_actor.h
index 92a1617c304..613d5454a9c 100644
--- a/storage/perfschema/pfs_setup_actor.h
+++ b/storage/perfschema/pfs_setup_actor.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_setup_object.cc b/storage/perfschema/pfs_setup_object.cc
index 128091a398b..f33030e927f 100644
--- a/storage/perfschema/pfs_setup_object.cc
+++ b/storage/perfschema/pfs_setup_object.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_setup_object.h b/storage/perfschema/pfs_setup_object.h
index 0d343f552b2..ee40742941c 100644
--- a/storage/perfschema/pfs_setup_object.h
+++ b/storage/perfschema/pfs_setup_object.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_stat.h b/storage/perfschema/pfs_stat.h
index 9e4da7957f6..8a049e3013b 100644
--- a/storage/perfschema/pfs_stat.h
+++ b/storage/perfschema/pfs_stat.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_timer.cc b/storage/perfschema/pfs_timer.cc
index 5e2c27c217b..8533dffcb27 100644
--- a/storage/perfschema/pfs_timer.cc
+++ b/storage/perfschema/pfs_timer.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_timer.h b/storage/perfschema/pfs_timer.h
index a4f55c20994..222a7f00fae 100644
--- a/storage/perfschema/pfs_timer.h
+++ b/storage/perfschema/pfs_timer.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
@@ -100,7 +107,7 @@ extern enum_timer_name stage_timer;
 extern enum_timer_name statement_timer;
 /**
   Timer information data.
-  Characteristics about each suported timer.
+  Characteristics about each supported timer.
 */
 extern MYSQL_PLUGIN_IMPORT MY_TIMER_INFO sys_timer_info;
 
diff --git a/storage/perfschema/pfs_user.cc b/storage/perfschema/pfs_user.cc
index d923d4158a5..14b86e1478e 100644
--- a/storage/perfschema/pfs_user.cc
+++ b/storage/perfschema/pfs_user.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_user.h b/storage/perfschema/pfs_user.h
index f2b1c4409c7..3d0457eae59 100644
--- a/storage/perfschema/pfs_user.h
+++ b/storage/perfschema/pfs_user.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/pfs_visitor.cc b/storage/perfschema/pfs_visitor.cc
index 3df7ef91bb3..097965fde17 100644
--- a/storage/perfschema/pfs_visitor.cc
+++ b/storage/perfschema/pfs_visitor.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/pfs_visitor.h b/storage/perfschema/pfs_visitor.h
index c3ada2f4e0b..120b5928045 100644
--- a/storage/perfschema/pfs_visitor.h
+++ b/storage/perfschema/pfs_visitor.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_accounts.cc b/storage/perfschema/table_accounts.cc
index 007fcb25550..708f8269a69 100644
--- a/storage/perfschema/table_accounts.cc
+++ b/storage/perfschema/table_accounts.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_accounts.h b/storage/perfschema/table_accounts.h
index f72eb39ed39..dfc2cc322e0 100644
--- a/storage/perfschema/table_accounts.h
+++ b/storage/perfschema/table_accounts.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_all_instr.cc b/storage/perfschema/table_all_instr.cc
index 05ec9f09c11..d48028b1539 100644
--- a/storage/perfschema/table_all_instr.cc
+++ b/storage/perfschema/table_all_instr.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_all_instr.h b/storage/perfschema/table_all_instr.h
index 7c9d5d9b0d6..072221ba86e 100644
--- a/storage/perfschema/table_all_instr.h
+++ b/storage/perfschema/table_all_instr.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_esgs_by_account_by_event_name.cc b/storage/perfschema/table_esgs_by_account_by_event_name.cc
index 3bc76f899ad..22e4e0040f1 100644
--- a/storage/perfschema/table_esgs_by_account_by_event_name.cc
+++ b/storage/perfschema/table_esgs_by_account_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esgs_by_account_by_event_name.h b/storage/perfschema/table_esgs_by_account_by_event_name.h
index 5afd68cd7d9..ee855d42818 100644
--- a/storage/perfschema/table_esgs_by_account_by_event_name.h
+++ b/storage/perfschema/table_esgs_by_account_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esgs_by_host_by_event_name.cc b/storage/perfschema/table_esgs_by_host_by_event_name.cc
index bbef6a8d16d..86cc2eb1b86 100644
--- a/storage/perfschema/table_esgs_by_host_by_event_name.cc
+++ b/storage/perfschema/table_esgs_by_host_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esgs_by_host_by_event_name.h b/storage/perfschema/table_esgs_by_host_by_event_name.h
index afc6d529428..6042e6396af 100644
--- a/storage/perfschema/table_esgs_by_host_by_event_name.h
+++ b/storage/perfschema/table_esgs_by_host_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esgs_by_thread_by_event_name.cc b/storage/perfschema/table_esgs_by_thread_by_event_name.cc
index 57ef634acad..dfda9702abb 100644
--- a/storage/perfschema/table_esgs_by_thread_by_event_name.cc
+++ b/storage/perfschema/table_esgs_by_thread_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esgs_by_thread_by_event_name.h b/storage/perfschema/table_esgs_by_thread_by_event_name.h
index 7db8d1be408..6ff677a95e2 100644
--- a/storage/perfschema/table_esgs_by_thread_by_event_name.h
+++ b/storage/perfschema/table_esgs_by_thread_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esgs_by_user_by_event_name.cc b/storage/perfschema/table_esgs_by_user_by_event_name.cc
index f8e8518bde3..af73c1fc5fd 100644
--- a/storage/perfschema/table_esgs_by_user_by_event_name.cc
+++ b/storage/perfschema/table_esgs_by_user_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esgs_by_user_by_event_name.h b/storage/perfschema/table_esgs_by_user_by_event_name.h
index 8f48747c8c8..bc545c2438a 100644
--- a/storage/perfschema/table_esgs_by_user_by_event_name.h
+++ b/storage/perfschema/table_esgs_by_user_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esgs_global_by_event_name.cc b/storage/perfschema/table_esgs_global_by_event_name.cc
index 83a4dbf43fd..6c5f0866671 100644
--- a/storage/perfschema/table_esgs_global_by_event_name.cc
+++ b/storage/perfschema/table_esgs_global_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esgs_global_by_event_name.h b/storage/perfschema/table_esgs_global_by_event_name.h
index 2b0ac8b6218..b8884355676 100644
--- a/storage/perfschema/table_esgs_global_by_event_name.h
+++ b/storage/perfschema/table_esgs_global_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_by_account_by_event_name.cc b/storage/perfschema/table_esms_by_account_by_event_name.cc
index d8f04d7af23..7afdabcbbfe 100644
--- a/storage/perfschema/table_esms_by_account_by_event_name.cc
+++ b/storage/perfschema/table_esms_by_account_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_by_account_by_event_name.h b/storage/perfschema/table_esms_by_account_by_event_name.h
index ff212291760..64f2053cff6 100644
--- a/storage/perfschema/table_esms_by_account_by_event_name.h
+++ b/storage/perfschema/table_esms_by_account_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_by_digest.cc b/storage/perfschema/table_esms_by_digest.cc
index ae648378b2a..5295c29dc40 100644
--- a/storage/perfschema/table_esms_by_digest.cc
+++ b/storage/perfschema/table_esms_by_digest.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_by_digest.h b/storage/perfschema/table_esms_by_digest.h
index 682dc70ab10..903b86110f6 100644
--- a/storage/perfschema/table_esms_by_digest.h
+++ b/storage/perfschema/table_esms_by_digest.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_by_host_by_event_name.cc b/storage/perfschema/table_esms_by_host_by_event_name.cc
index 7233b340bd2..42629ab6c09 100644
--- a/storage/perfschema/table_esms_by_host_by_event_name.cc
+++ b/storage/perfschema/table_esms_by_host_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_by_host_by_event_name.h b/storage/perfschema/table_esms_by_host_by_event_name.h
index def5e19ecdc..a6985b48149 100644
--- a/storage/perfschema/table_esms_by_host_by_event_name.h
+++ b/storage/perfschema/table_esms_by_host_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_by_thread_by_event_name.cc b/storage/perfschema/table_esms_by_thread_by_event_name.cc
index f62d974aa76..0a7cf46986c 100644
--- a/storage/perfschema/table_esms_by_thread_by_event_name.cc
+++ b/storage/perfschema/table_esms_by_thread_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_by_thread_by_event_name.h b/storage/perfschema/table_esms_by_thread_by_event_name.h
index 7c50307c483..72645d03389 100644
--- a/storage/perfschema/table_esms_by_thread_by_event_name.h
+++ b/storage/perfschema/table_esms_by_thread_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_by_user_by_event_name.cc b/storage/perfschema/table_esms_by_user_by_event_name.cc
index 66afe288f12..f8708ac9a14 100644
--- a/storage/perfschema/table_esms_by_user_by_event_name.cc
+++ b/storage/perfschema/table_esms_by_user_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_by_user_by_event_name.h b/storage/perfschema/table_esms_by_user_by_event_name.h
index 65284122043..d1d1e5df85d 100644
--- a/storage/perfschema/table_esms_by_user_by_event_name.h
+++ b/storage/perfschema/table_esms_by_user_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_global_by_event_name.cc b/storage/perfschema/table_esms_global_by_event_name.cc
index 96957bf028e..7d9584752b0 100644
--- a/storage/perfschema/table_esms_global_by_event_name.cc
+++ b/storage/perfschema/table_esms_global_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_esms_global_by_event_name.h b/storage/perfschema/table_esms_global_by_event_name.h
index 7453d635848..b90c14c0c0f 100644
--- a/storage/perfschema/table_esms_global_by_event_name.h
+++ b/storage/perfschema/table_esms_global_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_events_stages.cc b/storage/perfschema/table_events_stages.cc
index d92de88abe7..95e7f187d24 100644
--- a/storage/perfschema/table_events_stages.cc
+++ b/storage/perfschema/table_events_stages.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_events_stages.h b/storage/perfschema/table_events_stages.h
index cbc0f9a42bb..ae8760cd953 100644
--- a/storage/perfschema/table_events_stages.h
+++ b/storage/perfschema/table_events_stages.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_events_statements.cc b/storage/perfschema/table_events_statements.cc
index bb32e997792..16fc58d626d 100644
--- a/storage/perfschema/table_events_statements.cc
+++ b/storage/perfschema/table_events_statements.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_events_statements.h b/storage/perfschema/table_events_statements.h
index 6f8bc1621d0..cec28628f3e 100644
--- a/storage/perfschema/table_events_statements.h
+++ b/storage/perfschema/table_events_statements.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_events_waits.cc b/storage/perfschema/table_events_waits.cc
index f845752cc68..6cfc754f8c2 100644
--- a/storage/perfschema/table_events_waits.cc
+++ b/storage/perfschema/table_events_waits.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_events_waits.h b/storage/perfschema/table_events_waits.h
index 3e09fa487ad..90c1d341e5d 100644
--- a/storage/perfschema/table_events_waits.h
+++ b/storage/perfschema/table_events_waits.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_events_waits_summary.cc b/storage/perfschema/table_events_waits_summary.cc
index 2f5c83d57d3..03477f6d542 100644
--- a/storage/perfschema/table_events_waits_summary.cc
+++ b/storage/perfschema/table_events_waits_summary.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_events_waits_summary.h b/storage/perfschema/table_events_waits_summary.h
index a4f063bb66a..53f1bed7987 100644
--- a/storage/perfschema/table_events_waits_summary.h
+++ b/storage/perfschema/table_events_waits_summary.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_ews_by_account_by_event_name.cc b/storage/perfschema/table_ews_by_account_by_event_name.cc
index 0b86a4ac1dc..fa6258ec9ac 100644
--- a/storage/perfschema/table_ews_by_account_by_event_name.cc
+++ b/storage/perfschema/table_ews_by_account_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_ews_by_account_by_event_name.h b/storage/perfschema/table_ews_by_account_by_event_name.h
index b46008e2675..7cde09183e3 100644
--- a/storage/perfschema/table_ews_by_account_by_event_name.h
+++ b/storage/perfschema/table_ews_by_account_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_ews_by_host_by_event_name.cc b/storage/perfschema/table_ews_by_host_by_event_name.cc
index e82c734431c..e3ef7ca3720 100644
--- a/storage/perfschema/table_ews_by_host_by_event_name.cc
+++ b/storage/perfschema/table_ews_by_host_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_ews_by_host_by_event_name.h b/storage/perfschema/table_ews_by_host_by_event_name.h
index c631da36ec5..8ce44a96617 100644
--- a/storage/perfschema/table_ews_by_host_by_event_name.h
+++ b/storage/perfschema/table_ews_by_host_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_ews_by_thread_by_event_name.cc b/storage/perfschema/table_ews_by_thread_by_event_name.cc
index 7b3e220e973..33f9765310b 100644
--- a/storage/perfschema/table_ews_by_thread_by_event_name.cc
+++ b/storage/perfschema/table_ews_by_thread_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_ews_by_thread_by_event_name.h b/storage/perfschema/table_ews_by_thread_by_event_name.h
index cf94e7a81a2..b67664bfced 100644
--- a/storage/perfschema/table_ews_by_thread_by_event_name.h
+++ b/storage/perfschema/table_ews_by_thread_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_ews_by_user_by_event_name.cc b/storage/perfschema/table_ews_by_user_by_event_name.cc
index 577a9ef6676..cb99f749a9c 100644
--- a/storage/perfschema/table_ews_by_user_by_event_name.cc
+++ b/storage/perfschema/table_ews_by_user_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_ews_by_user_by_event_name.h b/storage/perfschema/table_ews_by_user_by_event_name.h
index e987cf1bcec..f4f29534be4 100644
--- a/storage/perfschema/table_ews_by_user_by_event_name.h
+++ b/storage/perfschema/table_ews_by_user_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_ews_global_by_event_name.cc b/storage/perfschema/table_ews_global_by_event_name.cc
index 9a5ba4f2375..7420c6351fd 100644
--- a/storage/perfschema/table_ews_global_by_event_name.cc
+++ b/storage/perfschema/table_ews_global_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_ews_global_by_event_name.h b/storage/perfschema/table_ews_global_by_event_name.h
index 57e3459e373..8157d274112 100644
--- a/storage/perfschema/table_ews_global_by_event_name.h
+++ b/storage/perfschema/table_ews_global_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_file_instances.cc b/storage/perfschema/table_file_instances.cc
index 7914664e2e0..b323df83ad2 100644
--- a/storage/perfschema/table_file_instances.cc
+++ b/storage/perfschema/table_file_instances.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_file_instances.h b/storage/perfschema/table_file_instances.h
index e07017911de..5b44e63028e 100644
--- a/storage/perfschema/table_file_instances.h
+++ b/storage/perfschema/table_file_instances.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_file_summary_by_event_name.cc b/storage/perfschema/table_file_summary_by_event_name.cc
index e98bc528995..459b2bf99a6 100644
--- a/storage/perfschema/table_file_summary_by_event_name.cc
+++ b/storage/perfschema/table_file_summary_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_file_summary_by_event_name.h b/storage/perfschema/table_file_summary_by_event_name.h
index 7a13fcdc4d9..b8cb293cb07 100644
--- a/storage/perfschema/table_file_summary_by_event_name.h
+++ b/storage/perfschema/table_file_summary_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_file_summary_by_instance.cc b/storage/perfschema/table_file_summary_by_instance.cc
index b80811d0a5b..3a30984405c 100644
--- a/storage/perfschema/table_file_summary_by_instance.cc
+++ b/storage/perfschema/table_file_summary_by_instance.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_file_summary_by_instance.h b/storage/perfschema/table_file_summary_by_instance.h
index 872698f8e58..0e7ce6958b2 100644
--- a/storage/perfschema/table_file_summary_by_instance.h
+++ b/storage/perfschema/table_file_summary_by_instance.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011 Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_helper.cc b/storage/perfschema/table_helper.cc
index 0dbeeb259c1..d6bdd894483 100644
--- a/storage/perfschema/table_helper.cc
+++ b/storage/perfschema/table_helper.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_helper.h b/storage/perfschema/table_helper.h
index b57abe9c4e6..62f94826754 100644
--- a/storage/perfschema/table_helper.h
+++ b/storage/perfschema/table_helper.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_host_cache.cc b/storage/perfschema/table_host_cache.cc
index 02f027e3aab..501894df9b1 100644
--- a/storage/perfschema/table_host_cache.cc
+++ b/storage/perfschema/table_host_cache.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_host_cache.h b/storage/perfschema/table_host_cache.h
index 47abb42444e..8add0b5049c 100644
--- a/storage/perfschema/table_host_cache.h
+++ b/storage/perfschema/table_host_cache.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_hosts.cc b/storage/perfschema/table_hosts.cc
index 2c5377db4ac..8bc5310817c 100644
--- a/storage/perfschema/table_hosts.cc
+++ b/storage/perfschema/table_hosts.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_hosts.h b/storage/perfschema/table_hosts.h
index 60b70ae803e..422b6449b25 100644
--- a/storage/perfschema/table_hosts.h
+++ b/storage/perfschema/table_hosts.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_os_global_by_type.cc b/storage/perfschema/table_os_global_by_type.cc
index cd2ace50c85..b549b0c22e7 100644
--- a/storage/perfschema/table_os_global_by_type.cc
+++ b/storage/perfschema/table_os_global_by_type.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_os_global_by_type.h b/storage/perfschema/table_os_global_by_type.h
index a434961b65b..2b9293ece06 100644
--- a/storage/perfschema/table_os_global_by_type.h
+++ b/storage/perfschema/table_os_global_by_type.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_performance_timers.cc b/storage/perfschema/table_performance_timers.cc
index 8d31c017832..a77f005ab62 100644
--- a/storage/perfschema/table_performance_timers.cc
+++ b/storage/perfschema/table_performance_timers.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_performance_timers.h b/storage/perfschema/table_performance_timers.h
index e1dc93fcbe4..93210ac9882 100644
--- a/storage/perfschema/table_performance_timers.h
+++ b/storage/perfschema/table_performance_timers.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_session_account_connect_attrs.cc b/storage/perfschema/table_session_account_connect_attrs.cc
index 5d3d511d717..fcb4f001ba7 100644
--- a/storage/perfschema/table_session_account_connect_attrs.cc
+++ b/storage/perfschema/table_session_account_connect_attrs.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_session_account_connect_attrs.h b/storage/perfschema/table_session_account_connect_attrs.h
index d56d571fb79..483001fcb91 100644
--- a/storage/perfschema/table_session_account_connect_attrs.h
+++ b/storage/perfschema/table_session_account_connect_attrs.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_session_connect.cc b/storage/perfschema/table_session_connect.cc
index 74b953b034e..0ef233ffd9e 100644
--- a/storage/perfschema/table_session_connect.cc
+++ b/storage/perfschema/table_session_connect.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_session_connect.h b/storage/perfschema/table_session_connect.h
index 91d24ab7075..ee1019fe7f2 100644
--- a/storage/perfschema/table_session_connect.h
+++ b/storage/perfschema/table_session_connect.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_session_connect_attrs.cc b/storage/perfschema/table_session_connect_attrs.cc
index 0ccb255cd0d..cb7b64a7fdf 100644
--- a/storage/perfschema/table_session_connect_attrs.cc
+++ b/storage/perfschema/table_session_connect_attrs.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_session_connect_attrs.h b/storage/perfschema/table_session_connect_attrs.h
index de18085d8ac..927c3a92af2 100644
--- a/storage/perfschema/table_session_connect_attrs.h
+++ b/storage/perfschema/table_session_connect_attrs.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_setup_actors.cc b/storage/perfschema/table_setup_actors.cc
index b5058f8cd85..71c384d0555 100644
--- a/storage/perfschema/table_setup_actors.cc
+++ b/storage/perfschema/table_setup_actors.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_setup_actors.h b/storage/perfschema/table_setup_actors.h
index aa403b4909d..748c57850b0 100644
--- a/storage/perfschema/table_setup_actors.h
+++ b/storage/perfschema/table_setup_actors.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_setup_consumers.cc b/storage/perfschema/table_setup_consumers.cc
index 1846e7949e6..7355efae45b 100644
--- a/storage/perfschema/table_setup_consumers.cc
+++ b/storage/perfschema/table_setup_consumers.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_setup_consumers.h b/storage/perfschema/table_setup_consumers.h
index 959efc3bfd8..90da55920c6 100644
--- a/storage/perfschema/table_setup_consumers.h
+++ b/storage/perfschema/table_setup_consumers.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_setup_instruments.cc b/storage/perfschema/table_setup_instruments.cc
index d6daa7b15d9..490226c7c83 100644
--- a/storage/perfschema/table_setup_instruments.cc
+++ b/storage/perfschema/table_setup_instruments.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_setup_instruments.h b/storage/perfschema/table_setup_instruments.h
index 0255b4b33f7..cd3715cfe55 100644
--- a/storage/perfschema/table_setup_instruments.h
+++ b/storage/perfschema/table_setup_instruments.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_setup_objects.cc b/storage/perfschema/table_setup_objects.cc
index e15c55b41ae..af6481ae98c 100644
--- a/storage/perfschema/table_setup_objects.cc
+++ b/storage/perfschema/table_setup_objects.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_setup_objects.h b/storage/perfschema/table_setup_objects.h
index 8e883126298..560346c577f 100644
--- a/storage/perfschema/table_setup_objects.h
+++ b/storage/perfschema/table_setup_objects.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_setup_timers.cc b/storage/perfschema/table_setup_timers.cc
index 75de0393501..a2d34828f08 100644
--- a/storage/perfschema/table_setup_timers.cc
+++ b/storage/perfschema/table_setup_timers.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_setup_timers.h b/storage/perfschema/table_setup_timers.h
index 8c4da92296a..d591f3e0b67 100644
--- a/storage/perfschema/table_setup_timers.h
+++ b/storage/perfschema/table_setup_timers.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_socket_instances.cc b/storage/perfschema/table_socket_instances.cc
index 419e19349f4..920531136d5 100644
--- a/storage/perfschema/table_socket_instances.cc
+++ b/storage/perfschema/table_socket_instances.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_socket_instances.h b/storage/perfschema/table_socket_instances.h
index b5e5edb36ed..41b5ee3fd21 100644
--- a/storage/perfschema/table_socket_instances.h
+++ b/storage/perfschema/table_socket_instances.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_socket_summary_by_event_name.cc b/storage/perfschema/table_socket_summary_by_event_name.cc
index 2da45c0d2cd..c813d45b732 100644
--- a/storage/perfschema/table_socket_summary_by_event_name.cc
+++ b/storage/perfschema/table_socket_summary_by_event_name.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_socket_summary_by_event_name.h b/storage/perfschema/table_socket_summary_by_event_name.h
index 9bdeb3104b4..4f679d89b09 100644
--- a/storage/perfschema/table_socket_summary_by_event_name.h
+++ b/storage/perfschema/table_socket_summary_by_event_name.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_socket_summary_by_instance.cc b/storage/perfschema/table_socket_summary_by_instance.cc
index 693f65e4843..a4b1477aa90 100644
--- a/storage/perfschema/table_socket_summary_by_instance.cc
+++ b/storage/perfschema/table_socket_summary_by_instance.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_socket_summary_by_instance.h b/storage/perfschema/table_socket_summary_by_instance.h
index deb8ffab554..a9eab8d18b6 100644
--- a/storage/perfschema/table_socket_summary_by_instance.h
+++ b/storage/perfschema/table_socket_summary_by_instance.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_sync_instances.cc b/storage/perfschema/table_sync_instances.cc
index 6e48468e6c3..f0c7800d24a 100644
--- a/storage/perfschema/table_sync_instances.cc
+++ b/storage/perfschema/table_sync_instances.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_sync_instances.h b/storage/perfschema/table_sync_instances.h
index c6a2ed8adaa..6f7e1bf5523 100644
--- a/storage/perfschema/table_sync_instances.h
+++ b/storage/perfschema/table_sync_instances.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_threads.cc b/storage/perfschema/table_threads.cc
index 744ff763be1..b396db1a814 100644
--- a/storage/perfschema/table_threads.cc
+++ b/storage/perfschema/table_threads.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_threads.h b/storage/perfschema/table_threads.h
index 96ae0925002..841b8102bca 100644
--- a/storage/perfschema/table_threads.h
+++ b/storage/perfschema/table_threads.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_tiws_by_index_usage.cc b/storage/perfschema/table_tiws_by_index_usage.cc
index 5d24fcc689b..b49e9280469 100644
--- a/storage/perfschema/table_tiws_by_index_usage.cc
+++ b/storage/perfschema/table_tiws_by_index_usage.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_tiws_by_index_usage.h b/storage/perfschema/table_tiws_by_index_usage.h
index f6d935365b2..a284bc7f0bc 100644
--- a/storage/perfschema/table_tiws_by_index_usage.h
+++ b/storage/perfschema/table_tiws_by_index_usage.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_tiws_by_table.cc b/storage/perfschema/table_tiws_by_table.cc
index 78535fd6512..db00fd2409e 100644
--- a/storage/perfschema/table_tiws_by_table.cc
+++ b/storage/perfschema/table_tiws_by_table.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_tiws_by_table.h b/storage/perfschema/table_tiws_by_table.h
index 9a86d39196c..7427ca797fa 100644
--- a/storage/perfschema/table_tiws_by_table.h
+++ b/storage/perfschema/table_tiws_by_table.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_tlws_by_table.cc b/storage/perfschema/table_tlws_by_table.cc
index 5299e7f6a56..d802127d10d 100644
--- a/storage/perfschema/table_tlws_by_table.cc
+++ b/storage/perfschema/table_tlws_by_table.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_tlws_by_table.h b/storage/perfschema/table_tlws_by_table.h
index 757adc3f5f5..b5872a07762 100644
--- a/storage/perfschema/table_tlws_by_table.h
+++ b/storage/perfschema/table_tlws_by_table.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/table_users.cc b/storage/perfschema/table_users.cc
index 6d6bfc5bfaf..883ebd36633 100644
--- a/storage/perfschema/table_users.cc
+++ b/storage/perfschema/table_users.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/table_users.h b/storage/perfschema/table_users.h
index 1b24dfb9039..912f0f43714 100644
--- a/storage/perfschema/table_users.h
+++ b/storage/perfschema/table_users.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/CMakeLists.txt b/storage/perfschema/unittest/CMakeLists.txt
index b449640b374..7b8c906a4e6 100644
--- a/storage/perfschema/unittest/CMakeLists.txt
+++ b/storage/perfschema/unittest/CMakeLists.txt
@@ -1,13 +1,20 @@
-# Copyright (c) 2009, 2015, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2009, 2019, Oracle and/or its affiliates. All rights reserved.
 #
 # This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; version 2 of the License.
+# it under the terms of the GNU General Public License, version 2.0,
+# as published by the Free Software Foundation.
+#
+# This program is also distributed with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation.  The authors of MySQL hereby grant you an additional
+# permission to link the program and your derivative works with the
+# separately licensed software that they have included with MySQL.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
+# GNU General Public License, version 2.0, for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/conf.txt b/storage/perfschema/unittest/conf.txt
index 8a14b9ed14b..f84ba3317b1 100644
--- a/storage/perfschema/unittest/conf.txt
+++ b/storage/perfschema/unittest/conf.txt
@@ -1,13 +1,20 @@
 # Copyright (c) 2009, 2010, Oracle and/or its affiliates.
 #
 # This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; version 2 of the License.
+# it under the terms of the GNU General Public License, version 2.0,
+# as published by the Free Software Foundation.
+#
+# This program is also distributed with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation.  The authors of MySQL hereby grant you an additional
+# permission to link the program and your derivative works with the
+# separately licensed software that they have included with MySQL.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
+# GNU General Public License, version 2.0, for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs-t.cc b/storage/perfschema/unittest/pfs-t.cc
index 75ded9c3679..f5f38367691 100644
--- a/storage/perfschema/unittest/pfs-t.cc
+++ b/storage/perfschema/unittest/pfs-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs_account-oom-t.cc b/storage/perfschema/unittest/pfs_account-oom-t.cc
index 71c089ab0f5..1ca66445e0c 100644
--- a/storage/perfschema/unittest/pfs_account-oom-t.cc
+++ b/storage/perfschema/unittest/pfs_account-oom-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs_connect_attr-t.cc b/storage/perfschema/unittest/pfs_connect_attr-t.cc
index 3dd62ca5662..7ebfb0c8294 100644
--- a/storage/perfschema/unittest/pfs_connect_attr-t.cc
+++ b/storage/perfschema/unittest/pfs_connect_attr-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs_host-oom-t.cc b/storage/perfschema/unittest/pfs_host-oom-t.cc
index e2eba7e6aff..14af1af0352 100644
--- a/storage/perfschema/unittest/pfs_host-oom-t.cc
+++ b/storage/perfschema/unittest/pfs_host-oom-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs_instr-oom-t.cc b/storage/perfschema/unittest/pfs_instr-oom-t.cc
index a18902dc3db..231fd1e100b 100644
--- a/storage/perfschema/unittest/pfs_instr-oom-t.cc
+++ b/storage/perfschema/unittest/pfs_instr-oom-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs_instr-t.cc b/storage/perfschema/unittest/pfs_instr-t.cc
index 47a91d9bb9a..c9f4bac1171 100644
--- a/storage/perfschema/unittest/pfs_instr-t.cc
+++ b/storage/perfschema/unittest/pfs_instr-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs_instr_class-oom-t.cc b/storage/perfschema/unittest/pfs_instr_class-oom-t.cc
index bdb2648c2f3..7eb21a33bd7 100644
--- a/storage/perfschema/unittest/pfs_instr_class-oom-t.cc
+++ b/storage/perfschema/unittest/pfs_instr_class-oom-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs_instr_class-t.cc b/storage/perfschema/unittest/pfs_instr_class-t.cc
index 0d8ec38525d..f1e246dc387 100644
--- a/storage/perfschema/unittest/pfs_instr_class-t.cc
+++ b/storage/perfschema/unittest/pfs_instr_class-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs_misc-t.cc b/storage/perfschema/unittest/pfs_misc-t.cc
index c308cf4b82d..7d274c0820d 100644
--- a/storage/perfschema/unittest/pfs_misc-t.cc
+++ b/storage/perfschema/unittest/pfs_misc-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs_server_stubs.cc b/storage/perfschema/unittest/pfs_server_stubs.cc
index 3c4b864d742..db1600faf9f 100644
--- a/storage/perfschema/unittest/pfs_server_stubs.cc
+++ b/storage/perfschema/unittest/pfs_server_stubs.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/unittest/pfs_timer-t.cc b/storage/perfschema/unittest/pfs_timer-t.cc
index 9ef111f531c..139454b8649 100644
--- a/storage/perfschema/unittest/pfs_timer-t.cc
+++ b/storage/perfschema/unittest/pfs_timer-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/pfs_user-oom-t.cc b/storage/perfschema/unittest/pfs_user-oom-t.cc
index 6e81df8d5e2..ca451f3e457 100644
--- a/storage/perfschema/unittest/pfs_user-oom-t.cc
+++ b/storage/perfschema/unittest/pfs_user-oom-t.cc
@@ -1,13 +1,20 @@
 /* Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/stub_pfs_defaults.h b/storage/perfschema/unittest/stub_pfs_defaults.h
index 6b4ee3f0e15..951508733e2 100644
--- a/storage/perfschema/unittest/stub_pfs_defaults.h
+++ b/storage/perfschema/unittest/stub_pfs_defaults.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
diff --git a/storage/perfschema/unittest/stub_pfs_global.h b/storage/perfschema/unittest/stub_pfs_global.h
index a665ed39704..8a1f9216ba2 100644
--- a/storage/perfschema/unittest/stub_pfs_global.h
+++ b/storage/perfschema/unittest/stub_pfs_global.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/perfschema/unittest/stub_print_error.h b/storage/perfschema/unittest/stub_print_error.h
index 476a6c0e901..2cd2ad5b03c 100644
--- a/storage/perfschema/unittest/stub_print_error.h
+++ b/storage/perfschema/unittest/stub_print_error.h
@@ -1,13 +1,20 @@
 /* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
+  GNU General Public License, version 2.0, for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
diff --git a/storage/rocksdb/CMakeLists.txt b/storage/rocksdb/CMakeLists.txt
index 9551ad7f343..3a707d8c02b 100644
--- a/storage/rocksdb/CMakeLists.txt
+++ b/storage/rocksdb/CMakeLists.txt
@@ -257,7 +257,7 @@ CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/myrocks_hotbackup.py
 INSTALL_SCRIPT(${CMAKE_CURRENT_BINARY_DIR}/myrocks_hotbackup COMPONENT rocksdb-engine)
 
 IF(CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-  SET_TARGET_PROPERTIES(rocksdb_tools sst_dump mysql_ldb PROPERTIES COMPILE_FLAGS -frtti)
+  SET_TARGET_PROPERTIES(rocksdb_tools sst_dump mysql_ldb PROPERTIES COMPILE_FLAGS "-frtti -Wno-error")
 ENDIF()
 IF(MSVC)
   # RocksDB, the storage engine, overdoes "const" by adding
diff --git a/storage/rocksdb/build_rocksdb.cmake b/storage/rocksdb/build_rocksdb.cmake
index ba50e94c983..2fbc938ae00 100644
--- a/storage/rocksdb/build_rocksdb.cmake
+++ b/storage/rocksdb/build_rocksdb.cmake
@@ -471,5 +471,5 @@ list(APPEND SOURCES ${CMAKE_CURRENT_BINARY_DIR}/build_version.cc)
 ADD_CONVENIENCE_LIBRARY(rocksdblib ${SOURCES})
 target_link_libraries(rocksdblib ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
 IF(CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-  set_target_properties(rocksdblib PROPERTIES COMPILE_FLAGS "-fPIC -fno-builtin-memcmp -frtti")
+  set_target_properties(rocksdblib PROPERTIES COMPILE_FLAGS "-fPIC -fno-builtin-memcmp -frtti -Wno-error")
 endif()
diff --git a/storage/rocksdb/mysql-test/rocksdb/r/innodb_i_s_tables_disabled.result b/storage/rocksdb/mysql-test/rocksdb/r/innodb_i_s_tables_disabled.result
index 8d5b6270318..61f005c1758 100644
--- a/storage/rocksdb/mysql-test/rocksdb/r/innodb_i_s_tables_disabled.result
+++ b/storage/rocksdb/mysql-test/rocksdb/r/innodb_i_s_tables_disabled.result
@@ -79,7 +79,7 @@ buffer_LRU_batch_flush_avg_time_thread	buffer	0	NULL	NULL	NULL	0	NULL	NULL	NULL
 buffer_flush_adaptive_avg_time_est	buffer	0	NULL	NULL	NULL	0	NULL	NULL	NULL	NULL	NULL	NULL	NULL	disabled	counter	Estimated time (ms) spent for adaptive flushing recently.
 buffer_LRU_batch_flush_avg_time_est	buffer	0	NULL	NULL	NULL	0	NULL	NULL	NULL	NULL	NULL	NULL	NULL	disabled	counter	Estimated time (ms) spent for LRU batch flushing recently.
 buffer_flush_avg_time	buffer	0	NULL	NULL	NULL	0	NULL	NULL	NULL	NULL	NULL	NULL	NULL	disabled	counter	Avg time (ms) spent for flushing recently.
-buffer_flush_adaptive_avg_pass	buffer	0	NULL	NULL	NULL	0	NULL	NULL	NULL	NULL	NULL	NULL	NULL	disabled	counter	Numner of adaptive flushes passed during the recent Avg period.
+buffer_flush_adaptive_avg_pass	buffer	0	NULL	NULL	NULL	0	NULL	NULL	NULL	NULL	NULL	NULL	NULL	disabled	counter	Number of adaptive flushes passed during the recent Avg period.
 buffer_LRU_batch_flush_avg_pass	buffer	0	NULL	NULL	NULL	0	NULL	NULL	NULL	NULL	NULL	NULL	NULL	disabled	counter	Number of LRU batch flushes passed during the recent Avg period.
 buffer_flush_avg_pass	buffer	0	NULL	NULL	NULL	0	NULL	NULL	NULL	NULL	NULL	NULL	NULL	disabled	counter	Number of flushes passed during the recent Avg period.
 buffer_LRU_get_free_loops	buffer	0	NULL	NULL	NULL	0	NULL	NULL	NULL	NULL	NULL	NULL	NULL	disabled	counter	Total loops in LRU get free.
diff --git a/storage/rocksdb/mysql-test/rocksdb/t/lock_rows_not_exist.test b/storage/rocksdb/mysql-test/rocksdb/t/lock_rows_not_exist.test
index d8a6bde45c8..a51a516aaaa 100644
--- a/storage/rocksdb/mysql-test/rocksdb/t/lock_rows_not_exist.test
+++ b/storage/rocksdb/mysql-test/rocksdb/t/lock_rows_not_exist.test
@@ -57,7 +57,7 @@ DELETE FROM t WHERE id1=1 AND id2=1 AND id3=0;
 --disable_parsing
 # 
 #  The following is commented out because RocksDB's Transaction API doesn't
-#  "support" READ COMMITED, in particular, it doesn't release row locks 
+#  "support" READ COMMITTED, in particular, it doesn't release row locks 
 #   after each statement. (MyRocks is able to request a new snapshot for 
 #  every statement, but this won't free the locks. TODO: Is the behavior
 #  that is tested below really needed?)
diff --git a/storage/sphinx/ha_sphinx.cc b/storage/sphinx/ha_sphinx.cc
index 812b362e737..4092cfcb514 100644
--- a/storage/sphinx/ha_sphinx.cc
+++ b/storage/sphinx/ha_sphinx.cc
@@ -3351,7 +3351,7 @@ int ha_sphinx::delete_table ( const char * )
 // Renames a table from one name to another from alter table call.
 //
 // If you do not implement this, the default rename_table() is called from
-// handler.cc and it will delete all files with the file extentions returned
+// handler.cc and it will delete all files with the file extensions returned
 // by bas_ext().
 //
 // Called from sql_table.cc by mysql_rename_table().
diff --git a/storage/spider/mysql-test/spider/r/pushdown_not_like.result b/storage/spider/mysql-test/spider/r/pushdown_not_like.result
new file mode 100644
index 00000000000..0e007b094de
--- /dev/null
+++ b/storage/spider/mysql-test/spider/r/pushdown_not_like.result
@@ -0,0 +1,63 @@
+for master_1
+for child2
+child2_1
+child2_2
+child2_3
+for child3
+child3_1
+child3_2
+child3_3
+
+drop and create databases
+connection master_1;
+DROP DATABASE IF EXISTS auto_test_local;
+CREATE DATABASE auto_test_local;
+USE auto_test_local;
+connection child2_1;
+DROP DATABASE IF EXISTS auto_test_remote;
+CREATE DATABASE auto_test_remote;
+USE auto_test_remote;
+
+create table select test
+connection master_1;
+DROP TABLE IF EXISTS ta_l;
+CREATE TABLE ta_l (
+a INT,
+b CHAR(1),
+c DATETIME,
+PRIMARY KEY(a)
+) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1
+INSERT INTO ta_l (a, b, c) VALUES
+(1, 'a', '2018-11-01 10:21:39'),
+(2, 'b', '2015-06-30 23:59:59'),
+(3, 'c', '2013-11-01 01:01:01');
+
+spider not like bug fix test
+connection master_1;
+select * from ta_l where b not like 'a%';
+a	b	c
+2	b	2015-06-30 23:59:59
+3	c	2013-11-01 01:01:01
+connection child2_1;
+SELECT argument FROM mysql.general_log WHERE argument LIKE '%select%';
+argument
+select t0.`a` `a`,t0.`b` `b`,t0.`c` `c` from `auto_test_remote`.`ta_r` t0 where (t0.`b` not like 'a%')
+SELECT argument FROM mysql.general_log WHERE argument LIKE '%select%'
+
+deinit
+connection master_1;
+DROP DATABASE IF EXISTS auto_test_local;
+connection child2_1;
+DROP DATABASE IF EXISTS auto_test_remote;
+SET GLOBAL log_output = @old_log_output;
+for master_1
+for child2
+child2_1
+child2_2
+child2_3
+for child3
+child3_1
+child3_2
+child3_3
+
+end of test
diff --git a/storage/spider/mysql-test/spider/t/pushdown_not_like.test b/storage/spider/mysql-test/spider/t/pushdown_not_like.test
new file mode 100644
index 00000000000..95e4fa6eea8
--- /dev/null
+++ b/storage/spider/mysql-test/spider/t/pushdown_not_like.test
@@ -0,0 +1,138 @@
+--disable_warnings
+--disable_query_log
+--disable_result_log
+--source test_init.inc
+--enable_result_log
+--enable_query_log
+
+
+--echo
+--echo drop and create databases
+--connection master_1
+DROP DATABASE IF EXISTS auto_test_local;
+CREATE DATABASE auto_test_local;
+USE auto_test_local;
+if ($USE_CHILD_GROUP2)
+{
+  --connection child2_1
+  DROP DATABASE IF EXISTS auto_test_remote;
+  CREATE DATABASE auto_test_remote;
+  USE auto_test_remote;
+}
+--enable_warnings
+
+
+--echo
+--echo create table select test
+if ($USE_CHILD_GROUP2)
+{
+  if (!$OUTPUT_CHILD_GROUP2)
+  {
+    --disable_query_log
+    --disable_result_log
+  }
+  --connection child2_1
+  if ($OUTPUT_CHILD_GROUP2)
+  {
+    --disable_query_log
+    echo CHILD2_1_DROP_TABLES;
+    echo CHILD2_1_CREATE_TABLES;
+  }
+  --disable_warnings
+  eval $CHILD2_1_DROP_TABLES;
+  --enable_warnings
+  eval $CHILD2_1_CREATE_TABLES;
+  if ($OUTPUT_CHILD_GROUP2)
+  {
+    --enable_query_log
+  }
+  if ($USE_GENERAL_LOG)
+  {
+    SET @old_log_output = @@global.log_output;
+    TRUNCATE TABLE mysql.general_log;
+    set global log_output = 'TABLE';
+  }
+  if (!$OUTPUT_CHILD_GROUP2)
+  {
+    --enable_query_log
+    --enable_result_log
+  }
+}
+
+--connection master_1
+--disable_warnings
+DROP TABLE IF EXISTS ta_l;
+--enable_warnings
+--disable_query_log
+echo CREATE TABLE ta_l (
+  a INT,
+  b CHAR(1),
+  c DATETIME,
+  PRIMARY KEY(a)
+) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1;
+eval CREATE TABLE ta_l (
+  a INT,
+  b CHAR(1),
+  c DATETIME,
+  PRIMARY KEY(a)
+) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1;
+--enable_query_log
+INSERT INTO ta_l (a, b, c) VALUES
+  (1, 'a', '2018-11-01 10:21:39'),
+  (2, 'b', '2015-06-30 23:59:59'),
+  (3, 'c', '2013-11-01 01:01:01');
+
+--echo
+--echo spider not like bug fix test
+if ($USE_CHILD_GROUP2)
+{
+  if (!$OUTPUT_CHILD_GROUP2)
+  {
+    --disable_query_log
+    --disable_result_log
+  }
+  --connection child2_1
+  if ($USE_GENERAL_LOG)
+  {
+    TRUNCATE TABLE mysql.general_log;
+  }
+  if (!$OUTPUT_CHILD_GROUP2)
+  {
+    --enable_query_log
+    --enable_result_log
+  }
+}
+
+--connection master_1
+select * from ta_l where b not like 'a%';
+if ($USE_CHILD_GROUP2)
+{
+  --connection child2_1
+  if ($USE_GENERAL_LOG)
+  {
+    SELECT argument FROM mysql.general_log WHERE argument LIKE '%select%';
+  }
+}
+
+
+--echo
+--echo deinit
+--disable_warnings
+--connection master_1
+DROP DATABASE IF EXISTS auto_test_local;
+if ($USE_CHILD_GROUP2)
+{
+  --connection child2_1
+  DROP DATABASE IF EXISTS auto_test_remote;
+  SET GLOBAL log_output = @old_log_output;
+}
+
+
+--disable_query_log
+--disable_result_log
+--source test_deinit.inc
+--enable_result_log
+--enable_query_log
+--enable_warnings
+--echo
+--echo end of test
diff --git a/storage/spider/spd_db_include.h b/storage/spider/spd_db_include.h
index e7fe0cebee7..d51770c1a77 100644
--- a/storage/spider/spd_db_include.h
+++ b/storage/spider/spd_db_include.h
@@ -161,6 +161,8 @@ typedef st_spider_result SPIDER_RESULT;
 #define SPIDER_SQL_IN_LEN (sizeof(SPIDER_SQL_IN_STR) - 1)
 #define SPIDER_SQL_NOT_IN_STR "not in("
 #define SPIDER_SQL_NOT_IN_LEN (sizeof(SPIDER_SQL_NOT_IN_STR) - 1)
+#define SPIDER_SQL_NOT_LIKE_STR "not like"
+#define SPIDER_SQL_NOT_LIKE_LEN (sizeof(SPIDER_SQL_NOT_LIKE_STR) - 1)
 #define SPIDER_SQL_AS_CHAR_STR " as char"
 #define SPIDER_SQL_AS_CHAR_LEN (sizeof(SPIDER_SQL_AS_CHAR_STR) - 1)
 #define SPIDER_SQL_CAST_STR "cast("
diff --git a/storage/spider/spd_db_mysql.cc b/storage/spider/spd_db_mysql.cc
index 1b62b4a9bd5..0329509c748 100644
--- a/storage/spider/spd_db_mysql.cc
+++ b/storage/spider/spd_db_mysql.cc
@@ -4789,13 +4789,27 @@ int spider_db_mbase_util::open_item_func(
     case Item_func::LE_FUNC:
     case Item_func::GE_FUNC:
     case Item_func::GT_FUNC:
-    case Item_func::LIKE_FUNC:
       if (str)
       {
         func_name = (char*) item_func->func_name();
         func_name_length = strlen(func_name);
       }
       break;
+    case Item_func::LIKE_FUNC:
+      if (str)
+      {
+         if (((Item_func_like *)item_func)->negated)
+         {
+            func_name = SPIDER_SQL_NOT_LIKE_STR;
+            func_name_length = SPIDER_SQL_NOT_LIKE_LEN;
+         }
+         else
+         {
+            func_name = (char*)item_func->func_name();
+            func_name_length = strlen(func_name);
+         }
+      }
+      break;
     default:
       THD *thd = spider->trx->thd;
       SPIDER_SHARE *share = spider->share;
diff --git a/storage/tokudb/CMakeLists.txt b/storage/tokudb/CMakeLists.txt
index f22f7c1d6b5..088a24f827b 100644
--- a/storage/tokudb/CMakeLists.txt
+++ b/storage/tokudb/CMakeLists.txt
@@ -168,3 +168,5 @@ TARGET_LINK_LIBRARIES(tokudb tokufractaltree_static tokuportability_static
 
 SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} -flto -fuse-linker-plugin")
 SET(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO} -flto -fuse-linker-plugin")
+
+ADD_SUBDIRECTORY(man)
diff --git a/storage/tokudb/PerconaFT/DartConfig.cmake b/storage/tokudb/PerconaFT/DartConfig.cmake
deleted file mode 100644
index 9ad189869c6..00000000000
--- a/storage/tokudb/PerconaFT/DartConfig.cmake
+++ /dev/null
@@ -1,10 +0,0 @@
-if(BUILD_TESTING)
-  if (NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
-    # Valgrind on OSX 10.8 generally works but outputs some warning junk
-    # that is hard to parse out, so we'll just let it run alone
-    set(MEMORYCHECK_COMMAND "${TokuDB_SOURCE_DIR}/scripts/tokuvalgrind")
-  endif ()
-  set(MEMORYCHECK_COMMAND_OPTIONS "--gen-suppressions=no --soname-synonyms=somalloc=*tokuportability* --quiet --num-callers=20 --leak-check=full --show-reachable=yes --trace-children=yes --trace-children-skip=sh,*/sh,basename,*/basename,dirname,*/dirname,rm,*/rm,cp,*/cp,mv,*/mv,cat,*/cat,diff,*/diff,grep,*/grep,date,*/date,test,*/tokudb_dump,*/tdb-recover --trace-children-skip-by-arg=--only_create,--test,--no-shutdown,novalgrind" CACHE INTERNAL "options for valgrind")
-  set(MEMORYCHECK_SUPPRESSIONS_FILE "${CMAKE_CURRENT_BINARY_DIR}/valgrind.suppressions" CACHE INTERNAL "suppressions file for valgrind")
-  set(UPDATE_COMMAND "svn")
-endif()
diff --git a/storage/tokudb/PerconaFT/ft/cachetable/cachetable.cc b/storage/tokudb/PerconaFT/ft/cachetable/cachetable.cc
index 5467bef43b4..034d5442742 100644
--- a/storage/tokudb/PerconaFT/ft/cachetable/cachetable.cc
+++ b/storage/tokudb/PerconaFT/ft/cachetable/cachetable.cc
@@ -225,6 +225,9 @@ uint32_t toku_get_checkpoint_period_unlocked (CACHETABLE ct) {
 }
 
 void toku_set_cleaner_period (CACHETABLE ct, uint32_t new_period) {
+    if(force_recovery) {
+        return;
+    }
     ct->cl.set_period(new_period);
 }
 
@@ -3026,9 +3029,12 @@ int toku_cleaner_thread (void *cleaner_v) {
 //
 ENSURE_POD(cleaner);
 
+extern uint force_recovery;
+
 int cleaner::init(uint32_t _cleaner_iterations, pair_list* _pl, CACHETABLE _ct) {
     // default is no cleaner, for now
     m_cleaner_cron_init = false;
+    if (force_recovery) return 0;
     int r = toku_minicron_setup(&m_cleaner_cron, 0, toku_cleaner_thread, this);
     if (r == 0) {
         m_cleaner_cron_init = true;
diff --git a/storage/tokudb/PerconaFT/ft/ft-cachetable-wrappers.cc b/storage/tokudb/PerconaFT/ft/ft-cachetable-wrappers.cc
index 6b6ff1e323f..439e0688e89 100644
--- a/storage/tokudb/PerconaFT/ft/ft-cachetable-wrappers.cc
+++ b/storage/tokudb/PerconaFT/ft/ft-cachetable-wrappers.cc
@@ -73,7 +73,7 @@ cachetable_put_empty_node_with_dep_nodes(
     enum cachetable_dirty dependent_dirty_bits[num_dependent_nodes];
     for (uint32_t i = 0; i < num_dependent_nodes; i++) {
         dependent_pairs[i] = dependent_nodes[i]->ct_pair;
-        dependent_dirty_bits[i] = (enum cachetable_dirty) dependent_nodes[i]->dirty;
+        dependent_dirty_bits[i] = (enum cachetable_dirty) dependent_nodes[i]->dirty();
     }
 
     toku_cachetable_put_with_dep_pairs(
@@ -253,7 +253,7 @@ toku_pin_ftnode_for_query(
             // written out, it would have to be dirtied.  That
             // requires a write lock, and a write lock requires you to
             // resolve checkpointing.
-            if (!node->dirty) {
+            if (!node->dirty()) {
                 toku_ft_bn_update_max_msn(node, max_msn_in_path, bfe->child_to_read);
             }
         }
@@ -280,7 +280,7 @@ toku_pin_ftnode_with_dep_nodes(
     enum cachetable_dirty dependent_dirty_bits[num_dependent_nodes];
     for (uint32_t i = 0; i < num_dependent_nodes; i++) {
         dependent_pairs[i] = dependent_nodes[i]->ct_pair;
-        dependent_dirty_bits[i] = (enum cachetable_dirty) dependent_nodes[i]->dirty;
+        dependent_dirty_bits[i] = (enum cachetable_dirty) dependent_nodes[i]->dirty();
     }
 
     int r = toku_cachetable_get_and_pin_with_dep_pairs(
@@ -333,7 +333,7 @@ cleanup:
 void toku_unpin_ftnode(FT ft, FTNODE node) {
     int r = toku_cachetable_unpin(ft->cf,
                                   node->ct_pair,
-                                  static_cast<enum cachetable_dirty>(node->dirty),
+                                  static_cast<enum cachetable_dirty>(node->dirty()),
                                   make_ftnode_pair_attr(node));
     invariant_zero(r);
 }
@@ -344,7 +344,7 @@ toku_unpin_ftnode_read_only(FT ft, FTNODE node)
     int r = toku_cachetable_unpin(
         ft->cf,
         node->ct_pair,
-        (enum cachetable_dirty) node->dirty,
+        (enum cachetable_dirty) node->dirty(),
         make_invalid_pair_attr()
         );
     assert(r==0);
diff --git a/storage/tokudb/PerconaFT/ft/ft-flusher.cc b/storage/tokudb/PerconaFT/ft/ft-flusher.cc
index 3fd59f388ce..bbb2a170cb9 100644
--- a/storage/tokudb/PerconaFT/ft/ft-flusher.cc
+++ b/storage/tokudb/PerconaFT/ft/ft-flusher.cc
@@ -139,7 +139,7 @@ maybe_destroy_child_blbs(FTNODE node, FTNODE child, FT ft)
     // up to date.
     if (child->n_children > 1 && 
         child->height == 0 && 
-        !child->dirty) {
+        !child->dirty()) {
         for (int i = 0; i < child->n_children; ++i) {
             if (BP_STATE(child, i) == PT_AVAIL &&
                 node->max_msn_applied_to_node_on_disk.msn < BLB_MAX_MSN_APPLIED(child, i).msn) 
@@ -480,7 +480,7 @@ handle_split_of_child(
         }
     )
 
-    node->dirty = 1;
+    node->set_dirty();
 
     XREALLOC_N(node->n_children+1, node->bp);
     // Slide the children over.
@@ -662,8 +662,8 @@ static void ftnode_finalize_split(FTNODE node, FTNODE B, MSN max_msn_applied_to_
     // The new node in the split inherits the oldest known reference xid
     B->oldest_referenced_xid_known = node->oldest_referenced_xid_known;
 
-    node->dirty = 1;
-    B->dirty = 1;
+    node->set_dirty();
+    B->set_dirty();
 }
 
 void
@@ -1003,8 +1003,8 @@ flush_this_child(
     paranoid_invariant(child->blocknum.b!=0);
     // VERIFY_NODE does not work off client thread as of now
     //VERIFY_NODE(t, child);
-    node->dirty = 1;
-    child->dirty = 1;
+    node->set_dirty();
+    child->set_dirty();
 
     BP_WORKDONE(node, childnum) = 0;  // this buffer is drained, no work has been done by its contents
     NONLEAF_CHILDINFO bnc = BNC(node, childnum);
@@ -1034,8 +1034,8 @@ merge_leaf_nodes(FTNODE a, FTNODE b)
     // TODO(leif): this is no longer the way in_memory_stats is
     // maintained. verify that it's ok to move this just before the unpin
     // and then do that.
-    a->dirty = 1;
-    b->dirty = 1;
+    a->set_dirty();
+    b->set_dirty();
 
     bn_data* a_last_bd = BLB_DATA(a, a->n_children-1);
     // this bool states if the last basement node in a has any items or not
@@ -1167,8 +1167,8 @@ maybe_merge_pinned_nonleaf_nodes(
     a->n_children = new_n_children;
     b->n_children = 0;
 
-    a->dirty = 1;
-    b->dirty = 1;
+    a->set_dirty();
+    b->set_dirty();
 
     *did_merge = true;
     *did_rebalance = false;
@@ -1211,7 +1211,7 @@ maybe_merge_pinned_nodes(
     toku_ftnode_assert_fully_in_memory(parent);
     toku_ftnode_assert_fully_in_memory(a);
     toku_ftnode_assert_fully_in_memory(b);
-    parent->dirty = 1;   // just to make sure
+    parent->set_dirty();   // just to make sure
     {
         MSN msna = a->max_msn_applied_to_node_on_disk;
         MSN msnb = b->max_msn_applied_to_node_on_disk;
@@ -1335,8 +1335,8 @@ ft_merge_child(
             }
 
             paranoid_invariant(BP_BLOCKNUM(node, childnuma).b == childa->blocknum.b);
-            childa->dirty = 1;  // just to make sure
-            childb->dirty = 1;  // just to make sure
+            childa->set_dirty();  // just to make sure
+            childb->set_dirty();  // just to make sure
         } else {
             // flow will be inaccurate for a while, oh well.  the children
             // are leaves in this case so it's not a huge deal (we're
@@ -1345,7 +1345,7 @@ ft_merge_child(
             // If we didn't merge the nodes, then we need the correct pivot.
             invariant_notnull(splitk.data);
             node->pivotkeys.replace_at(&splitk, childnuma);
-            node->dirty = 1;
+            node->set_dirty();
         }
         toku_destroy_dbt(&splitk);
     }
@@ -1369,7 +1369,7 @@ ft_merge_child(
         call_flusher_thread_callback(ft_flush_aflter_merge);
 
         // unlock the parent
-        paranoid_invariant(node->dirty);
+        paranoid_invariant(node->dirty());
         toku_unpin_ftnode(ft, node);
     }
     else {
@@ -1377,7 +1377,7 @@ ft_merge_child(
         call_flusher_thread_callback(ft_flush_aflter_rebalance);
 
         // unlock the parent
-        paranoid_invariant(node->dirty);
+        paranoid_invariant(node->dirty());
         toku_unpin_ftnode(ft, node);
         toku_unpin_ftnode(ft, childb);
     }
@@ -1439,9 +1439,9 @@ void toku_ft_flush_some_child(FT ft, FTNODE parent, struct flusher_advice *fa)
 
     // only do the following work if there is a flush to perform
     if (toku_bnc_n_entries(BNC(parent, childnum)) > 0 || parent->height == 1) {
-        if (!parent->dirty) {
+        if (!parent->dirty()) {
             dirtied++;
-            parent->dirty = 1;
+            parent->set_dirty();
         }
         // detach buffer
         BP_WORKDONE(parent, childnum) = 0;  // this buffer is drained, no work has been done by its contents
@@ -1486,9 +1486,9 @@ void toku_ft_flush_some_child(FT ft, FTNODE parent, struct flusher_advice *fa)
     // in the buffer to flush, and as a result, flushing is not necessary
     // and bnc is NULL
     if (bnc != NULL) {
-        if (!child->dirty) {
+        if (!child->dirty()) {
             dirtied++;
-            child->dirty = 1;
+            child->set_dirty();
         }
         // do the actual flush
         toku_bnc_flush_to_child(
@@ -1787,7 +1787,7 @@ static void flush_node_fun(void *fe_v)
     // read them back in, or just do the regular partial fetch.  If we
     // don't, that means fe->node is a parent, so we need to do this anyway.
     bring_node_fully_into_memory(fe->node,fe->ft);
-    fe->node->dirty = 1;
+    fe->node->set_dirty();
 
     struct flusher_advice fa;
     struct flush_status_update_extra fste;
@@ -1893,7 +1893,7 @@ void toku_ft_flush_node_on_background_thread(FT ft, FTNODE parent)
             //
             // can detach buffer and unpin root here
             //
-            parent->dirty = 1;
+            parent->set_dirty();
             BP_WORKDONE(parent, childnum) = 0;  // this buffer is drained, no work has been done by its contents
             NONLEAF_CHILDINFO bnc = BNC(parent, childnum);
             NONLEAF_CHILDINFO new_bnc = toku_create_empty_nl();
diff --git a/storage/tokudb/PerconaFT/ft/ft-internal.h b/storage/tokudb/PerconaFT/ft/ft-internal.h
index eec591d1744..130d3c302aa 100644
--- a/storage/tokudb/PerconaFT/ft/ft-internal.h
+++ b/storage/tokudb/PerconaFT/ft/ft-internal.h
@@ -76,11 +76,30 @@ enum ft_type {
     FT_CHECKPOINT_INPROGRESS
 };
 
+extern "C" {
+extern uint force_recovery;
+}
+
+extern int writing_rollback;
+
 // The ft_header is not managed by the cachetable.  Instead, it hangs off the cachefile as userdata.
 struct ft_header {
     enum ft_type type;
 
-    int dirty;
+    int dirty_;
+
+    void set_dirty() {
+        if(force_recovery) assert(writing_rollback);
+        dirty_ = 1;
+    }
+
+    void clear_dirty() {
+        dirty_ = 0;
+    }
+
+    bool dirty() {
+        return dirty_;
+    }
 
     // Free-running counter incremented once per checkpoint (toggling LSB).
     // LSB indicates which header location is used on disk so this
diff --git a/storage/tokudb/PerconaFT/ft/ft-ops.cc b/storage/tokudb/PerconaFT/ft/ft-ops.cc
index df0d88a9580..d752f13c9c3 100644
--- a/storage/tokudb/PerconaFT/ft/ft-ops.cc
+++ b/storage/tokudb/PerconaFT/ft/ft-ops.cc
@@ -656,7 +656,7 @@ void toku_ftnode_clone_callback(void *value_data,
         node->layout_version_read_from_disk;
     cloned_node->build_id = node->build_id;
     cloned_node->height = node->height;
-    cloned_node->dirty = node->dirty;
+    cloned_node->dirty_ = node->dirty_;
     cloned_node->fullhash = node->fullhash;
     cloned_node->n_children = node->n_children;
 
@@ -672,8 +672,8 @@ void toku_ftnode_clone_callback(void *value_data,
     toku_ftnode_clone_partitions(node, cloned_node);
 
     // clear dirty bit
-    node->dirty = 0;
-    cloned_node->dirty = 0;
+    node->clear_dirty();
+    cloned_node->clear_dirty();
     node->layout_version_read_from_disk = FT_LAYOUT_VERSION;
     // set new pair attr if necessary
     if (node->height == 0) {
@@ -742,7 +742,7 @@ void toku_ftnode_flush_callback(CACHEFILE UU(cachefile),
                 // persisted, we need undo the logical row count adjustments as
                 // they may occur again in the future if/when the node is
                 // re-read from disk for another query or change.
-                if (!ftnode->dirty && !write_me) {
+                if (!ftnode->dirty() && !write_me) {
                     int64_t lrc_delta = 0;
                     for (int i = 0; i < ftnode->n_children; i++) {
                         if (BP_STATE(ftnode, i) == PT_AVAIL) {
@@ -847,8 +847,8 @@ int toku_ftnode_fetch_callback(CACHEFILE UU(cachefile),
     if (r == 0) {
         *sizep = make_ftnode_pair_attr(*node);
         (*node)->ct_pair = p;
-        *dirtyp = (*node)->dirty;  // deserialize could mark the node as dirty
-                                   // (presumably for upgrade)
+        *dirtyp = (*node)->dirty();  // deserialize could mark the node as dirty
+                                     // (presumably for upgrade)
     }
     return r;
 }
@@ -870,7 +870,7 @@ void toku_ftnode_pe_est_callback(
     paranoid_invariant(ftnode_pv != NULL);
     long bytes_to_free = 0;
     FTNODE node = static_cast<FTNODE>(ftnode_pv);
-    if (node->dirty || node->height == 0 ||
+    if (node->dirty() || node->height == 0 ||
         node->layout_version_read_from_disk < FT_FIRST_LAYOUT_VERSION_WITH_BASEMENT_NODES) {
         *bytes_freed_estimate = 0;
         *cost = PE_CHEAP;
@@ -947,7 +947,7 @@ int toku_ftnode_pe_callback(void *ftnode_pv,
     void *pointers_to_free[node->n_children * 2];
 
     // Don't partially evict dirty nodes
-    if (node->dirty) {
+    if (node->dirty()) {
         goto exit;
     }
     // Don't partially evict nodes whose partitions can't be read back
@@ -1400,7 +1400,7 @@ ft_init_new_root(FT ft, FTNODE oldroot, FTNODE *newrootp)
     MSN msna = oldroot->max_msn_applied_to_node_on_disk;
     newroot->max_msn_applied_to_node_on_disk = msna;
     BP_STATE(newroot,0) = PT_AVAIL;
-    newroot->dirty = 1;
+    newroot->set_dirty();
 
     // Set the first child to have the new blocknum,
     // and then swap newroot with oldroot. The new root
@@ -1488,7 +1488,7 @@ static void inject_message_in_locked_node(
     // mark the node as dirty.
     // enforcing invariant here.
     //
-    paranoid_invariant(node->dirty != 0);
+    paranoid_invariant(node->dirty() != 0);
 
     // update some status variables
     if (node->height != 0) {
@@ -1848,7 +1848,7 @@ static void push_something_in_subtree(
                 }
             }
 
-            if (next_loc != NEITHER_EXTREME || child->dirty || toku_bnc_should_promote(ft, bnc)) {
+            if (next_loc != NEITHER_EXTREME || child->dirty() || toku_bnc_should_promote(ft, bnc)) {
                 push_something_in_subtree(ft, child, -1, msg, flow_deltas, gc_info, depth + 1, next_loc, false);
                 toku_sync_fetch_and_add(&bnc->flow[0], flow_deltas[0]);
                 // The recursive call unpinned the child, but
@@ -2803,9 +2803,9 @@ static int ft_create_file(FT_HANDLE UU(ft_handle), const char *fname, int *fdp)
 }
 
 // open a file for use by the ft.  if the file does not exist, error
-static int ft_open_file(const char *fname, int *fdp) {
+static int ft_open_file(const char *fname, int *fdp, bool rw) {
     int fd;
-    fd = ft_open_maybe_direct(fname, O_RDWR | O_BINARY, file_mode);
+    fd = ft_open_maybe_direct(fname, (rw ? O_RDWR : O_RDONLY) | O_BINARY, file_mode);
     if (fd==-1) {
         return get_error_errno();
     }
@@ -2956,7 +2956,7 @@ toku_ft_handle_inherit_options(FT_HANDLE t, FT ft) {
 // The checkpointed version (checkpoint_lsn) of the dictionary must be no later than max_acceptable_lsn .
 // Requires: The multi-operation client lock must be held to prevent a checkpoint from occuring.
 static int
-ft_handle_open(FT_HANDLE ft_h, const char *fname_in_env, int is_create, int only_create, CACHETABLE cachetable, TOKUTXN txn, FILENUM use_filenum, DICTIONARY_ID use_dictionary_id, LSN max_acceptable_lsn) {
+ft_handle_open(FT_HANDLE ft_h, const char *fname_in_env, int is_create, int only_create, CACHETABLE cachetable, TOKUTXN txn, FILENUM use_filenum, DICTIONARY_ID use_dictionary_id, LSN max_acceptable_lsn, bool open_rw = true) {
     int r;
     bool txn_created = false;
     char *fname_in_cwd = NULL;
@@ -2978,7 +2978,7 @@ ft_handle_open(FT_HANDLE ft_h, const char *fname_in_env, int is_create, int only
     fname_in_cwd = toku_cachetable_get_fname_in_cwd(cachetable, fname_in_env);
     {
         int fd = -1;
-        r = ft_open_file(fname_in_cwd, &fd);
+        r = ft_open_file(fname_in_cwd, &fd, open_rw);
         if (reserved_filenum.fileid == FILENUM_NONE.fileid) {
             reserved_filenum = toku_cachetable_reserve_filenum(cachetable);
         }
@@ -3124,15 +3124,15 @@ toku_ft_handle_open_recovery(FT_HANDLE t, const char *fname_in_env, int is_creat
 // Open an ft in normal use.  The FILENUM and dict_id are assigned by the ft_handle_open() function.
 // Requires: The multi-operation client lock must be held to prevent a checkpoint from occuring.
 int
-toku_ft_handle_open(FT_HANDLE t, const char *fname_in_env, int is_create, int only_create, CACHETABLE cachetable, TOKUTXN txn) {
+toku_ft_handle_open(FT_HANDLE t, const char *fname_in_env, int is_create, int only_create, CACHETABLE cachetable, TOKUTXN txn, bool open_rw) {
     int r;
-    r = ft_handle_open(t, fname_in_env, is_create, only_create, cachetable, txn, FILENUM_NONE, DICTIONARY_ID_NONE, MAX_LSN);
+    r = ft_handle_open(t, fname_in_env, is_create, only_create, cachetable, txn, FILENUM_NONE, DICTIONARY_ID_NONE, MAX_LSN, open_rw);
     return r;
 }
 
 // clone an ft handle. the cloned handle has a new dict_id but refers to the same fractal tree
 int 
-toku_ft_handle_clone(FT_HANDLE *cloned_ft_handle, FT_HANDLE ft_handle, TOKUTXN txn) {
+toku_ft_handle_clone(FT_HANDLE *cloned_ft_handle, FT_HANDLE ft_handle, TOKUTXN txn, bool open_rw) {
     FT_HANDLE result_ft_handle; 
     toku_ft_handle_create(&result_ft_handle);
 
@@ -3147,7 +3147,7 @@ toku_ft_handle_clone(FT_HANDLE *cloned_ft_handle, FT_HANDLE ft_handle, TOKUTXN t
     CACHEFILE cf = ft_handle->ft->cf;
     CACHETABLE ct = toku_cachefile_get_cachetable(cf);
     const char *fname_in_env = toku_cachefile_fname_in_env(cf);
-    int r = toku_ft_handle_open(result_ft_handle, fname_in_env, false, false, ct, txn); 
+    int r = toku_ft_handle_open(result_ft_handle, fname_in_env, false, false, ct, txn, open_rw);
     if (r != 0) {
         toku_ft_handle_close(result_ft_handle);
         result_ft_handle = NULL;
@@ -3548,7 +3548,7 @@ unlock_ftnode_fun (void *v) {
     int r = toku_cachetable_unpin_ct_prelocked_no_flush(
         ft_handle->ft->cf,
         node->ct_pair,
-        (enum cachetable_dirty) node->dirty,
+        (enum cachetable_dirty) node->dirty(),
         x->msgs_applied ? make_ftnode_pair_attr(node) : make_invalid_pair_attr()
         );
     assert_zero(r);
@@ -4970,6 +4970,14 @@ static void toku_pfs_keys_destroy(void) {
 }
 
 int toku_ft_layer_init(void) {
+    static bool ft_layer_init_started = false;
+
+    if(ft_layer_init_started) {
+        return 0;
+    }
+
+    ft_layer_init_started = true;
+
     int r = 0;
 
     // Portability must be initialized first
@@ -5000,6 +5008,14 @@ exit:
 }
 
 void toku_ft_layer_destroy(void) {
+    static bool ft_layer_destroy_started = false;
+
+    if(ft_layer_destroy_started) {
+        return;
+    }
+
+    ft_layer_destroy_started = true;
+
     toku_mutex_destroy(&ft_open_close_lock);
     toku_ft_serialize_layer_destroy();
     toku_checkpoint_destroy();
diff --git a/storage/tokudb/PerconaFT/ft/ft-ops.h b/storage/tokudb/PerconaFT/ft/ft-ops.h
index df8ffe287df..7b6d0634c37 100644
--- a/storage/tokudb/PerconaFT/ft/ft-ops.h
+++ b/storage/tokudb/PerconaFT/ft/ft-ops.h
@@ -125,12 +125,12 @@ typedef int (*ft_update_func)(DB *db, const DBT *key, const DBT *old_val, const
 void toku_ft_set_update(FT_HANDLE ft_h, ft_update_func update_fun);
 
 int toku_ft_handle_open(FT_HANDLE, const char *fname_in_env,
-		  int is_create, int only_create, CACHETABLE ct, TOKUTXN txn)  __attribute__ ((warn_unused_result));
+		  int is_create, int only_create, CACHETABLE ct, TOKUTXN txn, bool open_rw=true)  __attribute__ ((warn_unused_result));
 int toku_ft_handle_open_recovery(FT_HANDLE, const char *fname_in_env, int is_create, int only_create, CACHETABLE ct, TOKUTXN txn, 
 			   FILENUM use_filenum, LSN max_acceptable_lsn)  __attribute__ ((warn_unused_result));
 
 // clone an ft handle. the cloned handle has a new dict_id but refers to the same fractal tree
-int toku_ft_handle_clone(FT_HANDLE *cloned_ft_handle, FT_HANDLE ft_handle, TOKUTXN txn);
+int toku_ft_handle_clone(FT_HANDLE *cloned_ft_handle, FT_HANDLE ft_handle, TOKUTXN txn, bool open_rw=true);
 
 // close an ft handle during normal operation. the underlying ft may or may not close,
 // depending if there are still references. an lsn for this close will come from the logger.
diff --git a/storage/tokudb/PerconaFT/ft/ft-recount-rows.cc b/storage/tokudb/PerconaFT/ft/ft-recount-rows.cc
index e31d80772d5..3b5501b66d3 100644
--- a/storage/tokudb/PerconaFT/ft/ft-recount-rows.cc
+++ b/storage/tokudb/PerconaFT/ft/ft-recount-rows.cc
@@ -98,7 +98,7 @@ int toku_ft_recount_rows(FT_HANDLE ft,
     if (rre._cancelled == false) {
         // update ft count
         toku_unsafe_set(&ft->ft->in_memory_logical_rows, rre._keys);
-        ft->ft->h->dirty = 1;
+        ft->ft->h->set_dirty();
         ret = 0;
     }
 
diff --git a/storage/tokudb/PerconaFT/ft/ft-test-helpers.cc b/storage/tokudb/PerconaFT/ft/ft-test-helpers.cc
index a82d8a80718..ad1dda01760 100644
--- a/storage/tokudb/PerconaFT/ft/ft-test-helpers.cc
+++ b/storage/tokudb/PerconaFT/ft/ft-test-helpers.cc
@@ -259,7 +259,7 @@ int toku_testsetup_insert_to_nonleaf (FT_HANDLE ft_handle, BLOCKNUM blocknum, en
     // is directly queueing something in a FIFO instead of 
     // using ft APIs.
     node->max_msn_applied_to_node_on_disk = msn;
-    node->dirty = 1;
+    node->set_dirty();
     // Also hack max_msn_in_ft
     ft_handle->ft->h->max_msn_in_ft = msn;
 
diff --git a/storage/tokudb/PerconaFT/ft/ft-verify.cc b/storage/tokudb/PerconaFT/ft/ft-verify.cc
index 7e3a64f441e..4f6e07e61f2 100644
--- a/storage/tokudb/PerconaFT/ft/ft-verify.cc
+++ b/storage/tokudb/PerconaFT/ft/ft-verify.cc
@@ -512,7 +512,7 @@ toku_verify_ft_with_progress (FT_HANDLE ft_handle, int (*progress_callback)(void
     if (r == 0) {
         toku_ft_lock(ft_handle->ft);
         ft_handle->ft->h->time_of_last_verification = time(NULL);
-        ft_handle->ft->h->dirty = 1;
+        ft_handle->ft->h->set_dirty();
         toku_ft_unlock(ft_handle->ft);
     }
     return r;
diff --git a/storage/tokudb/PerconaFT/ft/ft.cc b/storage/tokudb/PerconaFT/ft/ft.cc
index c7c2ea33c9e..1106abfbfb4 100644
--- a/storage/tokudb/PerconaFT/ft/ft.cc
+++ b/storage/tokudb/PerconaFT/ft/ft.cc
@@ -61,7 +61,7 @@ void toku_reset_root_xid_that_created(FT ft, TXNID new_root_xid_that_created) {
     // (see cooperative use of dirty bit in ft_begin_checkpoint())
     toku_ft_lock(ft);
     ft->h->root_xid_that_created = new_root_xid_that_created;
-    ft->h->dirty = 1;
+    ft->h->set_dirty();
     toku_ft_unlock(ft);
 }
 
@@ -147,7 +147,7 @@ static void ft_begin_checkpoint (LSN checkpoint_lsn, void *header_v) {
     assert(ft->h->type == FT_CURRENT);
     assert(ft->checkpoint_header == NULL);
     ft_copy_for_checkpoint_unlocked(ft, checkpoint_lsn);
-    ft->h->dirty = 0;             // this is only place this bit is cleared        (in currentheader)
+    ft->h->clear_dirty();             // this is only place this bit is cleared        (in currentheader)
     ft->blocktable.note_start_checkpoint_unlocked();
     toku_ft_unlock (ft);
 }
@@ -186,7 +186,7 @@ static void ft_checkpoint (CACHEFILE cf, int fd, void *header_v) {
     FT_HEADER ch = ft->checkpoint_header;
     assert(ch);
     assert(ch->type == FT_CHECKPOINT_INPROGRESS);
-    if (ch->dirty) {            // this is only place this bit is tested (in checkpoint_header)
+    if (ch->dirty()) {            // this is only place this bit is tested (in checkpoint_header)
         TOKULOGGER logger = toku_cachefile_logger(cf);
         if (logger) {
             toku_logger_fsync_if_lsn_not_fsynced(logger, ch->checkpoint_lsn);
@@ -201,7 +201,7 @@ static void ft_checkpoint (CACHEFILE cf, int fd, void *header_v) {
                                                              
         // write translation and header to disk (or at least to OS internal buffer)
         toku_serialize_ft_to(fd, ch, &ft->blocktable, ft->cf);
-        ch->dirty = 0;                      // this is only place this bit is cleared (in checkpoint_header)
+        ch->clear_dirty();                      // this is only place this bit is cleared (in checkpoint_header)
         
         // fsync the cachefile
         toku_cachefile_fsync(cf);
@@ -255,7 +255,7 @@ static void ft_close(CACHEFILE cachefile, int fd, void *header_v, bool oplsn_val
                 toku_log_fclose(
                     logger,
                     &lsn,
-                    ft->h->dirty,
+                    ft->h->dirty(),
                     bs,
                     toku_cachefile_filenum(cachefile));  // flush the log on
                                                          // close (if new header
@@ -266,7 +266,7 @@ static void ft_close(CACHEFILE cachefile, int fd, void *header_v, bool oplsn_val
             }
         }
     }
-    if (ft->h->dirty) {               // this is the only place this bit is tested (in currentheader)
+    if (ft->h->dirty()) {               // this is the only place this bit is tested (in currentheader)
         bool do_checkpoint = true;
         if (logger && logger->rollback_cachefile == cachefile) {
             do_checkpoint = false;
@@ -275,7 +275,7 @@ static void ft_close(CACHEFILE cachefile, int fd, void *header_v, bool oplsn_val
             ft_begin_checkpoint(lsn, header_v);
             ft_checkpoint(cachefile, fd, ft);
             ft_end_checkpoint(cachefile, fd, header_v);
-            assert(!ft->h->dirty); // dirty bit should be cleared by begin_checkpoint and never set again (because we're closing the dictionary)
+            assert(!ft->h->dirty()); // dirty bit should be cleared by begin_checkpoint and never set again (because we're closing the dictionary)
         }
     }
 }
@@ -371,7 +371,7 @@ ft_header_create(FT_OPTIONS options, BLOCKNUM root_blocknum, TXNID root_xid_that
     uint64_t now = (uint64_t) time(NULL);
     struct ft_header h = {
         .type = FT_CURRENT,
-        .dirty = 0,
+        .dirty_ = 0,
         .checkpoint_count = 0,
         .checkpoint_lsn = ZERO_LSN,
         .layout_version = FT_LAYOUT_VERSION,
@@ -522,7 +522,7 @@ toku_ft_note_hot_begin(FT_HANDLE ft_handle) {
     toku_ft_lock(ft);
     ft->h->time_of_last_optimize_begin = now;
     ft->h->count_of_optimize_in_progress++;
-    ft->h->dirty = 1;
+    ft->h->set_dirty();
     toku_ft_unlock(ft);
 }
 
@@ -546,7 +546,7 @@ toku_ft_note_hot_complete(FT_HANDLE ft_handle, bool success, MSN msn_at_start_of
         if (ft->h->count_of_optimize_in_progress == ft->h->count_of_optimize_in_progress_read_from_disk)
             ft->h->count_of_optimize_in_progress = 0;
     }
-    ft->h->dirty = 1;
+    ft->h->set_dirty();
     toku_ft_unlock(ft);
 }
 
@@ -959,7 +959,7 @@ void toku_ft_remove_reference(
 void toku_ft_set_nodesize(FT ft, unsigned int nodesize) {
     toku_ft_lock(ft);
     ft->h->nodesize = nodesize;
-    ft->h->dirty = 1;
+    ft->h->set_dirty();
     toku_ft_unlock(ft);
 }
 
@@ -972,7 +972,7 @@ void toku_ft_get_nodesize(FT ft, unsigned int *nodesize) {
 void toku_ft_set_basementnodesize(FT ft, unsigned int basementnodesize) {
     toku_ft_lock(ft);
     ft->h->basementnodesize = basementnodesize;
-    ft->h->dirty = 1;
+    ft->h->set_dirty();
     toku_ft_unlock(ft);
 }
 
@@ -985,7 +985,7 @@ void toku_ft_get_basementnodesize(FT ft, unsigned int *basementnodesize) {
 void toku_ft_set_compression_method(FT ft, enum toku_compression_method method) {
     toku_ft_lock(ft);
     ft->h->compression_method = method;
-    ft->h->dirty = 1;
+    ft->h->set_dirty();
     toku_ft_unlock(ft);
 }
 
@@ -998,7 +998,7 @@ void toku_ft_get_compression_method(FT ft, enum toku_compression_method *methodp
 void toku_ft_set_fanout(FT ft, unsigned int fanout) {
     toku_ft_lock(ft);
     ft->h->fanout = fanout;
-    ft->h->dirty = 1;
+    ft->h->set_dirty();
     toku_ft_unlock(ft);
 }
 
diff --git a/storage/tokudb/PerconaFT/ft/ft.h b/storage/tokudb/PerconaFT/ft/ft.h
index ff0b63b2b12..5c6caead978 100644
--- a/storage/tokudb/PerconaFT/ft/ft.h
+++ b/storage/tokudb/PerconaFT/ft/ft.h
@@ -184,11 +184,11 @@ void tokuft_update_product_name_strings(void);
 extern char toku_product_name[TOKU_MAX_PRODUCT_NAME_LENGTH];
 
 struct toku_product_name_strings_struct {
-    char db_version[sizeof(toku_product_name) + sizeof("1.2.3 build ") + 256];
-    char environmentdictionary[sizeof(toku_product_name) + sizeof(".environment")];
-    char fileopsdirectory[sizeof(toku_product_name) + sizeof(".directory")];
-    char single_process_lock[sizeof(toku_product_name) + sizeof("___lock_dont_delete_me")];
-    char rollback_cachefile[sizeof(toku_product_name) + sizeof(".rollback")];
+    char db_version[sizeof(toku_product_name) + sizeof("1.2.3 build ") + 256 + 1];
+    char environmentdictionary[sizeof(toku_product_name) + sizeof(".environment") + 1];
+    char fileopsdirectory[sizeof(toku_product_name) + sizeof(".directory") + 1];
+    char single_process_lock[sizeof(toku_product_name) + sizeof("___lock_dont_delete_me") + 1];
+    char rollback_cachefile[sizeof(toku_product_name) + sizeof(".rollback") + 1];
 };
 
 extern struct toku_product_name_strings_struct toku_product_name_strings;
diff --git a/storage/tokudb/PerconaFT/ft/loader/loader.cc b/storage/tokudb/PerconaFT/ft/loader/loader.cc
index 5f57b473bc5..3ff237f05c7 100644
--- a/storage/tokudb/PerconaFT/ft/loader/loader.cc
+++ b/storage/tokudb/PerconaFT/ft/loader/loader.cc
@@ -1350,7 +1350,7 @@ int merge_row_arrays_base (struct row dest[/*an+bn*/], struct row a[/*an*/], int
  * Arguments:
  *   dest    write the rows here
  *   a,b     the rows being merged
- *   an,bn   the lenth of a and b respectively.
+ *   an,bn   the length of a and b respectively.
  *   dest_db We need the dest_db to run the comparison function.
  *   compare We need the compare function for the dest_db.
  */
@@ -1449,7 +1449,7 @@ static int merge_row_arrays (struct row dest[/*an+bn*/], struct row a[/*an*/], i
  * Arguments:
  *   dest    write the rows here
  *   a,b     the rows being merged
- *   an,bn   the lenth of a and b respectively.
+ *   an,bn   the length of a and b respectively.
  *   dest_db We need the dest_db to run the comparison function.
  *   compare We need the compare function for the dest_db.
  */
diff --git a/storage/tokudb/PerconaFT/ft/logger/logger.cc b/storage/tokudb/PerconaFT/ft/logger/logger.cc
index 9516f46df28..d66a1deecf9 100644
--- a/storage/tokudb/PerconaFT/ft/logger/logger.cc
+++ b/storage/tokudb/PerconaFT/ft/logger/logger.cc
@@ -50,6 +50,8 @@ Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved.
 
 #include "util/status.h"
 
+int writing_rollback = 0;
+
 static const int log_format_version = TOKU_LOG_VERSION;
 
 toku_instr_key *result_output_condition_lock_mutex_key;
@@ -232,6 +234,7 @@ void toku_logger_initialize_rollback_cache(TOKULOGGER logger, FT ft) {
 }
 
 int toku_logger_open_rollback(TOKULOGGER logger, CACHETABLE cachetable, bool create) {
+    writing_rollback++;
     assert(logger->is_open);
     assert(!logger->rollback_cachefile);
 
@@ -251,6 +254,7 @@ int toku_logger_open_rollback(TOKULOGGER logger, CACHETABLE cachetable, bool cre
     } else {
         toku_ft_handle_close(ft_handle);
     }
+    writing_rollback--;
     return r;
 }
 
@@ -268,20 +272,20 @@ void toku_logger_close_rollback_check_empty(TOKULOGGER logger, bool clean_shutdo
             FT CAST_FROM_VOIDP(ft, toku_cachefile_get_userdata(cf));
             if (clean_shutdown) {
                 //Verify it is safe to close it.
-                assert(!ft->h->dirty);  //Must not be dirty.
+                assert(!ft->h->dirty());  //Must not be dirty.
                 ft->blocktable.free_unused_blocknums(ft->h->root_blocknum);
                 // Must have no data blocks (rollback logs or otherwise).
                 ft->blocktable.verify_no_data_blocks_except_root(ft->h->root_blocknum);
-                assert(!ft->h->dirty);
+                assert(!ft->h->dirty());
             } else {
-                ft->h->dirty = 0;
+                ft->h->clear_dirty();
             }
             ft_to_close = toku_ft_get_only_existing_ft_handle(ft);
             if (clean_shutdown) {
                 bool is_empty;
                 is_empty = toku_ft_is_empty_fast(ft_to_close);
                 assert(is_empty);
-                assert(!ft->h->dirty); // it should not have been dirtied by the toku_ft_is_empty test.
+                assert(!ft->h->dirty()); // it should not have been dirtied by the toku_ft_is_empty test.
             }
         }
 
diff --git a/storage/tokudb/PerconaFT/ft/node.cc b/storage/tokudb/PerconaFT/ft/node.cc
index 8db2f895033..88f46c7812b 100644
--- a/storage/tokudb/PerconaFT/ft/node.cc
+++ b/storage/tokudb/PerconaFT/ft/node.cc
@@ -78,7 +78,7 @@ void toku_initialize_empty_ftnode(FTNODE n, BLOCKNUM blocknum, int height, int n
             }
         }
     }
-    n->dirty = 1;  // special case exception, it's okay to mark as dirty because the basements are empty
+    n->set_dirty();  // special case exception, it's okay to mark as dirty because the basements are empty
 
     toku_ft_status_note_ftnode(height, true);
 }
@@ -154,7 +154,7 @@ void toku_ftnode_clone_partitions(FTNODE node, FTNODE cloned_node) {
 
 void toku_evict_bn_from_memory(FTNODE node, int childnum, FT ft) {
     // free the basement node
-    assert(!node->dirty);
+    assert(!node->dirty());
     BASEMENTNODE bn = BLB(node, childnum);
     toku_ft_decrease_stats(&ft->in_memory_stats, bn->stat64_delta);
     toku_ft_adjust_logical_row_count(ft, -BLB_LRD(node, childnum));
@@ -596,7 +596,7 @@ toku_apply_ancestors_messages_to_node (
                         oldest_referenced_xid_for_simple_gc,
                         node->oldest_referenced_xid_known,
                         true);
-    if (!node->dirty && child_to_read >= 0) {
+    if (!node->dirty() && child_to_read >= 0) {
         paranoid_invariant(BP_STATE(node, child_to_read) == PT_AVAIL);
         apply_ancestors_messages_to_bn(
             t,
@@ -713,7 +713,7 @@ bool toku_ft_leaf_needs_ancestors_messages(
     paranoid_invariant(node->height == 0);
     bool needs_ancestors_messages = false;
     // child_to_read may be -1 in test cases
-    if (!node->dirty && child_to_read >= 0) {
+    if (!node->dirty() && child_to_read >= 0) {
         paranoid_invariant(BP_STATE(node, child_to_read) == PT_AVAIL);
         needs_ancestors_messages = bn_needs_ancestors_messages(
             ft,
@@ -746,7 +746,7 @@ cleanup:
 
 void toku_ft_bn_update_max_msn(FTNODE node, MSN max_msn_applied, int child_to_read) {
     invariant(node->height == 0);
-    if (!node->dirty && child_to_read >= 0) {
+    if (!node->dirty() && child_to_read >= 0) {
         paranoid_invariant(BP_STATE(node, child_to_read) == PT_AVAIL);
         BASEMENTNODE bn = BLB(node, child_to_read);
         if (max_msn_applied.msn > bn->max_msn_applied.msn) {
@@ -833,7 +833,7 @@ struct rebalance_array_info {
 void toku_ftnode_leaf_rebalance(FTNODE node, unsigned int basementnodesize) {
 
     assert(node->height == 0);
-    assert(node->dirty);
+    assert(node->dirty());
 
     uint32_t num_orig_basements = node->n_children;
     // Count number of leaf entries in this leaf (num_le).
@@ -1142,7 +1142,7 @@ void toku_ft_nonleaf_append_child(FTNODE node, FTNODE child, const DBT *pivotkey
         invariant(childnum > 0);
         node->pivotkeys.insert_at(pivotkey, childnum - 1);
     }
-    node->dirty = 1;
+    node->set_dirty();
 }
 
 void
@@ -1745,7 +1745,7 @@ static void ft_append_msg_to_child_buffer(const toku::comparator &cmp, FTNODE no
                                           int childnum, const ft_msg &msg, bool is_fresh) {
     paranoid_invariant(BP_STATE(node,childnum) == PT_AVAIL);
     bnc_insert_msg(BNC(node, childnum), msg, is_fresh, cmp);
-    node->dirty = 1;
+    node->set_dirty();
 }
 
 // This is only exported for tests.
@@ -2090,7 +2090,7 @@ void toku_ft_leaf_apply_msg(
     // be reapplied later), we mark the node as dirty and
     // take the opportunity to update node->max_msn_applied_to_node_on_disk.
     //
-    node->dirty = 1;
+    node->set_dirty();
 
     //
     // we cannot blindly update node->max_msn_applied_to_node_on_disk,
diff --git a/storage/tokudb/PerconaFT/ft/node.h b/storage/tokudb/PerconaFT/ft/node.h
index 05c8a44ebed..61093f3ed8d 100644
--- a/storage/tokudb/PerconaFT/ft/node.h
+++ b/storage/tokudb/PerconaFT/ft/node.h
@@ -155,6 +155,12 @@ private:
     size_t _total_size;
 };
 
+extern int writing_rollback;
+
+extern "C" {
+extern uint force_recovery;
+}
+
 // TODO: class me up
 struct ftnode {
     // max_msn_applied that will be written to disk
@@ -173,9 +179,22 @@ struct ftnode {
     uint32_t build_id;
     // height is always >= 0.  0 for leaf, >0 for nonleaf.
     int height;
-    int dirty;
+    int dirty_;
     uint32_t fullhash;
 
+    void set_dirty() {
+        if(force_recovery) assert(writing_rollback);
+        dirty_ = 1;
+    }
+
+    void clear_dirty() {
+        dirty_ = 0;
+    }
+
+    bool dirty() {
+        return dirty_;
+    }
+
     // for internal nodes, if n_children==fanout+1 then the tree needs to be
     // rebalanced. for leaf nodes, represents number of basement nodes
     int n_children;
diff --git a/storage/tokudb/PerconaFT/ft/serialize/block_table.cc b/storage/tokudb/PerconaFT/ft/serialize/block_table.cc
index 811f86c30a7..e3606c11294 100644
--- a/storage/tokudb/PerconaFT/ft/serialize/block_table.cc
+++ b/storage/tokudb/PerconaFT/ft/serialize/block_table.cc
@@ -196,9 +196,9 @@ static void ft_set_dirty(FT ft, bool for_checkpoint) {
     invariant(ft->h->type == FT_CURRENT);
     if (for_checkpoint) {
         invariant(ft->checkpoint_header->type == FT_CHECKPOINT_INPROGRESS);
-        ft->checkpoint_header->dirty = 1;
+        ft->checkpoint_header->set_dirty();
     } else {
-        ft->h->dirty = 1;
+        ft->h->set_dirty();
     }
 }
 
diff --git a/storage/tokudb/PerconaFT/ft/serialize/ft-node-deserialize.cc b/storage/tokudb/PerconaFT/ft/serialize/ft-node-deserialize.cc
index 02a9dfd085c..de58fb42a8b 100644
--- a/storage/tokudb/PerconaFT/ft/serialize/ft-node-deserialize.cc
+++ b/storage/tokudb/PerconaFT/ft/serialize/ft-node-deserialize.cc
@@ -60,7 +60,7 @@ initialize_ftnode(FTNODE node, BLOCKNUM blocknum)
 {
     node->fullhash = 0xDEADBEEF; // <CER> Is this 'spoof' ok?
     node->blocknum = blocknum;
-    node->dirty = 0;
+    node->clear_dirty();
     node->bp = NULL;
     // <CER> Can we use this initialization as a correctness assert in
     // a later function?
diff --git a/storage/tokudb/PerconaFT/ft/serialize/ft-serialize.cc b/storage/tokudb/PerconaFT/ft/serialize/ft-serialize.cc
index 0d6573972d7..0813855bf55 100644
--- a/storage/tokudb/PerconaFT/ft/serialize/ft-serialize.cc
+++ b/storage/tokudb/PerconaFT/ft/serialize/ft-serialize.cc
@@ -340,7 +340,7 @@ int deserialize_ft_versioned(int fd, struct rbuf *rb, FT *ftp, uint32_t version)
     {
         struct ft_header h = {
             .type = FT_CURRENT,
-            .dirty = 0,
+            .dirty_ = 0,
             .checkpoint_count = checkpoint_count,
             .checkpoint_lsn = checkpoint_lsn,
             .layout_version = FT_LAYOUT_VERSION,
diff --git a/storage/tokudb/PerconaFT/ft/serialize/ft_node-serialize.cc b/storage/tokudb/PerconaFT/ft/serialize/ft_node-serialize.cc
index f3b31eb31be..e6648b76bf0 100644
--- a/storage/tokudb/PerconaFT/ft/serialize/ft_node-serialize.cc
+++ b/storage/tokudb/PerconaFT/ft/serialize/ft_node-serialize.cc
@@ -827,7 +827,7 @@ int toku_serialize_ftnode_to(int fd,
         node, n_uncompressed_bytes, n_to_write, io_time, for_checkpoint);
 
     toku_free(compressed_buf);
-    node->dirty = 0;  // See #1957.   Must set the node to be clean after
+    node->clear_dirty();  // See #1957.   Must set the node to be clean after
                       // serializing it so that it doesn't get written again on
                       // the next checkpoint or eviction.
     if (node->height == 0) {
@@ -1544,7 +1544,7 @@ static FTNODE alloc_ftnode_for_deserialize(uint32_t fullhash, BLOCKNUM blocknum)
     FTNODE XMALLOC(node);
     node->fullhash = fullhash;
     node->blocknum = blocknum;
-    node->dirty = 0;
+    node->clear_dirty();
     node->oldest_referenced_xid_known = TXNID_NONE;
     node->bp = nullptr;
     node->ct_pair = nullptr;
@@ -1951,7 +1951,7 @@ static int deserialize_and_upgrade_internal_node(FTNODE node,
     // Assign the highest msn from our upgrade message buffers
     node->max_msn_applied_to_node_on_disk = highest_msn;
     // Since we assigned MSNs to this node's messages, we need to dirty it.
-    node->dirty = 1;
+    node->set_dirty();
 
     // Must compute the checksum now (rather than at the end, while we
     // still have the pointer to the buffer).
@@ -2908,9 +2908,9 @@ int toku_serialize_rollback_log_to(int fd,
     toku_free(compressed_buf);
     if (!is_serialized) {
         toku_static_serialized_rollback_log_destroy(&serialized_local);
-        log->dirty = 0;  // See #1957.   Must set the node to be clean after
-                         // serializing it so that it doesn't get written again
-                         // on the next checkpoint or eviction.
+        log->dirty = false;  // See #1957.   Must set the node to be clean after
+                             // serializing it so that it doesn't get written again
+                             // on the next checkpoint or eviction.
     }
     return 0;
 }
diff --git a/storage/tokudb/PerconaFT/ft/txn/rollback.cc b/storage/tokudb/PerconaFT/ft/txn/rollback.cc
index 0c793842f3c..105f980dc0d 100644
--- a/storage/tokudb/PerconaFT/ft/txn/rollback.cc
+++ b/storage/tokudb/PerconaFT/ft/txn/rollback.cc
@@ -43,6 +43,8 @@ Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved.
 #include "ft/logger/log-internal.h"
 #include "ft/txn/rollback-ct-callbacks.h"
 
+extern int writing_rollback;
+
 static void rollback_unpin_remove_callback(CACHEKEY* cachekey, bool for_checkpoint, void* extra) {
     FT CAST_FROM_VOIDP(ft, extra);
     ft->blocktable.free_blocknum(cachekey, ft, for_checkpoint);
@@ -155,6 +157,7 @@ static void rollback_log_create (
     ROLLBACK_LOG_NODE *result
     )
 {
+    writing_rollback++;
     ROLLBACK_LOG_NODE XMALLOC(log);
     rollback_empty_log_init(log);
 
@@ -169,6 +172,7 @@ static void rollback_log_create (
                        get_write_callbacks_for_rollback_log(ft),
                        toku_rollback_node_save_ct_pair);
     txn->roll_info.current_rollback = log->blocknum;
+    writing_rollback --;
 }
 
 void toku_rollback_log_unpin(TOKUTXN txn, ROLLBACK_LOG_NODE log) {
diff --git a/storage/tokudb/PerconaFT/ft/txn/txn.cc b/storage/tokudb/PerconaFT/ft/txn/txn.cc
index 7327cbd9d24..7152833d88d 100644
--- a/storage/tokudb/PerconaFT/ft/txn/txn.cc
+++ b/storage/tokudb/PerconaFT/ft/txn/txn.cc
@@ -723,7 +723,11 @@ time_t toku_txn_get_start_time(struct tokutxn *txn) {
     return txn->start_time;
 }
 
+extern uint force_recovery;
 int toku_txn_reads_txnid(TXNID txnid, TOKUTXN txn, bool is_provisional UU()) {
+    if(force_recovery) {
+        return TOKUDB_ACCEPT;
+    }
     int r = 0;
     TXNID oldest_live_in_snapshot = toku_get_oldest_in_live_root_txn_list(txn);
     if (oldest_live_in_snapshot == TXNID_NONE && txnid < txn->snapshot_txnid64) {
diff --git a/storage/tokudb/PerconaFT/portability/toku_instr_mysql.cc b/storage/tokudb/PerconaFT/portability/toku_instr_mysql.cc
index 786a6ef0546..0f287429542 100644
--- a/storage/tokudb/PerconaFT/portability/toku_instr_mysql.cc
+++ b/storage/tokudb/PerconaFT/portability/toku_instr_mysql.cc
@@ -359,7 +359,16 @@ void toku_instr_rwlock_wrlock_wait_end(
 
 void toku_instr_rwlock_unlock(toku_pthread_rwlock_t &rwlock) {
     if (rwlock.psi_rwlock)
+
+// Due to change introduced in e4148f2a22922687f7652c4e3d21a22da07c9e78
+// PSI rwlock version and interface changed
+// PSI_CURRENT_RWLOCK_VERSION is not defined in MySQL 5.6 and is defined
+// as 1 in 5.7 and < 8.0.17
+#if defined(PSI_CURRENT_RWLOCK_VERSION) && (PSI_CURRENT_RWLOCK_VERSION == 2)
+        PSI_RWLOCK_CALL(unlock_rwlock)(rwlock.psi_rwlock, PSI_RWLOCK_UNLOCK);
+#else
         PSI_RWLOCK_CALL(unlock_rwlock)(rwlock.psi_rwlock);
+#endif
 }
 
 #endif  // TOKU_MYSQL_WITH_PFS
diff --git a/storage/tokudb/PerconaFT/scripts/tokuvalgrind b/storage/tokudb/PerconaFT/scripts/tokuvalgrind
deleted file mode 120000
index 74517aa2975..00000000000
--- a/storage/tokudb/PerconaFT/scripts/tokuvalgrind
+++ /dev/null
@@ -1 +0,0 @@
-tokugrind
-\ No newline at end of file
diff --git a/storage/tokudb/PerconaFT/src/ydb.cc b/storage/tokudb/PerconaFT/src/ydb.cc
index 58d39c50c23..b041928b679 100644
--- a/storage/tokudb/PerconaFT/src/ydb.cc
+++ b/storage/tokudb/PerconaFT/src/ydb.cc
@@ -40,6 +40,9 @@ extern const char *toku_patent_string;
 const char *toku_copyright_string = "Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved.";
 
 #include <my_global.h>
+
+extern int writing_rollback;
+
 #include <db.h>
 #include <errno.h>
 #include <string.h>
@@ -88,6 +91,10 @@ const char *toku_copyright_string = "Copyright (c) 2006, 2015, Percona and/or it
  int toku_close_trace_file (void) { return 0; } 
 #endif
 
+extern "C" {
+  uint force_recovery = 0;
+}
+
 // Set when env is panicked, never cleared.
 static int env_is_panicked = 0;
 
@@ -224,6 +231,9 @@ env_fs_redzone(DB_ENV *env, uint64_t total) {
 // Check the available space in the file systems used by tokuft and erect barriers when available space gets low.
 static int
 env_fs_poller(void *arg) {
+    if(force_recovery == 6) {
+	    return 0;
+    }
     DB_ENV *env = (DB_ENV *) arg;
     int r;
 
@@ -308,6 +318,9 @@ env_fs_init(DB_ENV *env) {
 // Initialize the minicron that polls file system space
 static int
 env_fs_init_minicron(DB_ENV *env) {
+    if(force_recovery == 6) {
+        return 0;
+    }
     int r = toku_minicron_setup(&env->i->fs_poller, env->i->fs_poll_time*1000, env_fs_poller, env); 
     if (r == 0)
         env->i->fs_poller_is_init = true;
@@ -710,7 +723,7 @@ static int validate_env(DB_ENV *env,
     }
 
     // Test for fileops directory
-    if (r == 0) {
+    if (r == 0 && force_recovery != 6) {
         path = toku_construct_full_name(
             2, env->i->dir, toku_product_name_strings.fileopsdirectory);
         assert(path);
@@ -753,7 +766,7 @@ static int validate_env(DB_ENV *env,
     }
 
     // Test for recovery log
-    if ((r == 0) && (env->i->open_flags & DB_INIT_LOG)) {
+    if ((r == 0) && (env->i->open_flags & DB_INIT_LOG) && force_recovery != 6) {
         // if using transactions, test for existence of log
         r = ydb_recover_log_exists(env);  // return 0 or ENOENT
         if (expect_newenv && (r != ENOENT))
@@ -814,6 +827,27 @@ unlock_single_process(DB_ENV *env) {
 // (The set of necessary files is defined in the function validate_env() above.)
 static int 
 env_open(DB_ENV * env, const char *home, uint32_t flags, int mode) {
+
+    if(force_recovery == 6) {
+        {
+            const int len = strlen(toku_product_name_strings.rollback_cachefile);
+            toku_product_name_strings.rollback_cachefile[len] = '2';
+            toku_product_name_strings.rollback_cachefile[len+1] = 0;
+        }
+
+        {
+            const int len = strlen(toku_product_name_strings.single_process_lock);
+            toku_product_name_strings.single_process_lock[len] = '2';
+            toku_product_name_strings.single_process_lock[len+1] = 0;
+        }
+
+        {
+            const int len = strlen(toku_product_name_strings.environmentdictionary);
+            toku_product_name_strings.environmentdictionary[len] = '2';
+            toku_product_name_strings.environmentdictionary[len+1] = 0;
+        }
+    }
+
     HANDLE_PANICKED_ENV(env);
     int r;
     bool newenv;  // true iff creating a new environment
@@ -904,7 +938,7 @@ env_open(DB_ENV * env, const char *home, uint32_t flags, int mode) {
 
     bool need_rollback_cachefile;
     need_rollback_cachefile = false;
-    if (flags & (DB_INIT_TXN | DB_INIT_LOG)) {
+    if (flags & (DB_INIT_TXN | DB_INIT_LOG) && force_recovery != 6) {
         need_rollback_cachefile = true;
     }
 
@@ -917,7 +951,7 @@ env_open(DB_ENV * env, const char *home, uint32_t flags, int mode) {
     r = ydb_maybe_upgrade_env(env, &last_lsn_of_clean_shutdown_read_from_log, &upgrade_in_progress);
     if (r!=0) goto cleanup;
 
-    if (upgrade_in_progress) {
+    if (upgrade_in_progress || force_recovery == 6) {
         // Delete old rollback file.  There was a clean shutdown, so it has nothing useful,
         // and there is no value in upgrading it.  It is simpler to just create a new one.
         char* rollback_filename = toku_construct_full_name(2, env->i->dir, toku_product_name_strings.rollback_cachefile);
@@ -935,9 +969,13 @@ env_open(DB_ENV * env, const char *home, uint32_t flags, int mode) {
 
     unused_flags &= ~DB_INIT_TXN & ~DB_INIT_LOG;
 
+    if(force_recovery == 6) {
+        flags |= DB_INIT_LOG | DB_INIT_TXN;
+    }
+
     // do recovery only if there exists a log and recovery is requested
     // otherwise, a log is created when the logger is opened later
-    if (!newenv) {
+    if (!newenv && force_recovery == 0) {
         if (flags & DB_INIT_LOG) {
             // the log does exist
             if (flags & DB_RECOVER) {
@@ -1006,7 +1044,7 @@ env_open(DB_ENV * env, const char *home, uint32_t flags, int mode) {
         assert (using_txns);
         toku_logger_set_cachetable(env->i->logger, env->i->cachetable);
         if (!toku_logger_rollback_is_open(env->i->logger)) {
-            bool create_new_rollback_file = newenv | upgrade_in_progress;
+            bool create_new_rollback_file = newenv | upgrade_in_progress | (force_recovery == 6);
             r = toku_logger_open_rollback(env->i->logger, env->i->cachetable, create_new_rollback_file);
             if (r != 0) {
                 r = toku_ydb_do_error(env, r, "Cant open rollback\n");
@@ -1025,6 +1063,7 @@ env_open(DB_ENV * env, const char *home, uint32_t flags, int mode) {
         assert_zero(r);
         r = toku_db_use_builtin_key_cmp(env->i->persistent_environment);
         assert_zero(r);
+	writing_rollback++;
         r = toku_db_open_iname(env->i->persistent_environment, txn, toku_product_name_strings.environmentdictionary, DB_CREATE, mode);
         if (r != 0) {
             r = toku_ydb_do_error(env, r, "Cant open persistent env\n");
@@ -1057,6 +1096,7 @@ env_open(DB_ENV * env, const char *home, uint32_t flags, int mode) {
             assert_zero(r);
         }
         capture_persistent_env_contents(env, txn);
+	writing_rollback--;
     }
     {
         r = toku_db_create(&env->i->directory, env, 0);
@@ -1075,8 +1115,10 @@ env_open(DB_ENV * env, const char *home, uint32_t flags, int mode) {
         txn = NULL;
     }
     cp = toku_cachetable_get_checkpointer(env->i->cachetable);
-    r = toku_checkpoint(cp, env->i->logger, NULL, NULL, NULL, NULL, STARTUP_CHECKPOINT);
-    assert_zero(r);
+    if (!force_recovery) {
+        r = toku_checkpoint(cp, env->i->logger, NULL, NULL, NULL, NULL, STARTUP_CHECKPOINT);
+    }
+    writing_rollback--;
     env_fs_poller(env);          // get the file system state at startup
     r = env_fs_init_minicron(env);
     if (r != 0) {
diff --git a/storage/tokudb/PerconaFT/src/ydb_db.cc b/storage/tokudb/PerconaFT/src/ydb_db.cc
index 6b4452325f4..8b2b162abd2 100644
--- a/storage/tokudb/PerconaFT/src/ydb_db.cc
+++ b/storage/tokudb/PerconaFT/src/ydb_db.cc
@@ -324,6 +324,7 @@ toku_db_open(DB * db, DB_TXN * txn, const char *fname, const char *dbname, DBTYP
     // DB_THREAD is implicitly supported and DB_BLACKHOLE is supported at the ft-layer
     unused_flags &= ~DB_THREAD;
     unused_flags &= ~DB_BLACKHOLE;
+    unused_flags &= ~DB_RDONLY;
 
     // check for unknown or conflicting flags
     if (unused_flags) return EINVAL; // unknown flags
@@ -405,7 +406,7 @@ int toku_db_lt_on_create_callback(toku::locktree *lt, void *extra) {
     FT_HANDLE ft_handle = info->ft_handle;
 
     FT_HANDLE cloned_ft_handle;
-    r = toku_ft_handle_clone(&cloned_ft_handle, ft_handle, ttxn);
+    r = toku_ft_handle_clone(&cloned_ft_handle, ft_handle, ttxn, info->open_rw);
     if (r == 0) {
         assert(lt->get_userdata() == NULL);
         lt->set_userdata(cloned_ft_handle);
@@ -466,6 +467,7 @@ int toku_db_open_iname(DB * db, DB_TXN * txn, const char *iname_in_env, uint32_t
                                             flags&=~DB_READ_COMMITTED;
                                             flags&=~DB_SERIALIZABLE;
                                             flags&=~DB_IS_HOT_INDEX;
+                                            flags&=~DB_RDONLY;
     // unknown or conflicting flags are bad
     int unknown_flags = flags & ~DB_THREAD;
     unknown_flags &= ~DB_BLACKHOLE;
@@ -480,11 +482,12 @@ int toku_db_open_iname(DB * db, DB_TXN * txn, const char *iname_in_env, uint32_t
     db->i->open_flags = flags;
     db->i->open_mode = mode;
 
+    bool open_rw = mode & (S_IWUSR | S_IWOTH | S_IWGRP);
     FT_HANDLE ft_handle = db->i->ft_handle;
     int r = toku_ft_handle_open(ft_handle, iname_in_env,
                       is_db_create, is_db_excl,
                       db->dbenv->i->cachetable,
-                      txn ? db_txn_struct_i(txn)->tokutxn : nullptr);
+                      txn ? db_txn_struct_i(txn)->tokutxn : nullptr, open_rw);
     if (r != 0) {
         goto out;
     }
@@ -506,6 +509,7 @@ int toku_db_open_iname(DB * db, DB_TXN * txn, const char *iname_in_env, uint32_t
         struct lt_on_create_callback_extra on_create_extra = {
             .txn = txn,
             .ft_handle = db->i->ft_handle,
+            open_rw
         };
         db->i->lt = db->dbenv->i->ltm.get_lt(db->i->dict_id,
                                              toku_ft_get_comparator(db->i->ft_handle),
diff --git a/storage/tokudb/PerconaFT/src/ydb_db.h b/storage/tokudb/PerconaFT/src/ydb_db.h
index ab8fcd2a401..c260e9d0fbe 100644
--- a/storage/tokudb/PerconaFT/src/ydb_db.h
+++ b/storage/tokudb/PerconaFT/src/ydb_db.h
@@ -67,6 +67,7 @@ void ydb_db_layer_get_status(YDB_DB_LAYER_STATUS statp);
 struct lt_on_create_callback_extra {
     DB_TXN *txn;
     FT_HANDLE ft_handle;
+    bool open_rw;
 };
 int toku_db_lt_on_create_callback(toku::locktree *lt, void *extra);
 void toku_db_lt_on_destroy_callback(toku::locktree *lt);
diff --git a/storage/tokudb/PerconaFT/tools/tokuftdump.cc b/storage/tokudb/PerconaFT/tools/tokuftdump.cc
index 2838ae5182e..44edb15162a 100644
--- a/storage/tokudb/PerconaFT/tools/tokuftdump.cc
+++ b/storage/tokudb/PerconaFT/tools/tokuftdump.cc
@@ -181,7 +181,7 @@ static void dump_header(FT ft) {
     printf(" time_of_creation=         %" PRIu64 "    %s\n", ft->h->time_of_creation, timestr);
     format_time(ft->h->time_of_last_modification, timestr);
     printf(" time_of_last_modification=%" PRIu64 "    %s\n", ft->h->time_of_last_modification, timestr);
-    printf(" dirty=%d\n", ft->h->dirty);
+    printf(" dirty=%d\n", ft->h->dirty());
     printf(" checkpoint_count=%" PRId64 "\n", ft->h->checkpoint_count);
     printf(" checkpoint_lsn=%" PRId64 "\n", ft->h->checkpoint_lsn.lsn);
     printf(" nodesize=%u\n", ft->h->nodesize);
diff --git a/storage/tokudb/ha_tokudb.cc b/storage/tokudb/ha_tokudb.cc
index 535b2189cad..4a101f7e589 100644
--- a/storage/tokudb/ha_tokudb.cc
+++ b/storage/tokudb/ha_tokudb.cc
@@ -1333,7 +1333,7 @@ int ha_tokudb::open_main_dictionary(
             NULL,
             DB_BTREE,
             open_flags,
-            0);
+            S_IWUSR);
     if (error) {
         goto exit;
     }
@@ -1396,7 +1396,7 @@ int ha_tokudb::open_secondary_dictionary(
     }
 
 
-    error = (*ptr)->open(*ptr, txn, newname, NULL, DB_BTREE, open_flags, 0);
+    error = (*ptr)->open(*ptr, txn, newname, NULL, DB_BTREE, open_flags, S_IWUSR);
     if (error) {
         my_errno = error;
         goto cleanup;
diff --git a/storage/tokudb/man/CMakeLists.txt b/storage/tokudb/man/CMakeLists.txt
new file mode 100644
index 00000000000..192d8117119
--- /dev/null
+++ b/storage/tokudb/man/CMakeLists.txt
@@ -0,0 +1,2 @@
+SET(MAN1_TOKUDB tokuftdump.1 tokuft_logprint.1)
+INSTALL(FILES ${MAN1_TOKUDB} DESTINATION ${INSTALL_MANDIR}/man1 COMPONENT tokudb-engine)
diff --git a/storage/tokudb/man/tokuft_logprint.1 b/storage/tokudb/man/tokuft_logprint.1
new file mode 100644
index 00000000000..0a9ff539b73
--- /dev/null
+++ b/storage/tokudb/man/tokuft_logprint.1
@@ -0,0 +1,16 @@
+'\" t
+.\"
+.TH "\FBTOKUFT_LOGPRINT\FR" "1" "29 March 2019" "MariaDB 10\&.3" "MariaDB Database System"
+.\" -----------------------------------------------------------------
+.\" * set default formatting
+.\" -----------------------------------------------------------------
+.\" disable hyphenation
+.nh
+.\" disable justification (adjust text to left margin only)
+.ad l
+.SH NAME
+tokuft_logprint \- Dump the log from stdin to stdout 
+.SH DESCRIPTION
+Use: Dump the log from stdin to stdout\. Use \fBtokuft_logprint \-\-help\fR for details on usage\. 
+.PP
+For more information, please refer to the MariaDB Knowledge Base, available online at https://mariadb.com/kb/
diff --git a/storage/tokudb/man/tokuftdump.1 b/storage/tokudb/man/tokuftdump.1
new file mode 100644
index 00000000000..024b16ba631
--- /dev/null
+++ b/storage/tokudb/man/tokuftdump.1
@@ -0,0 +1,237 @@
+'\" t
+.\"
+.TH "\FBTOKUFTDUMP\FR" "1" "9 May 2017" "MariaDB 10\&.3" "MariaDB Database System"
+.\" -----------------------------------------------------------------
+.\" * set default formatting
+.\" -----------------------------------------------------------------
+.\" disable hyphenation
+.nh
+.\" disable justification (adjust text to left margin only)
+.ad l
+.\" -----------------------------------------------------------------
+.\" * MAIN CONTENT STARTS HERE *
+.\" -----------------------------------------------------------------
+.\" tokuftdump
+.\" upgrading MySQL
+.SH "NAME"
+tokuftdump \- look into the fractal tree file
+.SH "SYNOPSIS"
+.HP \w'\fBtokuftdump\ [\fR\fB\fIoptions\fR\fR\fB]\fR\ 'u
+\fBtokuftdump [\fR\fB\fIoptions\fR\fR\fB]\fR
+.SH "DESCRIPTION"
+.PP
+\fBtokuftdump\fR
+Investigates and diagnoses the fractal tree\&.
+.PP
+\fBtokuftdump\fR 
+supports the following options for processing option files\&.
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: interactive option
+.\" interactive option: tokuftdump
+\fB\-\-interactive\fR
+.sp
+Interactive\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: support option
+.\" support option: tokuftdump
+\fB\-\-support \fI/path/to/fractal-tree/file\fR
+.sp
+An interactive way to see what messages and/or switch between FTs\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: json option
+.\" json option: tokuftdump
+\fB\-\-json \fI/path/to/fractal-tree/file [output_json_file]\fR
+.sp
+If the output json file is left empty, FT\&.json will be created automatically\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: nodata option
+.\" nodata option: tokuftdump
+\fB\-\-nodata\fR
+.sp
+Nodata\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: dumpdata option
+.\" dumpdata option: tokuftdump
+\fB\-\-dumpdata = \fR\fB\fI0|1\fR\fR
+.sp
+Dumpdata\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: header option
+.\" header option: tokuftdump
+\fB\-\-header\fR
+.sp
+Header\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: rootnode option
+.\" rootnode option: tokuftdump
+\fB\-\-rootnode\fR
+.sp
+Rootnode\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: node option
+.\" node option: tokuftdump
+\fB\-\-node \fIN\fR
+.sp
+Node\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: fragmentation option
+.\" fragmentation option: tokuftdump
+\fB\-\-fragmentation\fR
+.sp
+Fragmentation\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: garbage option
+.\" garbage option: tokuftdump
+\fB\-\-garbage\fR
+.sp
+Garbage\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: tsv option
+.\" tsv option: tokuftdump
+\fB\-\-tsv\fR
+.sp
+TSV\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: translation-table option
+.\" translation-table option: tokuftdump
+\fB\-\-translation\-table\fR
+.sp
+Translation table\&.
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.sp -1
+.IP \(bu 2.3
+.\}
+.\" tokuftdump: summary option
+.\" summary option: tokuftdump
+\fB\-\-summary\fR
+.sp
+Provide summary info\&.
+.RE
+.SH "COPYRIGHT"
+.br
+.PP
+Copyright 2016 MariaDB Foundation
+.PP
+This documentation is free software; you can redistribute it and/or modify it only under the terms of the GNU General Public License as published by the Free Software Foundation; version 2 of the License.
+.PP
+This documentation is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+.PP
+You should have received a copy of the GNU General Public License along with the program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA or see http://www.gnu.org/licenses/.
+.sp
+.SH "SEE ALSO"
+For more information, please refer to the MariaDB Knowledge Base, available online at https://mariadb.com/kb/
+.SH AUTHOR
+MariaDB Foundation (http://www.mariadb.org/).
diff --git a/storage/tokudb/mysql-test/tokudb/t/type_bit.test b/storage/tokudb/mysql-test/tokudb/t/type_bit.test
index 445f69e8972..034585169f5 100644
--- a/storage/tokudb/mysql-test/tokudb/t/type_bit.test
+++ b/storage/tokudb/mysql-test/tokudb/t/type_bit.test
@@ -268,7 +268,7 @@ select hex(a), b from t1;
 drop table t1;
 
 #
-# type was not properly initalized, which caused key_copy to fail
+# type was not properly initialized, which caused key_copy to fail
 #
 
 create table t1(bit_field bit(2), int_field int, key a(bit_field));
diff --git a/storage/tokudb/mysql-test/tokudb_parts/r/partition_exch_qa_5_tokudb.result b/storage/tokudb/mysql-test/tokudb_parts/r/partition_exch_qa_5_tokudb.result
index 03ef0ed2c09..2e31fc57dd4 100644
--- a/storage/tokudb/mysql-test/tokudb_parts/r/partition_exch_qa_5_tokudb.result
+++ b/storage/tokudb/mysql-test/tokudb_parts/r/partition_exch_qa_5_tokudb.result
@@ -10,8 +10,8 @@ current_user()
 test1@localhost
 SHOW GRANTS FOR CURRENT_USER;
 Grants for test1@localhost
-GRANT USAGE ON *.* TO 'test1'@'localhost'
-GRANT SELECT, INSERT, CREATE, DROP ON `test`.* TO 'test1'@'localhost'
+GRANT USAGE ON *.* TO `test1`@`localhost`
+GRANT SELECT, INSERT, CREATE, DROP ON `test`.* TO `test1`@`localhost`
 ALTER TABLE tp EXCHANGE PARTITION p0 WITH TABLE t_10;
 ERROR 42000: ALTER command denied to user 'test1'@'localhost' for table 'tp'
 disconnect test1;
@@ -22,8 +22,8 @@ current_user()
 test2@localhost
 SHOW GRANTS FOR CURRENT_USER;
 Grants for test2@localhost
-GRANT USAGE ON *.* TO 'test2'@'localhost'
-GRANT SELECT, INSERT, UPDATE, CREATE, DROP, ALTER ON `test`.* TO 'test2'@'localhost'
+GRANT USAGE ON *.* TO `test2`@`localhost`
+GRANT SELECT, INSERT, UPDATE, CREATE, DROP, ALTER ON `test`.* TO `test2`@`localhost`
 ALTER TABLE tp EXCHANGE PARTITION p0 WITH TABLE t_10;
 SELECT * FROM t_10;
 a	b
@@ -80,8 +80,8 @@ current_user()
 test2@localhost
 SHOW GRANTS FOR CURRENT_USER;
 Grants for test2@localhost
-GRANT USAGE ON *.* TO 'test2'@'localhost'
-GRANT SELECT, INSERT, UPDATE, CREATE, DROP ON `test`.* TO 'test2'@'localhost'
+GRANT USAGE ON *.* TO `test2`@`localhost`
+GRANT SELECT, INSERT, UPDATE, CREATE, DROP ON `test`.* TO `test2`@`localhost`
 ALTER TABLE tp EXCHANGE PARTITION p0 WITH TABLE t_10;
 ERROR 42000: ALTER command denied to user 'test2'@'localhost' for table 'tp'
 SELECT * FROM tp WHERE a BETWEEN 0 AND 10;
diff --git a/storage/tokudb/tokudb_status.h b/storage/tokudb/tokudb_status.h
index 5cca54e52c9..07772bdc92a 100644
--- a/storage/tokudb/tokudb_status.h
+++ b/storage/tokudb/tokudb_status.h
@@ -201,7 +201,7 @@ int create(
                 name,
                 NULL,
                 DB_BTREE, DB_CREATE | DB_EXCL,
-                0);
+                S_IWUSR);
     }
     if (error == 0) {
         *status_db_ptr = status_db;
@@ -230,7 +230,7 @@ int open(
                 NULL,
                 DB_BTREE,
                 DB_THREAD,
-                0);
+                S_IWUSR);
     }
     if (error == 0) {
         uint32_t pagesize = 0;
author	Olivier Bertrand <bertrandop@gmail.com>	2020-03-12 19:16:36 +0100
committer	Olivier Bertrand <bertrandop@gmail.com>	2020-03-12 19:16:36 +0100
commit	d26b4eb4c071f39d2ff262026608d26e7a56309d (patch)
tree	f8ed01ab17f186aa3e0175c143d5345def73dc2c /storage
parent	4ba36cfa0c677b7d094092d6aa5541c6c936a11f (diff)
parent	51e9381dcc01ebd72d4f0adc057a64213f850d70 (diff)
download	mariadb-git-d26b4eb4c071f39d2ff262026608d26e7a56309d.tar.gz