~drizzle-trunk/drizzle/development

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2000 MySQL AB

 *  Copyright (C) 2008 Sun Microsystems

 *

 *  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.

 *

 *  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.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

/*

 * Errors a drizzled can give you

 */

#include "config.h"

#include "drizzled/internal/my_sys.h"

#include "drizzled/definitions.h"

#include "drizzled/error.h"

#include "drizzled/gettext.h"

#include <drizzled/unordered_map.h>

#include <exception>

namespace drizzled

{

namespace

{

class ErrorStringNotFound: public std::exception

{

public:

  ErrorStringNotFound(uint32_t code)

    : error_num_(code)

  {}

  uint32_t error_num() const

  {

    return error_num_;

  }

private:

  uint32_t error_num_;

};

/*

 * Provides a mapping from the error enum values to std::strings.

 */

class ErrorMap

{

public:

  ErrorMap();

  // Insert the message for the error.  If the error already has an existing

  // mapping, an error is logged, but the function continues.

  void add(uint32_t error_num, const std::string &message);

  // If there is no error mapping for the error_num, ErrorStringNotFound is raised.

  const std::string &find(uint32_t error_num) const;

private:

  // Disable copy and assignment.

  ErrorMap(const ErrorMap &e);

  ErrorMap& operator=(const ErrorMap &e);

  typedef unordered_map<uint32_t, std::string> ErrorMessageMap;

  ErrorMessageMap mapping_;

};

ErrorMap& get_error_map()

{

  static ErrorMap errors;

  return errors;

}

} // anonymous namespace

void add_error_message(uint32_t error_code, const std::string &message)

{

  get_error_map().add(error_code, message);

}

const char * error_message(unsigned int code)

{

  try

  {

    return get_error_map().find(code).c_str();

  }

  catch (ErrorStringNotFound const& e)

  {

    return get_error_map().find(ER_UNKNOWN_ERROR).c_str();

  }

}

error_handler_func error_handler_hook= NULL;

/*

  WARNING!

  my_error family functions have to be used according following rules:

  - if message have not parameters use my_message(ER_CODE, ER(ER_CODE), MYF(N))

  - if message registered use my_error(ER_CODE, MYF(N), ...).

  - With some special text of errror message use:

  my_printf_error(ER_CODE, format, MYF(N), ...)

*/

/*

   Error message to user

   SYNOPSIS

     my_error()

       nr	Errno

       MyFlags	Flags

       ...	variable list

*/

void my_error(int nr, myf MyFlags, ...)

{

  std::string format;

  va_list args;

  char ebuff[ERRMSGSIZE + 20];

  try

  {

    format= get_error_map().find(nr);

    va_start(args,MyFlags);

    (void) vsnprintf (ebuff, sizeof(ebuff), _(format.c_str()), args);

    va_end(args);

  }

  catch (ErrorStringNotFound const& e)

  {

    (void) snprintf (ebuff, sizeof(ebuff), _("Unknown error %d"), nr);

  }

  (*error_handler_hook)(nr, ebuff, MyFlags);

}

/*

  Error as printf

         SYNOPSIS

    my_printf_error()

      error	Errno

      format	Format string

      MyFlags	Flags

      ...	variable list

*/

void my_printf_error(uint32_t error, const char *format, myf MyFlags, ...)

{

  va_list args;

  char ebuff[ERRMSGSIZE+20];

  va_start(args,MyFlags);

  (void) vsnprintf (ebuff, sizeof(ebuff), format, args);

  va_end(args);

  (*error_handler_hook)(error, ebuff, MyFlags);

  return;

}

/*

  Give message using error_handler_hook

  SYNOPSIS

    my_message()

      error	Errno

      str	Error message

      MyFlags	Flags

*/

void my_message(uint32_t error, const char *str, register myf MyFlags)

{

  (*error_handler_hook)(error, str, MyFlags);

}

namespace

{

// Insert the message for the error.  If the error already has an existing

// mapping, an error is logged, but the function continues.

void ErrorMap::add(uint32_t error_num, const std::string &message)

{

  if (mapping_.find(error_num) == mapping_.end())

  {

    // Log the error.

    mapping_[error_num]= message;

  }

  else

  {

    mapping_.insert(ErrorMessageMap::value_type(error_num, message));

  }

}

const std::string &ErrorMap::find(uint32_t error_num) const

{

  ErrorMessageMap::const_iterator pos= mapping_.find(error_num);

  if (pos == mapping_.end())

  {

    throw ErrorStringNotFound(error_num);

  }

  return pos->second;

}

// Constructor sets the default mappings.

ErrorMap::ErrorMap()

{

  add(ER_NO, N_("NO"));

  add(ER_YES, N_("YES"));

  add(ER_CANT_CREATE_FILE, N_("Can't create file '%-.200s' (errno: %d)"));

  add(ER_CANT_CREATE_TABLE, N_("Can't create table '%-.200s' (errno: %d)"));

  add(ER_CANT_CREATE_DB, N_("Can't create database '%-.192s' (errno: %d)"));

  add(ER_DB_CREATE_EXISTS, N_("Can't create database '%-.192s'; database exists"));

  add(ER_DB_DROP_EXISTS, N_("Can't drop database '%-.192s'; database doesn't exist"));

  add(ER_DB_DROP_DELETE, N_("Error dropping database (can't delete '%-.192s', errno: %d)"));

  add(ER_DB_DROP_RMDIR, N_("Error dropping database (can't rmdir '%-.192s', errno: %d)"));

  add(ER_CANT_DELETE_FILE, N_("Error on delete of '%-.192s' (errno: %d)"));

  add(ER_CANT_FIND_SYSTEM_REC, N_("Can't read record in system table"));

  add(ER_CANT_GET_STAT, N_("Can't get status of '%-.200s' (errno: %d)"));

  add(ER_CANT_GET_WD, N_("Can't get working directory (errno: %d)"));

  add(ER_CANT_LOCK, N_("Can't lock file (errno: %d)"));

  add(ER_CANT_OPEN_FILE, N_("Can't open file: '%-.200s' (errno: %d)"));

  add(ER_FILE_NOT_FOUND, N_("Can't find file: '%-.200s' (errno: %d)"));

  add(ER_CANT_READ_DIR, N_("Can't read dir of '%-.192s' (errno: %d)"));

  add(ER_CANT_SET_WD, N_("Can't change dir to '%-.192s' (errno: %d)"));

  add(ER_CHECKREAD, N_("Record has changed since last read in table '%-.192s'"));

  add(ER_DISK_FULL, N_("Disk full (%s); waiting for someone to free some space..."));

  add(ER_DUP_KEY, N_("Can't write; duplicate key in table '%-.192s'"));

  add(ER_ERROR_ON_CLOSE, N_("Error on close of '%-.192s' (errno: %d)"));

  add(ER_ERROR_ON_READ, N_("Error reading file '%-.200s' (errno: %d)"));

  add(ER_ERROR_ON_RENAME, N_("Error on rename of '%-.150s' to '%-.150s' (errno: %d)"));

  add(ER_ERROR_ON_WRITE, N_("Error writing file '%-.200s' (errno: %d)"));

  add(ER_FILE_USED, N_("'%-.192s' is locked against change"));

  add(ER_FILSORT_ABORT, N_("Sort aborted"));

  add(ER_FORM_NOT_FOUND, N_("View '%-.192s' doesn't exist for '%-.192s'"));

  add(ER_GET_ERRNO, N_("Got error %d from storage engine"));

  add(ER_ILLEGAL_HA, N_("Table storage engine for '%-.192s' doesn't have this option"));

  add(ER_KEY_NOT_FOUND, N_("Can't find record in '%-.192s'"));

  add(ER_NOT_FORM_FILE, N_("Incorrect information in file: '%-.200s'"));

  add(ER_NOT_KEYFILE, N_("Incorrect key file for table '%-.200s'; try to repair it"));

  add(ER_OLD_KEYFILE, N_("Old key file for table '%-.192s'; repair it!"));

  add(ER_OPEN_AS_READONLY, N_("Table '%-.192s' is read only"));

  add(ER_OUTOFMEMORY, N_("Out of memory; restart server and try again (needed %lu bytes)"));

  add(ER_OUT_OF_SORTMEMORY, N_("Out of sort memory; increase server sort buffer size"));

  add(ER_UNEXPECTED_EOF, N_("Unexpected EOF found when reading file '%-.192s' (errno: %d)"));

  add(ER_CON_COUNT_ERROR, N_("Too many connections"));

  add(ER_OUT_OF_RESOURCES, N_("Out of memory; check if drizzled or some other process uses all available memory; if not, you may have to use 'ulimit' to allow drizzled to use more memory or you can add more swap space"));

  add(ER_BAD_HOST_ERROR, N_("Can't get hostname for your address"));

  add(ER_HANDSHAKE_ERROR, N_("Bad handshake"));

  add(ER_DBACCESS_DENIED_ERROR, N_("Access denied for user '%-.48s'@'%-.64s' to database '%-.192s'"));

  add(ER_ACCESS_DENIED_ERROR, N_("Access denied for user '%-.48s'@'%-.64s' (using password: %s)"));

  add(ER_NO_DB_ERROR, N_("No database selected"));

  add(ER_UNKNOWN_COM_ERROR, N_("Unknown command"));

  add(ER_BAD_NULL_ERROR, N_("Column '%-.192s' cannot be null"));

  add(ER_BAD_DB_ERROR, N_("Unknown database '%-.192s'"));

  add(ER_TABLE_EXISTS_ERROR, N_("Table '%-.192s' already exists"));

  add(ER_BAD_TABLE_ERROR, N_("Unknown table '%-.100s'"));

  add(ER_NON_UNIQ_ERROR, N_("Column '%-.192s' in %-.192s is ambiguous"));

  add(ER_SERVER_SHUTDOWN, N_("Server shutdown in progress"));

  add(ER_BAD_FIELD_ERROR, N_("Unknown column '%-.192s' in '%-.192s'"));

  add(ER_WRONG_FIELD_WITH_GROUP, N_("'%-.192s' isn't in GROUP BY"));

  add(ER_WRONG_GROUP_FIELD, N_("Can't group on '%-.192s'"));

  add(ER_WRONG_SUM_SELECT, N_("Statement has sum functions and columns in same statement"));

  add(ER_WRONG_VALUE_COUNT, N_("Column count doesn't match value count"));

  add(ER_TOO_LONG_IDENT, N_("Identifier name '%-.100s' is too long"));

  add(ER_DUP_FIELDNAME, N_("Duplicate column name '%-.192s'"));

  add(ER_DUP_KEYNAME, N_("Duplicate key name '%-.192s'"));

  add(ER_DUP_ENTRY, N_("Duplicate entry '%-.192s' for key %d"));

  add(ER_WRONG_FIELD_SPEC, N_("Incorrect column specifier for column '%-.192s'"));

  add(ER_PARSE_ERROR, N_("%s near '%-.80s' at line %d"));

  add(ER_EMPTY_QUERY, N_("Query was empty"));

  add(ER_NONUNIQ_TABLE, N_("Not unique table/alias: '%-.192s'"));

  add(ER_INVALID_DEFAULT, N_("Invalid default value for '%-.192s'"));

  add(ER_MULTIPLE_PRI_KEY, N_("Multiple primary key defined"));

  add(ER_TOO_MANY_KEYS, N_("Too many keys specified; max %d keys allowed"));

  add(ER_TOO_MANY_KEY_PARTS, N_("Too many key parts specified; max %d parts allowed"));

  add(ER_TOO_LONG_KEY, N_("Specified key was too long; max key length is %d bytes"));

  add(ER_KEY_COLUMN_DOES_NOT_EXITS, N_("Key column '%-.192s' doesn't exist in table"));

  add(ER_BLOB_USED_AS_KEY, N_("BLOB column '%-.192s' can't be used in key specification with the used table type"));

  add(ER_TOO_BIG_FIELDLENGTH, N_("Column length too big for column '%-.192s' (max = %d); use BLOB or TEXT instead"));

  add(ER_WRONG_AUTO_KEY, N_("Incorrect table definition; there can be only one auto column and it must be defined as a key"));

  add(ER_READY, N_("%s: ready for connections.\nVersion: '%s'  socket: '%s'  port: %u\n"));

  add(ER_NORMAL_SHUTDOWN, N_("%s: Normal shutdown\n"));

  add(ER_GOT_SIGNAL, N_("%s: Got signal %d. Aborting!\n"));

  add(ER_SHUTDOWN_COMPLETE, N_("%s: Shutdown complete\n"));

  add(ER_FORCING_CLOSE, N_("%s: Forcing close of thread %" PRIu64 " user: '%-.48s'\n"));

  add(ER_IPSOCK_ERROR, N_("Can't create IP socket"));

  add(ER_NO_SUCH_INDEX, N_("Table '%-.192s' has no index like the one used in CREATE INDEX; recreate the table"));

  add(ER_WRONG_FIELD_TERMINATORS, N_("Field separator argument '%-.32s' with length '%d' is not what is expected; check the manual"));

  add(ER_BLOBS_AND_NO_TERMINATED, N_("You can't use fixed rowlength with BLOBs; please use 'fields terminated by'"));

  add(ER_TEXTFILE_NOT_READABLE, N_("The file '%-.128s' must be in the database directory or be readable by all"));

  add(ER_FILE_EXISTS_ERROR, N_("File '%-.200s' already exists"));

  add(ER_LOAD_INFO, N_("Records: %ld  Deleted: %ld  Skipped: %ld  Warnings: %ld"));

  add(ER_ALTER_INFO, N_("Records: %ld  Duplicates: %ld"));

  add(ER_WRONG_SUB_KEY, N_("Incorrect prefix key; the used key part isn't a string, the used length is longer than the key part, or the storage engine doesn't support unique prefix keys"));

  add(ER_CANT_REMOVE_ALL_FIELDS, N_("You can't delete all columns with ALTER TABLE; use DROP TABLE instead"));

  add(ER_CANT_DROP_FIELD_OR_KEY, N_("Can't DROP '%-.192s'; check that column/key exists"));

  add(ER_INSERT_INFO, N_("Records: %ld  Duplicates: %ld  Warnings: %ld"));

  add(ER_UPDATE_TABLE_USED, N_("You can't specify target table '%-.192s' for update in FROM clause"));

  add(ER_NO_SUCH_THREAD, N_("Unknown thread id: %lu"));

  add(ER_KILL_DENIED_ERROR, N_("You are not owner of thread %lu"));

  add(ER_NO_TABLES_USED, N_("No tables used"));

  add(ER_TOO_BIG_SET, N_("Too many strings for column %-.192s and SET"));

  add(ER_NO_UNIQUE_LOGFILE, N_("Can't generate a unique log-filename %-.200s.(1-999)\n"));

  add(ER_TABLE_NOT_LOCKED_FOR_WRITE, N_("Table '%-.192s' was locked with a READ lock and can't be updated"));

  add(ER_TABLE_NOT_LOCKED, N_("Table '%-.192s' was not locked with LOCK TABLES"));

  add(ER_BLOB_CANT_HAVE_DEFAULT, N_("BLOB/TEXT column '%-.192s' can't have a default value"));

  add(ER_WRONG_DB_NAME, N_("Incorrect database name '%-.100s'"));

  add(ER_WRONG_TABLE_NAME, N_("Incorrect table name '%-.100s'"));

  add(ER_TOO_BIG_SELECT, N_("The SELECT would examine more than MAX_JOIN_SIZE rows; check your WHERE and use SET SQL_BIG_SELECTS=1 or SET MAX_JOIN_SIZE=# if the SELECT is okay"));

  add(ER_UNKNOWN_ERROR, N_("Unknown error"));

  add(ER_UNKNOWN_PROCEDURE, N_("Unknown procedure '%-.192s'"));

  add(ER_WRONG_PARAMCOUNT_TO_PROCEDURE, N_("Incorrect parameter count to procedure '%-.192s'"));

  add(ER_WRONG_PARAMETERS_TO_PROCEDURE, N_("Incorrect parameters to procedure '%-.192s'"));

  add(ER_UNKNOWN_TABLE, N_("Unknown table '%-.192s' in %-.32s"));

  add(ER_FIELD_SPECIFIED_TWICE, N_("Column '%-.192s' specified twice"));

  add(ER_INVALID_GROUP_FUNC_USE, N_("Invalid use of group function"));

  add(ER_UNSUPPORTED_EXTENSION, N_("Table '%-.192s' uses an extension that doesn't exist in this Drizzle version"));

  add(ER_TABLE_MUST_HAVE_COLUMNS, N_("A table must have at least 1 column"));

  add(ER_RECORD_FILE_FULL, N_("The table '%-.192s' is full"));

  add(ER_UNKNOWN_CHARACTER_SET, N_("Unknown character set: '%-.64s'"));

  add(ER_TOO_MANY_TABLES, N_("Too many tables; Drizzle can only use %d tables in a join"));

  add(ER_TOO_MANY_FIELDS, N_("Too many columns"));

  add(ER_TOO_BIG_ROWSIZE, N_("Row size too large. The maximum row size for the used table type, not counting BLOBs, is %ld. You have to change some columns to TEXT or BLOBs"));

  add(ER_STACK_OVERRUN, N_("Thread stack overrun:  Used: %ld of a %ld stack.  Use 'drizzled -O thread_stack=#' to specify a bigger stack if needed"));

  add(ER_WRONG_OUTER_JOIN, N_("Cross dependency found in OUTER JOIN; examine your ON conditions"));

  add(ER_NULL_COLUMN_IN_INDEX, N_("Table handler doesn't support NULL in given index. Please change column '%-.192s' to be NOT NULL or use another handler"));

  add(ER_CANT_FIND_UDF, N_("Can't load function '%-.192s'"));

  add(ER_CANT_INITIALIZE_UDF, N_("Can't initialize function '%-.192s'; %-.80s"));

  add(ER_PLUGIN_NO_PATHS, N_("No paths allowed for plugin library"));

  add(ER_PLUGIN_EXISTS, N_("Plugin '%-.192s' already exists"));

  add(ER_CANT_OPEN_LIBRARY, N_("Can't open shared library '%-.192s' (errno: %d %-.128s)"));

  add(ER_CANT_FIND_DL_ENTRY, N_("Can't find symbol '%-.128s' in library '%-.128s'"));

  add(ER_FUNCTION_NOT_DEFINED, N_("Function '%-.192s' is not defined"));

  add(ER_HOST_IS_BLOCKED, N_("Host '%-.64s' is blocked because of many connection errors; unblock with 'drizzleadmin flush-hosts'"));

  add(ER_HOST_NOT_PRIVILEGED, N_("Host '%-.64s' is not allowed to connect to this Drizzle server"));

  add(ER_PASSWORD_ANONYMOUS_USER, N_("You are using Drizzle as an anonymous user and anonymous users are not allowed to change passwords"));

  add(ER_PASSWORD_NOT_ALLOWED, N_("You must have privileges to update tables in the drizzle database to be able to change passwords for others"));

  add(ER_PASSWORD_NO_MATCH, N_("Can't find any matching row in the user table"));

  add(ER_UPDATE_INFO, N_("Rows matched: %ld  Changed: %ld  Warnings: %ld"));

  add(ER_CANT_CREATE_THREAD, N_("Can't create a new thread (errno %d); if you are not out of available memory, you can consult the manual for a possible OS-dependent bug"));

  add(ER_WRONG_VALUE_COUNT_ON_ROW, N_("Column count doesn't match value count at row %ld"));

  add(ER_CANT_REOPEN_TABLE, N_("Can't reopen table: '%-.192s'"));

  add(ER_INVALID_USE_OF_NULL, N_("Invalid use of NULL value"));

  add(ER_REGEXP_ERROR, N_("Got error '%-.64s' from regexp"));

  add(ER_MIX_OF_GROUP_FUNC_AND_FIELDS, N_("Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) with no GROUP columns is illegal if there is no GROUP BY clause"));

  add(ER_NONEXISTING_GRANT, N_("There is no such grant defined for user '%-.48s' on host '%-.64s'"));

  add(ER_TABLEACCESS_DENIED_ERROR, N_("%-.16s command denied to user '%-.48s'@'%-.64s' for table '%-.192s'"));

  add(ER_COLUMNACCESS_DENIED_ERROR, N_("%-.16s command denied to user '%-.48s'@'%-.64s' for column '%-.192s' in table '%-.192s'"));

  add(ER_ILLEGAL_GRANT_FOR_TABLE, N_("Illegal GRANT/REVOKE command; please consult the manual to see which privileges can be used"));

  add(ER_GRANT_WRONG_HOST_OR_USER, N_("The host or user argument to GRANT is too long"));

  add(ER_NO_SUCH_TABLE, N_("Table '%-.192s.%-.192s' doesn't exist"));

  add(ER_NONEXISTING_TABLE_GRANT, N_("There is no such grant defined for user '%-.48s' on host '%-.64s' on table '%-.192s'"));

  add(ER_NOT_ALLOWED_COMMAND, N_("The used command is not allowed with this Drizzle version"));

  add(ER_SYNTAX_ERROR, N_("You have an error in your SQL syntax; check the manual that corresponds to your Drizzle server version for the right syntax to use"));

  add(ER_DELAYED_CANT_CHANGE_LOCK, N_("Delayed insert thread couldn't get requested lock for table %-.192s"));

  add(ER_TOO_MANY_DELAYED_THREADS, N_("Too many delayed threads in use"));

  add(ER_ABORTING_CONNECTION, N_("Aborted connection %ld to db: '%-.192s' user: '%-.48s' (%-.64s)"));

  add(ER_NET_PACKET_TOO_LARGE, N_("Got a packet bigger than 'max_allowed_packet' bytes"));

  add(ER_NET_READ_ERROR_FROM_PIPE, N_("Got a read error from the connection pipe"));

  add(ER_NET_FCNTL_ERROR, N_("Got an error from fcntl()"));

  add(ER_NET_PACKETS_OUT_OF_ORDER, N_("Got packets out of order"));

  add(ER_NET_UNCOMPRESS_ERROR, N_("Couldn't uncompress communication packet"));

  add(ER_NET_READ_ERROR, N_("Got an error reading communication packets"));

  add(ER_NET_READ_INTERRUPTED, N_("Got timeout reading communication packets"));

  add(ER_NET_ERROR_ON_WRITE, N_("Got an error writing communication packets"));

  add(ER_NET_WRITE_INTERRUPTED, N_("Got timeout writing communication packets"));

  add(ER_TOO_LONG_STRING, N_("Result string is longer than 'max_allowed_packet' bytes"));

  add(ER_TABLE_CANT_HANDLE_BLOB, N_("The used table type doesn't support BLOB/TEXT columns"));

  add(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT, N_("The used table type doesn't support AUTO_INCREMENT columns"));

  add(ER_DELAYED_INSERT_TABLE_LOCKED, N_("INSERT DELAYED can't be used with table '%-.192s' because it is locked with LOCK TABLES"));

  add(ER_WRONG_COLUMN_NAME, N_("Incorrect column name '%-.100s'"));

  add(ER_WRONG_KEY_COLUMN, N_("The used storage engine can't index column '%-.192s'"));

  add(ER_WRONG_MRG_TABLE, N_("Unable to open underlying table which is differently defined or of non-MyISAM type or doesn't exist"));

  add(ER_DUP_UNIQUE, N_("Can't write, because of unique constraint, to table '%-.192s'"));

  add(ER_BLOB_KEY_WITHOUT_LENGTH, N_("BLOB/TEXT column '%-.192s' used in key specification without a key length"));

  add(ER_PRIMARY_CANT_HAVE_NULL, N_("All parts of a PRIMARY KEY must be NOT NULL; if you need NULL in a key, use UNIQUE instead"));

  add(ER_TOO_MANY_ROWS, N_("Result consisted of more than one row"));

  add(ER_REQUIRES_PRIMARY_KEY, N_("This table type requires a primary key"));

  add(ER_NO_RAID_COMPILED, N_("This version of Drizzle is not compiled with RAID support"));

  add(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE, N_("You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column"));

  add(ER_KEY_DOES_NOT_EXITS, N_("Key '%-.192s' doesn't exist in table '%-.192s'"));

  add(ER_CHECK_NO_SUCH_TABLE, N_("Can't open table"));

  add(ER_CHECK_NOT_IMPLEMENTED, N_("The storage engine for the table doesn't support %s"));

  add(ER_CANT_DO_THIS_DURING_AN_TRANSACTION, N_("You are not allowed to execute this command in a transaction"));

  add(ER_ERROR_DURING_COMMIT, N_("Got error %d during COMMIT"));

  add(ER_ERROR_DURING_ROLLBACK, N_("Got error %d during ROLLBACK"));

  add(ER_ERROR_DURING_FLUSH_LOGS, N_("Got error %d during FLUSH_LOGS"));

  add(ER_ERROR_DURING_CHECKPOINT, N_("Got error %d during CHECKPOINT"));

  // This is a very incorrect place to use the PRIi64 macro as the

  // program that looks over the source for the N_() macros does not

  // (obviously) do macro expansion, so the string is entirely wrong for

  // what it is trying to output for every language except english.

  add(ER_NEW_ABORTING_CONNECTION, N_("Aborted connection %"PRIi64" to db: '%-.192s' user: '%-.48s' host: '%-.64s' (%-.64s)"));

  add(ER_DUMP_NOT_IMPLEMENTED, N_("The storage engine for the table does not support binary table dump"));

  add(ER_FLUSH_MASTER_BINLOG_CLOSED, N_("Binlog closed, cannot RESET MASTER"));

  add(ER_INDEX_REBUILD, N_("Failed rebuilding the index of  dumped table '%-.192s'"));

  add(ER_MASTER, N_("Error from master: '%-.64s'"));

  add(ER_MASTER_NET_READ, N_("Net error reading from master"));

  add(ER_MASTER_NET_WRITE, N_("Net error writing to master"));

  add(ER_FT_MATCHING_KEY_NOT_FOUND, N_("Can't find FULLTEXT index matching the column list"));

  add(ER_LOCK_OR_ACTIVE_TRANSACTION, N_("Can't execute the given command because you have active locked tables or an active transaction"));

  add(ER_UNKNOWN_SYSTEM_VARIABLE, N_("Unknown system variable '%-.64s'"));

  add(ER_CRASHED_ON_USAGE, N_("Table '%-.192s' is marked as crashed and should be repaired"));

  add(ER_CRASHED_ON_REPAIR, N_("Table '%-.192s' is marked as crashed and last (automatic?) repair failed"));

  add(ER_WARNING_NOT_COMPLETE_ROLLBACK, N_("Some non-transactional changed tables couldn't be rolled back"));

  add(ER_TRANS_CACHE_FULL, N_("Multi-statement transaction required more than 'max_binlog_cache_size' bytes of storage; increase this drizzled variable and try again"));

  add(ER_SLAVE_MUST_STOP, N_("This operation cannot be performed with a running slave; run STOP SLAVE first"));

  add(ER_SLAVE_NOT_RUNNING, N_("This operation requires a running slave; configure slave and do START SLAVE"));

  add(ER_BAD_SLAVE, N_("The server is not configured as slave; fix with CHANGE MASTER TO"));

  add(ER_MASTER_INFO, N_("Could not initialize master info structure; more error messages can be found in the Drizzle error log"));

  add(ER_SLAVE_THREAD, N_("Could not create slave thread; check system resources"));

  add(ER_TOO_MANY_USER_CONNECTIONS, N_("User %-.64s already has more than 'max_user_connections' active connections"));

  add(ER_SET_CONSTANTS_ONLY, N_("You may only use constant expressions with SET"));

  add(ER_LOCK_WAIT_TIMEOUT, N_("Lock wait timeout exceeded; try restarting transaction"));

  add(ER_LOCK_TABLE_FULL, N_("The total number of locks exceeds the lock table size"));

  add(ER_READ_ONLY_TRANSACTION, N_("Update locks cannot be acquired during a READ UNCOMMITTED transaction"));

  add(ER_DROP_DB_WITH_READ_LOCK, N_("DROP DATABASE not allowed while thread is holding global read lock"));

  add(ER_CREATE_DB_WITH_READ_LOCK, N_("CREATE DATABASE not allowed while thread is holding global read lock"));

  add(ER_WRONG_ARGUMENTS, N_("Incorrect arguments to %s"));

  add(ER_NO_PERMISSION_TO_CREATE_USER, N_("'%-.48s'@'%-.64s' is not allowed to create new users"));

  add(ER_UNION_TABLES_IN_DIFFERENT_DIR, N_("Incorrect table definition; all MERGE tables must be in the same database"));

  add(ER_LOCK_DEADLOCK, N_("Deadlock found when trying to get lock; try restarting transaction"));

  add(ER_TABLE_CANT_HANDLE_FT, N_("The used table type doesn't support FULLTEXT indexes"));

  add(ER_CANNOT_ADD_FOREIGN, N_("Cannot add foreign key constraint"));

  add(ER_NO_REFERENCED_ROW, N_("Cannot add or update a child row: a foreign key constraint fails"));

  add(ER_ROW_IS_REFERENCED, N_("Cannot delete or update a parent row: a foreign key constraint fails"));

  add(ER_CONNECT_TO_MASTER, N_("Error connecting to master: %-.128s"));

  add(ER_QUERY_ON_MASTER, N_("Error running query on master: %-.128s"));

  add(ER_ERROR_WHEN_EXECUTING_COMMAND, N_("Error when executing command %s: %-.128s"));

  add(ER_WRONG_USAGE, N_("Incorrect usage of %s and %s"));

  add(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT, N_("The used SELECT statements have a different number of columns"));

  add(ER_CANT_UPDATE_WITH_READLOCK, N_("Can't execute the query because you have a conflicting read lock"));

  add(ER_MIXING_NOT_ALLOWED, N_("Mixing of transactional and non-transactional tables is disabled"));

  add(ER_DUP_ARGUMENT, N_("Option '%s' used twice in statement"));

  add(ER_USER_LIMIT_REACHED, N_("User '%-.64s' has exceeded the '%s' resource (current value: %ld)"));

  add(ER_SPECIFIC_ACCESS_DENIED_ERROR, N_("Access denied; you need the %-.128s privilege for this operation"));

  add(ER_LOCAL_VARIABLE, N_("Variable '%-.64s' is a SESSION variable and can't be used with SET GLOBAL"));

  add(ER_GLOBAL_VARIABLE, N_("Variable '%-.64s' is a GLOBAL variable and should be set with SET GLOBAL"));

  add(ER_NO_DEFAULT, N_("Variable '%-.64s' doesn't have a default value"));

  add(ER_WRONG_VALUE_FOR_VAR, N_("Variable '%-.64s' can't be set to the value of '%-.200s'"));

  add(ER_WRONG_TYPE_FOR_VAR, N_("Incorrect argument type to variable '%-.64s'"));

  add(ER_VAR_CANT_BE_READ, N_("Variable '%-.64s' can only be set, not read"));

  add(ER_CANT_USE_OPTION_HERE, N_("Incorrect usage/placement of '%s'"));

  add(ER_NOT_SUPPORTED_YET, N_("This version of Drizzle doesn't yet support '%s'"));

  add(ER_MASTER_FATAL_ERROR_READING_BINLOG, N_("Got fatal error %d: '%-.128s' from master when reading data from binary log"));

  add(ER_SLAVE_IGNORED_TABLE, N_("Slave SQL thread ignored the query because of replicate-*-table rules"));

  add(ER_INCORRECT_GLOBAL_LOCAL_VAR, N_("Variable '%-.192s' is a %s variable"));

  add(ER_WRONG_FK_DEF, N_("Incorrect foreign key definition for '%-.192s': %s"));

  add(ER_KEY_REF_DO_NOT_MATCH_TABLE_REF, N_("Key reference and table reference don't match"));

  add(ER_OPERAND_COLUMNS, N_("Operand should contain %d column(s)"));

  add(ER_SUBQUERY_NO_1_ROW, N_("Subquery returns more than 1 row"));

  add(ER_UNKNOWN_STMT_HANDLER, N_("Unknown prepared statement handler (%.*s) given to %s"));

  add(ER_CORRUPT_HELP_DB, N_("Help database is corrupt or does not exist"));

  add(ER_CYCLIC_REFERENCE, N_("Cyclic reference on subqueries"));

  add(ER_AUTO_CONVERT, N_("Converting column '%s' from %s to %s"));

  add(ER_ILLEGAL_REFERENCE, N_("Reference '%-.64s' not supported (%s)"));

  add(ER_DERIVED_MUST_HAVE_ALIAS, N_("Every derived table must have its own alias"));

  add(ER_SELECT_REDUCED, N_("Select %u was reduced during optimization"));

  add(ER_TABLENAME_NOT_ALLOWED_HERE, N_("Table '%-.192s' from one of the SELECTs cannot be used in %-.32s"));

  add(ER_NOT_SUPPORTED_AUTH_MODE, N_("Client does not support authentication protocol requested by server; consider upgrading Drizzle client"));

  add(ER_SPATIAL_CANT_HAVE_NULL, N_("All parts of a SPATIAL index must be NOT NULL"));

  add(ER_COLLATION_CHARSET_MISMATCH, N_("COLLATION '%s' is not valid for CHARACTER SET '%s'"));

  add(ER_SLAVE_WAS_RUNNING, N_("Slave is already running"));

  add(ER_SLAVE_WAS_NOT_RUNNING, N_("Slave already has been stopped"));

  add(ER_TOO_BIG_FOR_UNCOMPRESS, N_("Uncompressed data size too large; the maximum size is %d (based on max_allowed_packet). The length of uncompressed data may also be corrupted."));

  add(ER_ZLIB_Z_MEM_ERROR, N_("ZLIB: Not enough memory"));

  add(ER_ZLIB_Z_BUF_ERROR, N_("ZLIB: Not enough room in the output buffer (probably, length of uncompressed data was corrupted)"));

  add(ER_ZLIB_Z_DATA_ERROR, N_("ZLIB: Input data corrupted"));

  add(ER_CUT_VALUE_GROUP_CONCAT, N_("%d line(s) were cut by GROUP_CONCAT()"));

  add(ER_WARN_TOO_FEW_RECORDS, N_("Row %ld doesn't contain data for all columns"));

  add(ER_WARN_TOO_MANY_RECORDS, N_("Row %ld was truncated; it contained more data than there were input columns"));

  add(ER_WARN_NULL_TO_NOTNULL, N_("Column set to default value; NULL supplied to NOT NULL column '%s' at row %ld"));

  add(ER_WARN_DATA_OUT_OF_RANGE, N_("Out of range value for column '%s' at row %ld"));

  add(ER_WARN_DATA_TRUNCATED, N_("Data truncated for column '%s' at row %ld"));

  add(ER_WARN_USING_OTHER_HANDLER, N_("Using storage engine %s for table '%s'"));

  add(ER_CANT_AGGREGATE_2COLLATIONS, N_("Illegal mix of collations (%s,%s) and (%s,%s) for operation '%s'"));

  add(ER_DROP_USER, N_("Cannot drop one or more of the requested users"));

  add(ER_REVOKE_GRANTS, N_("Can't revoke all privileges for one or more of the requested users"));

  add(ER_CANT_AGGREGATE_3COLLATIONS, N_("Illegal mix of collations (%s,%s), (%s,%s), (%s,%s) for operation '%s'"));

  add(ER_CANT_AGGREGATE_NCOLLATIONS, N_("Illegal mix of collations for operation '%s'"));

  add(ER_VARIABLE_IS_NOT_STRUCT, N_("Variable '%-.64s' is not a variable component (can't be used as XXXX.variable_name)"));

  add(ER_UNKNOWN_COLLATION, N_("Unknown collation: '%-.64s'"));

  add(ER_SLAVE_IGNORED_SSL_PARAMS, N_("SSL parameters in CHANGE MASTER are ignored because this Drizzle slave was compiled without SSL support; they can be used later if Drizzle slave with SSL is started"));

  add(ER_SERVER_IS_IN_SECURE_AUTH_MODE, N_("Server is running in --secure-auth mode, but '%s'@'%s' has a password in the old format; please change the password to the new format"));

  add(ER_WARN_FIELD_RESOLVED, N_("Field or reference '%-.192s%s%-.192s%s%-.192s' of SELECT #%d was resolved in SELECT #%d"));

  add(ER_BAD_SLAVE_UNTIL_COND, N_("Incorrect parameter or combination of parameters for START SLAVE UNTIL"));

  add(ER_MISSING_SKIP_SLAVE, N_("It is recommended to use --skip-slave-start when doing step-by-step replication with START SLAVE UNTIL; otherwise, you will get problems if you get an unexpected slave's drizzled restart"));

  add(ER_UNTIL_COND_IGNORED, N_("SQL thread is not to be started so UNTIL options are ignored"));

  add(ER_WRONG_NAME_FOR_INDEX, N_("Incorrect index name '%-.100s'"));

  add(ER_WRONG_NAME_FOR_CATALOG, N_("Incorrect catalog name '%-.100s'"));

  add(ER_WARN_QC_RESIZE, N_("Query cache failed to set size %lu; new query cache size is %lu"));

  add(ER_BAD_FT_COLUMN, N_("Column '%-.192s' cannot be part of FULLTEXT index"));

  add(ER_UNKNOWN_KEY_CACHE, N_("Unknown key cache '%-.100s'"));

  add(ER_WARN_HOSTNAME_WONT_WORK, N_("Drizzle is started in --skip-name-resolve mode; you must restart it without this switch for this grant to work"));

  add(ER_UNKNOWN_STORAGE_ENGINE, N_("Unknown table engine '%s'"));

  add(ER_WARN_DEPRECATED_SYNTAX, N_("'%s' is deprecated; use '%s' instead"));

  add(ER_NON_UPDATABLE_TABLE, N_("The target table %-.100s of the %s is not updatable"));

  add(ER_FEATURE_DISABLED, N_("The '%s' feature is disabled; you need Drizzle built with '%s' to have it working"));

  add(ER_OPTION_PREVENTS_STATEMENT, N_("The Drizzle server is running with the %s option so it cannot execute this statement"));

  add(ER_DUPLICATED_VALUE_IN_TYPE, N_("Column '%-.100s' has duplicated value '%-.64s' in %s"));

  add(ER_TRUNCATED_WRONG_VALUE, N_("Truncated incorrect %-.32s value: '%-.128s'"));

  add(ER_TOO_MUCH_AUTO_TIMESTAMP_COLS, N_("Incorrect table definition; there can be only one TIMESTAMP column with CURRENT_TIMESTAMP in DEFAULT or ON UPDATE clause"));

  add(ER_INVALID_ON_UPDATE, N_("Invalid ON UPDATE clause for '%-.192s' column"));

  add(ER_UNSUPPORTED_PS, N_("This command is not supported in the prepared statement protocol yet"));

  add(ER_GET_ERRMSG, N_("Got error %d '%-.100s' from %s"));

  add(ER_GET_TEMPORARY_ERRMSG, N_("Got temporary error %d '%-.100s' from %s"));

  add(ER_UNKNOWN_TIME_ZONE, N_("Unknown or incorrect time zone: '%-.64s'"));

  add(ER_WARN_INVALID_TIMESTAMP, N_("Invalid TIMESTAMP value in column '%s' at row %ld"));

  add(ER_INVALID_CHARACTER_STRING, N_("Invalid %s character string: '%.64s'"));

  add(ER_WARN_ALLOWED_PACKET_OVERFLOWED, N_("Result of %s() was larger than max_allowed_packet (%ld) - truncated"));

  add(ER_CONFLICTING_DECLARATIONS, N_("Conflicting declarations: '%s%s' and '%s%s'"));

  add(ER_SP_NO_RECURSIVE_CREATE, N_("Can't create a %s from within another stored routine"));

  add(ER_SP_ALREADY_EXISTS, N_("%s %s already exists"));

  add(ER_SP_DOES_NOT_EXIST, N_("%s %s does not exist"));

  add(ER_SP_DROP_FAILED, N_("Failed to DROP %s %s"));

  add(ER_SP_STORE_FAILED, N_("Failed to CREATE %s %s"));

  add(ER_SP_LILABEL_MISMATCH, N_("%s with no matching label: %s"));

  add(ER_SP_LABEL_REDEFINE, N_("Redefining label %s"));

  add(ER_SP_LABEL_MISMATCH, N_("End-label %s without match"));

  add(ER_SP_UNINIT_VAR, N_("Referring to uninitialized variable %s"));

  add(ER_SP_BADSELECT, N_("PROCEDURE %s can't return a result set in the given context"));

  add(ER_SP_BADRETURN, N_("RETURN is only allowed in a FUNCTION"));

  add(ER_SP_BADSTATEMENT, N_("%s is not allowed in stored procedures"));

  add(ER_UPDATE_LOG_DEPRECATED_IGNORED, N_("The update log is deprecated and replaced by the binary log; SET SQL_LOG_UPDATE has been ignored"));

  add(ER_UPDATE_LOG_DEPRECATED_TRANSLATED, N_("The update log is deprecated and replaced by the binary log; SET SQL_LOG_UPDATE has been translated to SET SQL_LOG_BIN"));

  add(ER_QUERY_INTERRUPTED, N_("Query execution was interrupted"));

  add(ER_SP_WRONG_NO_OF_ARGS, N_("Incorrect number of arguments for %s %s; expected %u, got %u"));

  add(ER_SP_COND_MISMATCH, N_("Undefined CONDITION: %s"));

  add(ER_SP_NORETURN, N_("No RETURN found in FUNCTION %s"));

  add(ER_SP_NORETURNEND, N_("FUNCTION %s ended without RETURN"));

  add(ER_SP_BAD_CURSOR_QUERY, N_("Cursor statement must be a SELECT"));

  add(ER_SP_BAD_CURSOR_SELECT, N_("Cursor SELECT must not have INTO"));

  add(ER_SP_CURSOR_MISMATCH, N_("Undefined CURSOR: %s"));

  add(ER_SP_CURSOR_ALREADY_OPEN, N_("Cursor is already open"));

  add(ER_SP_CURSOR_NOT_OPEN, N_("Cursor is not open"));

  add(ER_SP_UNDECLARED_VAR, N_("Undeclared variable: %s"));

  add(ER_SP_WRONG_NO_OF_FETCH_ARGS, N_("Incorrect number of FETCH variables"));

  add(ER_SP_FETCH_NO_DATA, N_("No data - zero rows fetched, selected, or processed"));

  add(ER_SP_DUP_PARAM, N_("Duplicate parameter: %s"));

  add(ER_SP_DUP_VAR, N_("Duplicate variable: %s"));

  add(ER_SP_DUP_COND, N_("Duplicate condition: %s"));

  add(ER_SP_DUP_CURS, N_("Duplicate cursor: %s"));

  add(ER_SP_CANT_ALTER, N_("Failed to ALTER %s %s"));

  add(ER_SP_SUBSELECT_NYI, N_("Subquery value not supported"));

  add(ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, N_("%s is not allowed in stored function or trigger"));

  add(ER_SP_VARCOND_AFTER_CURSHNDLR, N_("Variable or condition declaration after cursor or handler declaration"));

  add(ER_SP_CURSOR_AFTER_HANDLER, N_("Cursor declaration after handler declaration"));

  add(ER_SP_CASE_NOT_FOUND, N_("Case not found for CASE statement"));

  add(ER_FPARSER_TOO_BIG_FILE, N_("Configuration file '%-.192s' is too big"));

  add(ER_FPARSER_BAD_HEADER, N_("Malformed file type header in file '%-.192s'"));

  add(ER_FPARSER_EOF_IN_COMMENT, N_("Unexpected end of file while parsing comment '%-.200s'"));

  add(ER_FPARSER_ERROR_IN_PARAMETER, N_("Error while parsing parameter '%-.192s' (line: '%-.192s')"));

  add(ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER, N_("Unexpected end of file while skipping unknown parameter '%-.192s'"));

  add(ER_VIEW_NO_EXPLAIN, N_("EXPLAIN/SHOW can not be issued; lacking privileges for underlying table"));

  add(ER_WRONG_OBJECT, N_("'%-.192s.%-.192s' is not %s"));

  add(ER_NONUPDATEABLE_COLUMN, N_("Column '%-.192s' is not updatable"));

  add(ER_VIEW_SELECT_DERIVED, N_("View's SELECT contains a subquery in the FROM clause"));

  add(ER_VIEW_SELECT_CLAUSE, N_("View's SELECT contains a '%s' clause"));

  add(ER_VIEW_SELECT_VARIABLE, N_("View's SELECT contains a variable or parameter"));

  add(ER_VIEW_SELECT_TMPTABLE, N_("View's SELECT refers to a temporary table '%-.192s'"));

  add(ER_VIEW_WRONG_LIST, N_("View's SELECT and view's field list have different column counts"));

  add(ER_WARN_VIEW_MERGE, N_("View merge algorithm can't be used here for now (assumed undefined algorithm)"));

  add(ER_WARN_VIEW_WITHOUT_KEY, N_("View being updated does not have complete key of underlying table in it"));

  add(ER_VIEW_INVALID, N_("View '%-.192s.%-.192s' references invalid table(s) or column(s) or function(s) or definer/invoker of view lack rights to use them"));

  add(ER_SP_NO_DROP_SP, N_("Can't drop or alter a %s from within another stored routine"));

  add(ER_SP_GOTO_IN_HNDLR, N_("GOTO is not allowed in a stored procedure handler"));

  add(ER_TRG_ALREADY_EXISTS, N_("Trigger already exists"));

  add(ER_TRG_DOES_NOT_EXIST, N_("Trigger does not exist"));

  add(ER_TRG_ON_VIEW_OR_TEMP_TABLE, N_("Trigger's '%-.192s' is view or temporary table"));

  add(ER_TRG_CANT_CHANGE_ROW, N_("Updating of %s row is not allowed in %strigger"));

  add(ER_TRG_NO_SUCH_ROW_IN_TRG, N_("There is no %s row in %s trigger"));

  add(ER_NO_DEFAULT_FOR_FIELD, N_("Field '%-.192s' doesn't have a default value"));

  add(ER_DIVISION_BY_ZERO, N_("Division by 0"));

  add(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, N_("Incorrect %-.32s value: '%-.128s' for column '%.192s' at row %u"));

  add(ER_ILLEGAL_VALUE_FOR_TYPE, N_("Illegal %s '%-.192s' value found during parsing"));

  add(ER_VIEW_NONUPD_CHECK, N_("CHECK OPTION on non-updatable view '%-.192s.%-.192s'"));

  add(ER_VIEW_CHECK_FAILED, N_("CHECK OPTION failed '%-.192s.%-.192s'"));

  add(ER_PROCACCESS_DENIED_ERROR, N_("%-.16s command denied to user '%-.48s'@'%-.64s' for routine '%-.192s'"));

  add(ER_RELAY_LOG_FAIL, N_("Failed purging old relay logs: %s"));

  add(ER_PASSWD_LENGTH, N_("Password hash should be a %d-digit hexadecimal number"));

  add(ER_UNKNOWN_TARGET_BINLOG, N_("Target log not found in binlog index"));

  add(ER_IO_ERR_LOG_INDEX_READ, N_("I/O error reading log index file"));

  add(ER_BINLOG_PURGE_PROHIBITED, N_("Server configuration does not permit binlog purge"));

  add(ER_FSEEK_FAIL, N_("Failed on fseek()"));

  add(ER_BINLOG_PURGE_FATAL_ERR, N_("Fatal error during log purge"));

  add(ER_LOG_IN_USE, N_("A purgeable log is in use, will not purge"));

  add(ER_LOG_PURGE_UNKNOWN_ERR, N_("Unknown error during log purge"));

  add(ER_RELAY_LOG_INIT, N_("Failed initializing relay log position: %s"));

  add(ER_NO_BINARY_LOGGING, N_("You are not using binary logging"));

  add(ER_RESERVED_SYNTAX, N_("The '%-.64s' syntax is reserved for purposes internal to the Drizzle server"));

  add(ER_WSAS_FAILED, N_("WSAStartup Failed"));

  add(ER_DIFF_GROUPS_PROC, N_("Can't handle procedures with different groups yet"));

  add(ER_NO_GROUP_FOR_PROC, N_("Select must have a group with this procedure"));

  add(ER_ORDER_WITH_PROC, N_("Can't use ORDER clause with this procedure"));

  add(ER_LOGGING_PROHIBIT_CHANGING_OF, N_("Binary logging and replication forbid changing the global server %s"));

  add(ER_NO_FILE_MAPPING, N_("Can't map file: %-.200s, errno: %d"));

  add(ER_WRONG_MAGIC, N_("Wrong magic in %-.64s"));

  add(ER_PS_MANY_PARAM, N_("Prepared statement contains too many placeholders"));

  add(ER_KEY_PART_0, N_("Key part '%-.192s' length cannot be 0"));

  add(ER_VIEW_CHECKSUM, N_("View text checksum failed"));

  add(ER_VIEW_MULTIUPDATE, N_("Can not modify more than one base table through a join view '%-.192s.%-.192s'"));

  add(ER_VIEW_NO_INSERT_FIELD_LIST, N_("Can not insert into join view '%-.192s.%-.192s' without fields list"));

  add(ER_VIEW_DELETE_MERGE_VIEW, N_("Can not delete from join view '%-.192s.%-.192s'"));

  add(ER_CANNOT_USER, N_("Operation %s failed for %.256s"));

  add(ER_XAER_NOTA, N_("XAER_NOTA: Unknown XID"));

  add(ER_XAER_INVAL, N_("XAER_INVAL: Invalid arguments (or unsupported command)"));

  add(ER_XAER_RMFAIL, N_("XAER_RMFAIL: The command cannot be executed when global transaction is in the  %.64s state"));

  add(ER_XAER_OUTSIDE, N_("XAER_OUTSIDE: Some work is done outside global transaction"));

  add(ER_XAER_RMERR, N_("XAER_RMERR: Fatal error occurred in the transaction branch - check your data for consistency"));

  add(ER_XA_RBROLLBACK, N_("XA_RBROLLBACK: Transaction branch was rolled back"));

  add(ER_NONEXISTING_PROC_GRANT, N_("There is no such grant defined for user '%-.48s' on host '%-.64s' on routine '%-.192s'"));

  add(ER_PROC_AUTO_GRANT_FAIL, N_("Failed to grant EXECUTE and ALTER ROUTINE privileges"));

  add(ER_PROC_AUTO_REVOKE_FAIL, N_("Failed to revoke all privileges to dropped routine"));

  add(ER_DATA_TOO_LONG, N_("Data too long for column '%s' at row %ld"));

  add(ER_SP_BAD_SQLSTATE, N_("Bad SQLSTATE: '%s'"));

  add(ER_STARTUP, N_("%s: ready for connections.\nVersion: '%s' %s\n"));

  add(ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR, N_("Can't load value from file with fixed size rows to variable"));

  add(ER_CANT_CREATE_USER_WITH_GRANT, N_("You are not allowed to create a user with GRANT"));

  add(ER_WRONG_VALUE_FOR_TYPE, N_("Incorrect %-.32s value: '%-.128s' for function %-.32s"));

  add(ER_TABLE_DEF_CHANGED, N_("Table definition has changed, please retry transaction"));

  add(ER_SP_DUP_HANDLER, N_("Duplicate handler declared in the same block"));

  add(ER_SP_NOT_VAR_ARG, N_("OUT or INOUT argument %d for routine %s is not a variable or NEW pseudo-variable in BEFORE trigger"));