diff --git a/extra/comp_err.c b/extra/comp_err.c
index 3fc4b05fa61..b4f9db90509 100644
--- a/extra/comp_err.c
+++ b/extra/comp_err.c
@@ -32,9 +32,11 @@
 #include <my_getopt.h>
 #include <my_dir.h>
 
-#define MAX_ROWS  2000
+#define MAX_ROWS  3000
+#define ERRORS_PER_RANGE 1000
+#define MAX_SECTIONS 4
 #define HEADER_LENGTH 32                /* Length of header in errmsg.sys */
-#define ERRMSG_VERSION 3                /* Version number of errmsg.sys */
+#define ERRMSG_VERSION 4                /* Version number of errmsg.sys */
 #define DEFAULT_CHARSET_DIR "../sql/share/charsets"
 #define ER_PREFIX "ER_"
 #define ER_PREFIX2 "MARIA_ER_"
@@ -53,6 +55,8 @@ static char *default_dbug_option= (char*) "d:t:O,/tmp/comp_err.trace";
 uchar file_head[]= { 254, 254, 2, ERRMSG_VERSION };
 /* Store positions to each error message row to store in errmsg.sys header */
 uint file_pos[MAX_ROWS+1];
+uint section_count,section_start;
+uchar section_header[MAX_SECTIONS*2];
 
 const char *empty_string= "";			/* For empty states */
 /*
@@ -131,7 +135,7 @@ static struct my_option my_long_options[]=
 };
 
 
-static struct errors *generate_empty_message(uint dcode);
+static struct errors *generate_empty_message(uint dcode, my_bool skip);
 static struct languages *parse_charset_string(char *str);
 static struct errors *parse_error_string(char *ptr, int er_count);
 static struct message *parse_message_string(struct message *new_message,
@@ -140,8 +144,8 @@ static struct message *find_message(struct errors *err, const char *lang,
                                     my_bool no_default);
 static int check_message_format(struct errors *err,
                                 const char* mess);
-static int parse_input_file(const char *file_name, struct errors **top_error,
-			    struct languages **top_language);
+static uint parse_input_file(const char *file_name, struct errors **top_error,
+                             struct languages **top_language);
 static int get_options(int *argc, char ***argv);
 static void print_version(void);
 static void usage(void);
@@ -226,6 +230,7 @@ static void print_escaped_string(FILE *f, const char *str)
 static int create_header_files(struct errors *error_head)
 {
   uint er_last= 0;
+  uint section= 1;
   FILE *er_definef, *sql_statef, *er_namef;
   struct errors *tmp_error;
   struct message *er_msg;
@@ -266,8 +271,19 @@ static int create_header_files(struct errors *error_head)
     if (!tmp_error->er_name)
       continue;                                 /* Placeholder for gap */
 
-    if (tmp_error->d_code > current_d_code + 1)
+    while  (tmp_error->d_code > current_d_code + 1)
+    {
+      uint next_range= (((current_d_code + ERRORS_PER_RANGE) / 
+                         ERRORS_PER_RANGE) * ERRORS_PER_RANGE);
+
+      fprintf(er_definef, "#define ER_ERROR_LAST_SECTION_%d %d\n", section,
+              current_d_code);
       fprintf(er_definef, "\n/* New section */\n\n");
+      fprintf(er_definef, "#define ER_ERROR_FIRST_SECTION_%d %d\n", section+1,
+              MY_MIN(tmp_error->d_code, next_range));
+      section++;
+      current_d_code= MY_MIN(tmp_error->d_code, next_range);
+    }
     current_d_code= tmp_error->d_code;
 
     fprintf(er_definef, "#define %s %u\n", tmp_error->er_name,
@@ -301,13 +317,12 @@ static int create_sys_files(struct languages *lang_head,
 {
   FILE *to;
   uint csnum= 0, length, i, row_nr;
-  uchar head[32];
+  uchar head[HEADER_LENGTH];
   char outfile[FN_REFLEN], *outfile_end;
   long start_pos;
   struct message *tmp;
   struct languages *tmp_lang;
   struct errors *tmp_error;
-
   MY_STAT stat_info;
   DBUG_ENTER("create_sys_files");
 
@@ -331,7 +346,7 @@ static int create_sys_files(struct languages *lang_head,
     {
       if (my_mkdir(outfile, 0777,MYF(0)) < 0)
       {
-        fprintf(stderr, "Can't create output directory for %s\n", 
+        fprintf(stderr, "Can't creqate output directory for %s\n", 
                 outfile);
         DBUG_RETURN(1);
       }
@@ -343,7 +358,7 @@ static int create_sys_files(struct languages *lang_head,
       DBUG_RETURN(1);
 
     /* 2 is for 2 bytes to store row position / error message */
-    start_pos= (long) (HEADER_LENGTH + row_count * 2);
+    start_pos= (long) (HEADER_LENGTH + (row_count + section_count) * 2);
     fseek(to, start_pos, 0);
     row_nr= 0;
     for (tmp_error= error_head; tmp_error; tmp_error= tmp_error->next_error)
@@ -358,25 +373,31 @@ static int create_sys_files(struct languages *lang_head,
 		"language\n", tmp_error->er_name, tmp_lang->lang_short_name);
 	goto err;
       }
-      if (copy_rows(to, tmp->text, row_nr, start_pos))
+      if (tmp->text)                            /* If not skipped row */
       {
-	fprintf(stderr, "Failed to copy rows to %s\n", outfile);
-	goto err;
+        if (copy_rows(to, tmp->text, row_nr, start_pos))
+        {
+          fprintf(stderr, "Failed to copy rows to %s\n", outfile);
+          goto err;
+        }
+        row_nr++;
       }
-      row_nr++;
     }
 
     /* continue with header of the errmsg.sys file */
-    length= ftell(to) - HEADER_LENGTH - row_count * 2;
+    length= ftell(to) - HEADER_LENGTH - (row_count + section_count) * 2;
     bzero((uchar*) head, HEADER_LENGTH);
     bmove((uchar *) head, (uchar *) file_head, 4);
     head[4]= 1;
     int4store(head + 6, length);
     int2store(head + 10, row_count);
+    int2store(head + 12, section_count);
     head[30]= csnum;
 
     my_fseek(to, 0l, MY_SEEK_SET, MYF(0));
-    if (my_fwrite(to, (uchar*) head, HEADER_LENGTH, MYF(MY_WME | MY_FNABP)))
+    if (my_fwrite(to, (uchar*) head, HEADER_LENGTH, MYF(MY_WME | MY_FNABP)) ||
+        my_fwrite(to, (uchar*) section_header, section_count*2,
+                  MYF(MY_WME | MY_FNABP)))
       goto err;
 
     file_pos[row_count]= (ftell(to) - start_pos);
@@ -437,8 +458,8 @@ static void clean_up(struct languages *lang_head, struct errors *error_head)
 }
 
 
-static int parse_input_file(const char *file_name, struct errors **top_error,
-			    struct languages **top_lang)
+static uint parse_input_file(const char *file_name, struct errors **top_error,
+                             struct languages **top_lang)
 {
   FILE *file;
   char *str, buff[1000];
@@ -450,11 +471,15 @@ static int parse_input_file(const char *file_name, struct errors **top_error,
 
   *top_error= 0;
   *top_lang= 0;
+  section_start= er_offset;
+  section_count= 0;
+
   if (!(file= my_fopen(file_name, O_RDONLY | O_SHARE, MYF(MY_WME))))
     DBUG_RETURN(0);
 
   while ((str= fgets(buff, sizeof(buff), file)))
   {
+    my_bool skip;
     if (is_prefix(str, "language"))
     {
       if (!(*top_lang= parse_charset_string(str)))
@@ -464,18 +489,34 @@ static int parse_input_file(const char *file_name, struct errors **top_error,
       }
       continue;
     }
-    if (is_prefix(str, "start-error-number"))
+    skip= 0;
+    if (is_prefix(str, "start-error-number") ||
+        (skip= is_prefix(str, "skip-to-error-number")))
     {
       uint tmp_er_offset;
+
       if (!(tmp_er_offset= parse_error_offset(str)))
       {
 	fprintf(stderr, "Failed to parse the error offset string!\n");
 	DBUG_RETURN(0);
       }
+      if (skip)
+      {
+        if (section_count >= MAX_SECTIONS-1)
+        {
+          fprintf(stderr, "Found too many skip-to-error-number entries. "
+                  "We only support %d entries\n", MAX_SECTIONS);
+          DBUG_RETURN(0);
+        }
+        int2store(section_header + section_count*2,
+                  er_offset +rcount - section_start);
+        section_count++;
+        section_start= tmp_er_offset;
+      }
       if (!er_offset_found)
       {
         er_offset_found= 1;
-        er_offset= tmp_er_offset;
+        er_offset= section_start= tmp_er_offset;
       }
       else
       {
@@ -487,7 +528,7 @@ static int parse_input_file(const char *file_name, struct errors **top_error,
         }
         for ( ; er_offset + rcount < tmp_er_offset ; rcount++)
         {
-          current_error= generate_empty_message(er_offset + rcount);
+          current_error= generate_empty_message(er_offset + rcount, skip);
           *tail_error= current_error;
           tail_error= &current_error->next_error;
         }
@@ -559,6 +600,10 @@ static int parse_input_file(const char *file_name, struct errors **top_error,
     fprintf(stderr, "Wrong input file format. Stop!\nLine: %s\n", str);
     DBUG_RETURN(0);
   }
+  int2store(section_header + section_count*2,
+            er_offset + rcount - section_start);
+  section_count++;
+
   *tail_error= 0;			/* Mark end of list */
 
   my_fclose(file, MYF(0));
@@ -887,7 +932,7 @@ static struct message *parse_message_string(struct message *new_message,
 }
 
 
-static struct errors *generate_empty_message(uint d_code)
+static struct errors *generate_empty_message(uint d_code, my_bool skip)
 {
   struct errors *new_error;
   struct message message;
@@ -896,7 +941,8 @@ static struct errors *generate_empty_message(uint d_code)
   if (!(new_error= (struct errors *) my_malloc(sizeof(*new_error),
                                                MYF(MY_WME))))
     return(0);
-  if (my_init_dynamic_array(&new_error->msg, sizeof(struct message), 0, 1, MYF(0)))
+  if (my_init_dynamic_array(&new_error->msg, sizeof(struct message), 0, 1,
+                            MYF(0)))
     return(0);				/* OOM: Fatal error */
 
   new_error->er_name= NULL;
@@ -904,8 +950,10 @@ static struct errors *generate_empty_message(uint d_code)
   new_error->sql_code1= empty_string;
   new_error->sql_code2= empty_string;
 
+  message.text= 0;              /* If skip set, don't generate a text */
+
   if (!(message.lang_short_name= my_strdup(default_language, MYF(MY_WME))) ||
-      !(message.text= my_strdup("", MYF(MY_WME))))
+      (!skip && !(message.text= my_strdup("", MYF(MY_WME)))))
     return(0);
 
   /* Can't fail as msg is preallocated */
diff --git a/include/my_sys.h b/include/my_sys.h
index 36530eb94e9..7b7158573b4 100644
--- a/include/my_sys.h
+++ b/include/my_sys.h
@@ -689,7 +689,7 @@ extern void     my_osmaperr(unsigned long last_error);
 #endif
 
 extern void init_glob_errs(void);
-extern const char** get_global_errmsgs(void);
+extern const char** get_global_errmsgs(int nr);
 extern void wait_for_free_space(const char *filename, int errors);
 extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
 extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
@@ -714,9 +714,9 @@ extern void my_printf_error(uint my_err, const char *format,
                             ATTRIBUTE_FORMAT(printf, 2, 4);
 extern void my_printv_error(uint error, const char *format, myf MyFlags,
                             va_list ap);
-extern int my_error_register(const char** (*get_errmsgs) (void),
+extern int my_error_register(const char** (*get_errmsgs) (int nr),
                              uint first, uint last);
-extern const char **my_error_unregister(uint first, uint last);
+extern my_bool my_error_unregister(uint first, uint last);
 extern void my_message(uint my_err, const char *str,myf MyFlags);
 extern void my_message_stderr(uint my_err, const char *str, myf MyFlags);
 extern my_bool my_init(void);
diff --git a/libmysql/errmsg.c b/libmysql/errmsg.c
index e30cdc9762b..0930efe3655 100644
--- a/libmysql/errmsg.c
+++ b/libmysql/errmsg.c
@@ -90,7 +90,7 @@ const char *client_errors[]=
   ""
 };
 
-const char** get_client_errmsgs(void)
+const char** get_client_errmsgs(int nr __attribute((unused)))
 {
   return client_errors;
 }
diff --git a/mysys/errors.c b/mysys/errors.c
index 11e7d04e79e..7f3d966f9d7 100644
--- a/mysys/errors.c
+++ b/mysys/errors.c
@@ -119,7 +119,7 @@ void wait_for_free_space(const char *filename, int errors)
   (void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
 }
 
-const char **get_global_errmsgs()
+const char **get_global_errmsgs(int nr __attribute((unused)))
 {
   return globerrs;
 }
diff --git a/mysys/my_error.c b/mysys/my_error.c
index 5d16091e0be..c0698b19a20 100644
--- a/mysys/my_error.c
+++ b/mysys/my_error.c
@@ -49,7 +49,7 @@
 static struct my_err_head
 {
   struct my_err_head *meh_next;         /* chain link */
-  const char**       (*get_errmsgs)(); /* returns error message format */
+  const char**       (*get_errmsgs)(int nr); /* returns error message format */
   uint               meh_first;       /* error number matching array slot 0 */
   uint               meh_last;          /* error number matching last slot */
 } my_errmsgs_globerrs=
@@ -86,7 +86,7 @@ const char *my_get_err_msg(uint nr)
     we return NULL.
   */
   if (!(format= (meh_p && (nr >= meh_p->meh_first)) ?
-                meh_p->get_errmsgs()[nr - meh_p->meh_first] : NULL) ||
+                meh_p->get_errmsgs(nr)[nr - meh_p->meh_first] : NULL) ||
       !*format)
     return NULL;
 
@@ -217,7 +217,8 @@ void my_message(uint error, const char *str, register myf MyFlags)
   @retval  != 0     Error
 */
 
-int my_error_register(const char** (*get_errmsgs) (), uint first, uint last)
+int my_error_register(const char** (*get_errmsgs)(int error), uint first,
+                      uint last)
 {
   struct my_err_head *meh_p;
   struct my_err_head **search_meh_pp;
@@ -273,11 +274,10 @@ int my_error_register(const char** (*get_errmsgs) (), uint first, uint last)
   @retval  non-NULL  OK, returns address of error messages pointers array.
 */
 
-const char **my_error_unregister(uint first, uint last)
+my_bool my_error_unregister(uint first, uint last)
 {
   struct my_err_head    *meh_p;
   struct my_err_head    **search_meh_pp;
-  const char            **errmsgs;
 
   /* Search for the registration in the list. */
   for (search_meh_pp= &my_errmsgs_list;
@@ -289,17 +289,15 @@ const char **my_error_unregister(uint first, uint last)
       break;
   }
   if (! *search_meh_pp)
-    return NULL;
-
+    return TRUE;
+  
   /* Remove header from the chain. */
   meh_p= *search_meh_pp;
   *search_meh_pp= meh_p->meh_next;
 
-  /* Save the return value and free the header. */
-  errmsgs= meh_p->get_errmsgs();
   my_free(meh_p);
   
-  return errmsgs;
+  return FALSE;
 }
 
 
diff --git a/sql/derror.cc b/sql/derror.cc
index bc4b89493aa..b3f0bacb3d8 100644
--- a/sql/derror.cc
+++ b/sql/derror.cc
@@ -30,16 +30,19 @@
 #include "derror.h"                             // read_texts
 #include "sql_class.h"                          // THD
 
+uint errors_per_range[MAX_ERROR_RANGES+1];
+
 static bool check_error_mesg(const char *file_name, const char **errmsg);
 static void init_myfunc_errs(void);
 
 
 C_MODE_START
-static const char **get_server_errmsgs()
+static const char **get_server_errmsgs(int nr)
 {
+  int section= (nr-ER_ERROR_FIRST) / ERRORS_PER_RANGE;
   if (!current_thd)
-    return DEFAULT_ERRMSGS;
-  return CURRENT_THD_ERRMSGS;
+    return DEFAULT_ERRMSGS[section];
+  return CURRENT_THD_ERRMSGS[section];
 }
 C_MODE_END
 
@@ -60,61 +63,88 @@ C_MODE_END
     TRUE        Error
 */
 
+static const char ***original_error_messages;
+
 bool init_errmessage(void)
 {
-  const char **errmsgs, **ptr, **org_errmsgs;
+  const char **errmsgs;
   bool error= FALSE;
   DBUG_ENTER("init_errmessage");
 
-  /*
-    Get a pointer to the old error messages pointer array.
-    read_texts() tries to free it.
-  */
-  org_errmsgs= my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST);
+  free_error_messages();
+  my_free(original_error_messages);
+  original_error_messages= 0;
+
+  error_message_charset_info= system_charset_info;
 
   /* Read messages from file. */
   if (read_texts(ERRMSG_FILE, my_default_lc_messages->errmsgs->language,
-                 &errmsgs, ER_ERROR_LAST - ER_ERROR_FIRST + 1) &&
-      !errmsgs)
+                 &original_error_messages))
   {
-    my_free(errmsgs);
-    
-    if (org_errmsgs)
+    /*
+      No error messages.  Create a temporary empty error message so
+      that we don't get a crash if some code wrongly tries to access
+      a non existing error message.
+    */
+    if (!(original_error_messages= (const char***)
+          my_malloc(MAX_ERROR_RANGES * sizeof(char**) +
+                    (ERRORS_PER_RANGE * sizeof(char*)),
+                     MYF(0))))
+      DBUG_RETURN(TRUE);
+    errmsgs= (const char**) (original_error_messages + MAX_ERROR_RANGES);
+
+    for (uint i=0 ; i < MAX_ERROR_RANGES ; i++)
     {
-      /* Use old error messages */
-      errmsgs= org_errmsgs;
-    }
-    else
-    {
-      /*
-        No error messages.  Create a temporary empty error message so
-        that we don't get a crash if some code wrongly tries to access
-        a non existing error message.
-      */
-      if (!(errmsgs= (const char**) my_malloc((ER_ERROR_LAST-ER_ERROR_FIRST+1)*
-                                              sizeof(char*), MYF(0))))
-        DBUG_RETURN(TRUE);
-      for (ptr= errmsgs; ptr < errmsgs + ER_ERROR_LAST - ER_ERROR_FIRST; ptr++)
-        *ptr= "";
-      error= TRUE;
+      original_error_messages[i]= errmsgs;
+      errors_per_range[i]= ERRORS_PER_RANGE;
     }
+    errors_per_range[2]= 0;                     // MYSYS error messages
+
+    for (const char **ptr= errmsgs;
+         ptr < errmsgs + ERRORS_PER_RANGE ;
+         ptr++)
+      *ptr= "";
+
+    error= TRUE;
   }
-  else
-    my_free(org_errmsgs);                        // Free old language
 
   /* Register messages for use with my_error(). */
-  if (my_error_register(get_server_errmsgs, ER_ERROR_FIRST, ER_ERROR_LAST))
+  for (uint i=0 ; i < MAX_ERROR_RANGES ; i++)
   {
-    my_free(errmsgs);
-    DBUG_RETURN(TRUE);
+    if (errors_per_range[i])
+    {
+      if (my_error_register(get_server_errmsgs, (i+1)*ERRORS_PER_RANGE,
+                            (i+1)*ERRORS_PER_RANGE +
+                            errors_per_range[i]-1))
+      {
+        my_free(original_error_messages);
+        original_error_messages= 0;
+        DBUG_RETURN(TRUE);
+      }
+    }
   }
-
-  DEFAULT_ERRMSGS= errmsgs;             /* Init global variable */
+  DEFAULT_ERRMSGS= original_error_messages;
   init_myfunc_errs();			/* Init myfunc messages */
   DBUG_RETURN(error);
 }
 
 
+void free_error_messages()
+{
+  /* We don't need to free errmsg as it's done in cleanup_errmsg */
+  for (uint i= 0 ; i < MAX_ERROR_RANGES ; i++)
+  {
+    if (errors_per_range[i])
+    {
+      my_error_unregister((i+1)*ERRORS_PER_RANGE,
+                          (i+1)*ERRORS_PER_RANGE +
+                          errors_per_range[i]-1);
+      errors_per_range[i]= 0;
+    }
+  }
+}
+
+
 /**
    Check the error messages array contains all relevant error messages
 */
@@ -125,11 +155,17 @@ static bool check_error_mesg(const char *file_name, const char **errmsg)
     The last MySQL error message can't be an empty string; If it is,
     it means that the error file doesn't contain all MySQL messages
     and is probably from an older version of MySQL / MariaDB.
+    We also check that each section has enough error messages.
   */
-  if (errmsg[ER_LAST_MYSQL_ERROR_MESSAGE -1 - ER_ERROR_FIRST][0] == 0)
+  if (errmsg[ER_LAST_MYSQL_ERROR_MESSAGE -1 - ER_ERROR_FIRST][0] == 0 ||
+      (errors_per_range[0] < ER_ERROR_LAST_SECTION_2 - ER_ERROR_FIRST + 1) ||
+      errors_per_range[1] != 0 ||
+      (errors_per_range[2] < ER_ERROR_LAST_SECTION_4 - 
+       ER_ERROR_FIRST_SECTION_4 +1) ||
+      (errors_per_range[2] < ER_ERROR_LAST - ER_ERROR_FIRST_SECTION_5 + 1))
   {
     sql_print_error("Error message file '%s' is probably from and older "
-                    "version of MariaDB / MYSQL as it doesn't contain all "
+                    "version of MariaDB as it doesn't contain all "
                     "error messages", file_name);
     return 1;
   }
@@ -137,27 +173,27 @@ static bool check_error_mesg(const char *file_name, const char **errmsg)
 }
 
 
-/**
-  Read text from packed textfile in language-directory.
+struct st_msg_file
+{
+  uint sections;
+  uint errors;
+  size_t text_length;
+};
 
-  If we can't read messagefile then it's panic- we can't continue.
+/**
+  Open file for packed textfile in language-directory.
 */
 
-bool read_texts(const char *file_name, const char *language,
-                const char ***point, uint error_messages)
+static File open_error_msg_file(const char *file_name, const char *language,
+                                uint error_messages, struct st_msg_file *ret)
 {
-  register uint i;
-  uint count,funktpos;
-  size_t offset, length;
+  int error_pos= 0;
   File file;
   char name[FN_REFLEN];
   char lang_path[FN_REFLEN];
-  uchar *UNINIT_VAR(buff);
-  uchar head[32],*pos;
-  DBUG_ENTER("read_texts");
+  uchar head[32];
+  DBUG_ENTER("open_error_msg_file");
 
-  *point= 0;
-  funktpos=0;
   convert_dirname(lang_path, language, NullS);
   (void) my_load_path(lang_path, lang_path, lc_messages_dir);
   if ((file= mysql_file_open(key_file_ERRMSG,
@@ -168,69 +204,120 @@ bool read_texts(const char *file_name, const char *language,
     /*
       Trying pre-5.4 sematics of the --language parameter.
       It included the language-specific part, e.g.:
-      
       --language=/path/to/english/
     */
     if ((file= mysql_file_open(key_file_ERRMSG,
-                               fn_format(name, file_name, lc_messages_dir, "", 4),
+                               fn_format(name, file_name, lc_messages_dir, "",
+                                         4),
                                O_RDONLY | O_SHARE | O_BINARY,
                                MYF(0))) < 0)
       goto err;
     sql_print_warning("An old style --language or -lc-message-dir value with language specific part detected: %s", lc_messages_dir);
     sql_print_warning("Use --lc-messages-dir without language specific part instead.");
   }
-
-  funktpos=1;
+  error_pos=1;
   if (mysql_file_read(file, (uchar*) head, 32, MYF(MY_NABP)))
     goto err;
-  funktpos=2;
+  error_pos=2;
   if (head[0] != (uchar) 254 || head[1] != (uchar) 254 ||
-      head[2] != 2 || head[3] != 3)
+      head[2] != 2 || head[3] != 4)
     goto err; /* purecov: inspected */
 
-  error_message_charset_info= system_charset_info;
-  length=uint4korr(head+6); count=uint2korr(head+10);
+  ret->text_length= uint4korr(head+6);
+  ret->errors=      uint2korr(head+10);
+  ret->sections=    uint2korr(head+12);
 
-  if (count < error_messages)
+  if (ret->errors < error_messages || ret->sections != MAX_ERROR_RANGES)
   {
     sql_print_error("\
 Error message file '%s' had only %d error messages, but it should contain at least %d error messages.\nCheck that the above file is the right version for this program!",
-		    name,count,error_messages);
+		    name,ret->errors,error_messages);
     (void) mysql_file_close(file, MYF(MY_WME));
-    DBUG_RETURN(1);
+    DBUG_RETURN(FERR);
   }
-
-  if (!(*point= (const char**)
-	my_malloc((size_t) (MY_MAX(length,count*2)+count*sizeof(char*)),MYF(0))))
-  {
-    funktpos=3;					/* purecov: inspected */
-    goto err;					/* purecov: inspected */
-  }
-  buff= (uchar*) (*point + count);
-
-  if (mysql_file_read(file, buff, (size_t) count*2, MYF(MY_NABP)))
-    goto err;
-  for (i=0, offset=0, pos= buff ; i< count ; i++)
-  {
-    (*point)[i]= (char*) buff+offset;
-    offset+= uint2korr(pos);
-    pos+=2;
-  }
-  if (mysql_file_read(file, buff, length, MYF(MY_NABP)))
-    goto err;
-
-  (void) mysql_file_close(file, MYF(0));
-
-  i= check_error_mesg(file_name, *point);
-  DBUG_RETURN(i);
+  DBUG_RETURN(file);
 
 err:
-  sql_print_error((funktpos == 3) ? "Not enough memory for messagefile '%s'" :
-                  (funktpos == 2) ? "Incompatible header in messagefile '%s'. Probably from another version of MariaDB" :
-                  ((funktpos == 1) ? "Can't read from messagefile '%s'" :
+  sql_print_error((error_pos == 2) ?
+                  "Incompatible header in messagefile '%s'. Probably from "
+                  "another version of MariaDB" :
+                  ((error_pos == 1) ? "Can't read from messagefile '%s'" :
                    "Can't find messagefile '%s'"), name);
   if (file != FERR)
     (void) mysql_file_close(file, MYF(MY_WME));
+  DBUG_RETURN(FERR);
+}
+
+
+/*
+  Define the number of normal and extra error messages in the errmsg.sys
+  file
+*/
+
+static const uint error_messages= ER_ERROR_LAST - ER_ERROR_FIRST+1;
+
+/**
+  Read text from packed textfile in language-directory.
+*/
+
+bool read_texts(const char *file_name, const char *language,
+                const char ****data)
+{
+  uint i, range_size;
+  const char **point;
+  size_t offset;
+  File file;
+  uchar *buff, *pos;
+  struct st_msg_file msg_file;
+  DBUG_ENTER("read_texts");
+
+  if ((file= open_error_msg_file(file_name, language, error_messages,
+                                 &msg_file)) == FERR)
+    DBUG_RETURN(1);
+
+  if (!(*data= (const char***)
+	my_malloc((size_t) ((MAX_ERROR_RANGES+1) * sizeof(char**) +
+                            MY_MAX(msg_file.text_length, msg_file.errors * 2)+
+                            msg_file.errors * sizeof(char*)),
+                  MYF(MY_WME))))
+    goto err;					/* purecov: inspected */
+
+  point= (const char**) ((*data) + MAX_ERROR_RANGES);
+  buff=  (uchar*) (point + msg_file.errors);
+
+  if (mysql_file_read(file, buff,
+                      (size_t) (msg_file.errors + msg_file.sections) * 2,
+                      MYF(MY_NABP | MY_WME)))
+    goto err;
+
+  pos= buff;
+  /* read in sections */
+  for (i= 0, offset= 0; i < msg_file.sections ; i++)
+  {
+    (*data)[i]= point + offset;
+    errors_per_range[i]= range_size= uint2korr(pos);
+    offset+= range_size;
+    pos+= 2;
+  }
+
+  /* Calculate pointers to text data */
+  for (i=0, offset=0 ; i < msg_file.errors ; i++)
+  {
+    point[i]= (char*) buff+offset;
+    offset+=uint2korr(pos);
+    pos+=2;
+  }
+
+  /* Read error message texts */
+  if (mysql_file_read(file, buff, msg_file.text_length, MYF(MY_NABP | MY_WME)))
+    goto err;
+
+  (void) mysql_file_close(file, MYF(MY_WME));
+
+  DBUG_RETURN(check_error_mesg(file_name, point));
+
+err:
+  (void) mysql_file_close(file, MYF(0));
   DBUG_RETURN(1);
 } /* read_texts */
 
diff --git a/sql/derror.h b/sql/derror.h
index b2f6331e048..9f2aee71c7e 100644
--- a/sql/derror.h
+++ b/sql/derror.h
@@ -19,7 +19,8 @@
 #include "my_global.h"                          /* uint */
 
 bool init_errmessage(void);
+void free_error_messages();
 bool read_texts(const char *file_name, const char *language,
-                const char ***point, uint error_messages);
+                const char ****data);
 
 #endif /* DERROR_INCLUDED */
diff --git a/sql/handler.cc b/sql/handler.cc
index 748a51f5c59..a03a0912908 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -295,7 +295,7 @@ handler *get_ha_partition(partition_info *part_info)
 static const char **handler_errmsgs;
 
 C_MODE_START
-static const char **get_handler_errmsgs()
+static const char **get_handler_errmsgs(int nr)
 {
   return handler_errmsgs;
 }
@@ -386,12 +386,10 @@ int ha_init_errors(void)
 */
 static int ha_finish_errors(void)
 {
-  const char    **errmsgs;
-
   /* Allocate a pointer array for the error message strings. */
-  if (! (errmsgs= my_error_unregister(HA_ERR_FIRST, HA_ERR_LAST)))
-    return 1;
-  my_free(errmsgs);
+  my_error_unregister(HA_ERR_FIRST, HA_ERR_LAST);
+  my_free(handler_errmsgs);
+  handler_errmsgs= 0;
   return 0;
 }
 
diff --git a/sql/log_event.cc b/sql/log_event.cc
index b56a9e2aee3..3715f0cc4d4 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -4523,7 +4523,7 @@ compare_errors:
                   "Error on master: message (format)='%s' error code=%d ; "
                   "Error on slave: actual message='%s', error code=%d. "
                   "Default database: '%s'. Query: '%s'",
-                  ER_SAFE_THD(thd, expected_error),
+                  ER_THD(thd, expected_error),
                   expected_error,
                   actual_error ? thd->get_stmt_da()->message() : "no error",
                   actual_error,
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index e7d7f90d44e..f53a41ead18 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -2234,13 +2234,12 @@ void clean_up(bool print_message)
 
   if (print_message && my_default_lc_messages && server_start_time)
     sql_print_information(ER_DEFAULT(ER_SHUTDOWN_COMPLETE),my_progname);
-  cleanup_errmsgs();
   MYSQL_CALLBACK(thread_scheduler, end, ());
   thread_scheduler= 0;
   mysql_library_end();
   finish_client_errs();
-  (void) my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST); // finish server errs
-  DBUG_PRINT("quit", ("Error messages freed"));
+  cleanup_errmsgs();
+  free_error_messages();
   /* Tell main we are ready */
   logger.cleanup_end();
   sys_var_end();
@@ -6012,6 +6011,8 @@ int mysqld_main(int argc, char **argv)
                          mysqld_port,
                          MYSQL_COMPILATION_COMMENT);
 
+  sql_print_information(ER_DEFAULT(ER_EXTRA_TEST));  // QQ
+
   // try to keep fd=0 busy
   if (!freopen(IF_WIN("NUL","/dev/null"), "r", stdin))
   {
diff --git a/sql/share/errmsg-utf8.txt b/sql/share/errmsg-utf8.txt
index 0d168e937a9..bcad75de25d 100644
--- a/sql/share/errmsg-utf8.txt
+++ b/sql/share/errmsg-utf8.txt
@@ -7154,3 +7154,20 @@ ER_WRONG_ORDER_IN_WITH_CLAUSE
         eng "The definition of the table '%s' refers to the table '%s' defined later in a non-recursive WITH clause"
 ER_RECURSIVE_QUERY_IN_WITH_CLAUSE
         eng "Recursive queries in WITH clause are not supported yet"
+
+#
+# Internal errors, not used
+#
+skip-to-error-number 2000
+
+# MySQL 5.7 error numbers starts here
+skip-to-error-number 3000
+
+ER_MYSQL_57_TEST
+        eng "5.7 test"
+
+# MariaDB extra error numbers starts from 4000
+skip-to-error-number 4000
+
+ER_EXTRA_TEST
+        eng "10.2 test"
diff --git a/sql/sql_class.h b/sql/sql_class.h
index be652e6dd01..7eb00d948a2 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -658,7 +658,7 @@ typedef struct system_variables
 
   /* Error messages */
   MY_LOCALE *lc_messages;
-  const char **errmsgs;             /* lc_messages->errmsg->errmsgs */
+  const char ***errmsgs;             /* lc_messages->errmsg->errmsgs */
 
   /* Locale Support */
   MY_LOCALE *lc_time_names;
diff --git a/sql/sql_locale.h b/sql/sql_locale.h
index 8357a9ecba4..e231393eec6 100644
--- a/sql/sql_locale.h
+++ b/sql/sql_locale.h
@@ -19,7 +19,7 @@
 typedef struct my_locale_errmsgs
 {
   const char *language;
-  const char **errmsgs;
+  const char ***errmsgs;
 } MY_LOCALE_ERRMSGS;
 
 #include "my_global.h"                          /* uint */
diff --git a/sql/sys_vars.cc b/sql/sys_vars.cc
index 9d871703bfe..4bf202813f3 100644
--- a/sql/sys_vars.cc
+++ b/sql/sys_vars.cc
@@ -4629,8 +4629,7 @@ static bool check_locale(sys_var *self, THD *thd, set_var *var)
     mysql_mutex_lock(&LOCK_error_messages);
     res= (!locale->errmsgs->errmsgs &&
           read_texts(ERRMSG_FILE, locale->errmsgs->language,
-                     &locale->errmsgs->errmsgs,
-                     ER_ERROR_LAST - ER_ERROR_FIRST + 1));
+                     &locale->errmsgs->errmsgs));
     mysql_mutex_unlock(&LOCK_error_messages);
     if (res)
     {
diff --git a/sql/unireg.h b/sql/unireg.h
index 10751b6ec93..251597c1884 100644
--- a/sql/unireg.h
+++ b/sql/unireg.h
@@ -43,15 +43,16 @@
 #define PLUGINDIR	"lib/plugin"
 #endif
 
-#define CURRENT_THD_ERRMSGS current_thd->variables.errmsgs
-#define DEFAULT_ERRMSGS     my_default_lc_messages->errmsgs->errmsgs
+#define MAX_ERROR_RANGES 4  /* 1000-2000, 2000-3000, 3000-4000, 4000-5000 */
+#define ERRORS_PER_RANGE 1000
 
-#define ER(X)         CURRENT_THD_ERRMSGS[(X) - ER_ERROR_FIRST]
-#define ER_DEFAULT(X) DEFAULT_ERRMSGS[(X) - ER_ERROR_FIRST]
-#define ER_SAFE(X) (((X) >= ER_ERROR_FIRST && (X) <= ER_ERROR_LAST) ? ER(X) : "Invalid error code")
-#define ER_SAFE_THD(T,X) (((X) >= ER_ERROR_FIRST && (X) <= ER_ERROR_LAST) ? ER_THD(T,X) : "Invalid error code")
-#define ER_THD(thd,X) ((thd)->variables.errmsgs[(X) - ER_ERROR_FIRST])
-#define ER_THD_OR_DEFAULT(thd,X) ((thd) ? ER_THD(thd, X) : ER_DEFAULT(X))
+#define DEFAULT_ERRMSGS           my_default_lc_messages->errmsgs->errmsgs
+#define CURRENT_THD_ERRMSGS       (current_thd)->variables.errmsgs
+
+#define ER_DEFAULT(X) DEFAULT_ERRMSGS[((X)-ER_ERROR_FIRST) / ERRORS_PER_RANGE][(X)% ERRORS_PER_RANGE]
+#define ER_THD(thd,X) ((thd)->variables.errmsgs[((X)-ER_ERROR_FIRST) / ERRORS_PER_RANGE][(X) % ERRORS_PER_RANGE])
+#define ER(X)         ER_THD(current_thd, (X))
+#define ER_THD_OR_DEFAULT(thd,X) ((thd) ? ER_THD(thd, (X)) : ER_DEFAULT(X))
 
 #define ME_INFO (ME_HOLDTANG+ME_OLDWIN+ME_NOREFRESH)
 #define ME_ERROR (ME_BELL+ME_OLDWIN+ME_NOREFRESH)
diff --git a/unittest/sql/explain_filename-t.cc b/unittest/sql/explain_filename-t.cc
index 69ce51c0446..a737ebec608 100644
--- a/unittest/sql/explain_filename-t.cc
+++ b/unittest/sql/explain_filename-t.cc
@@ -26,7 +26,8 @@
 char to[BUFLEN];
 char from[BUFLEN];
 
-const char *error_messages[1000];
+static const char *error_messages_txt[1000];
+static const char **error_messages[1]= { error_messages_txt };
 
 int setup()
 {
@@ -34,12 +35,12 @@ int setup()
   my_default_lc_messages = &my_locale_en_US;
 
   /* Populate the necessary error messages */
-  error_messages[ER_DATABASE_NAME - ER_ERROR_FIRST]     = "Database";
-  error_messages[ER_TABLE_NAME - ER_ERROR_FIRST]        = "Table";
-  error_messages[ER_PARTITION_NAME - ER_ERROR_FIRST]    = "Partition";
-  error_messages[ER_SUBPARTITION_NAME - ER_ERROR_FIRST] = "Subpartition";
-  error_messages[ER_TEMPORARY_NAME - ER_ERROR_FIRST]    = "Temporary";
-  error_messages[ER_RENAMED_NAME - ER_ERROR_FIRST]      = "Renamed";
+  error_messages[0][ER_DATABASE_NAME - ER_ERROR_FIRST]     = "Database";
+  error_messages[0][ER_TABLE_NAME - ER_ERROR_FIRST]        = "Table";
+  error_messages[0][ER_PARTITION_NAME - ER_ERROR_FIRST]    = "Partition";
+  error_messages[0][ER_SUBPARTITION_NAME - ER_ERROR_FIRST] = "Subpartition";
+  error_messages[0][ER_TEMPORARY_NAME - ER_ERROR_FIRST]    = "Temporary";
+  error_messages[0][ER_RENAMED_NAME - ER_ERROR_FIRST]      = "Renamed";
 
   my_default_lc_messages->errmsgs->errmsgs = error_messages;