← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/errname.h

  • Committer: Padraig O'Sullivan
  • Date: 2009-07-22 23:26:26 UTC
  • mto: (1039.5.43 replication)
  • mto: This revision was merged to the branch mainline in revision 1130.
  • Revision ID: osullivan.padraig@gmail.com-20090722232626-mu4khq7ho6dqcf7q
Created a simple filtered replicator that can filter by schema name or table
name.

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/errname.h
 
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 MySQL
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; either version 2 of the License, or
 
9
 *  (at your option) any later version.
 
10
 *
 
11
 *  This program is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *  GNU General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU General Public License
 
17
 *  along with this program; if not, write to the Free Software
 
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
19
 */
 
20
 
 
21
#ifndef _client_errname_h
 
22
#define _client_errname_h
 
23
 
 
24
/* List of error names to error codes, available from 5.0 */
 
25
 
 
26
#include <string>
 
27
#include <map>
 
28
 
 
29
class ErrorCodes 
 
30
{
 
31
public:
 
32
  ErrorCodes() : error_code_map()
 
33
  {
 
34
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO",1002));
 
35
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_YES",1003));
 
36
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_CREATE_FILE",1004));
 
37
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_CREATE_TABLE",1005));
 
38
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_CREATE_DB",1006));
 
39
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DB_CREATE_EXISTS",1007));
 
40
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DB_DROP_EXISTS",1008));
 
41
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DB_DROP_DELETE",1009));
 
42
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DB_DROP_RMDIR",1010));
 
43
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_DELETE_FILE",1011));
 
44
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_FIND_SYSTEM_REC",1012));
 
45
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_GET_STAT",1013));
 
46
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_GET_WD",1014));
 
47
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_LOCK",1015));
 
48
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_OPEN_FILE",1016));
 
49
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FILE_NOT_FOUND",1017));
 
50
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_READ_DIR",1018));
 
51
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_SET_WD",1019));
 
52
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CHECKREAD",1020));
 
53
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DISK_FULL",1021));
 
54
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DUP_KEY",1022));
 
55
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ERROR_ON_CLOSE",1023));
 
56
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ERROR_ON_READ",1024));
 
57
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ERROR_ON_RENAME",1025));
 
58
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ERROR_ON_WRITE",1026));
 
59
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FILE_USED",1027));
 
60
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FILSORT_ABORT",1028));
 
61
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FORM_NOT_FOUND",1029));
 
62
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_GET_ERRNO",1030));
 
63
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ILLEGAL_HA",1031));
 
64
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_KEY_NOT_FOUND",1032));
 
65
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NOT_FORM_FILE",1033));
 
66
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NOT_KEYFILE",1034));
 
67
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_OLD_KEYFILE",1035));
 
68
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_OPEN_AS_READONLY",1036));
 
69
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_OUTOFMEMORY",1037));
 
70
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_OUT_OF_SORTMEMORY",1038));
 
71
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNEXPECTED_EOF",1039));
 
72
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CON_COUNT_ERROR",1040));
 
73
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_OUT_OF_RESOURCES",1041));
 
74
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BAD_HOST_ERROR",1042));
 
75
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_HANDSHAKE_ERROR",1043));
 
76
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DBACCESS_DENIED_ERROR",1044));
 
77
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ACCESS_DENIED_ERROR",1045));
 
78
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_DB_ERROR",1046));
 
79
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_COM_ERROR",1047));
 
80
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BAD_NULL_ERROR",1048));
 
81
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BAD_DB_ERROR",1049));
 
82
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLE_EXISTS_ERROR",1050));
 
83
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BAD_TABLE_ERROR",1051));
 
84
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NON_UNIQ_ERROR",1052));
 
85
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SERVER_SHUTDOWN",1053));
 
86
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BAD_FIELD_ERROR",1054));
 
87
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_FIELD_WITH_GROUP",1055));
 
88
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_GROUP_FIELD",1056));
 
89
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_SUM_SELECT",1057));
 
90
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_VALUE_COUNT",1058));
 
91
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_LONG_IDENT",1059));
 
92
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DUP_FIELDNAME",1060));
 
93
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DUP_KEYNAME",1061));
 
94
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DUP_ENTRY",1062));
 
95
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_FIELD_SPEC",1063));
 
96
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARSE_ERROR",1064));
 
97
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EMPTY_QUERY",1065));
 
98
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NONUNIQ_TABLE",1066));
 
99
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_INVALID_DEFAULT",1067));
 
100
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MULTIPLE_PRI_KEY",1068));
 
101
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_MANY_KEYS",1069));
 
102
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_MANY_KEY_PARTS",1070));
 
103
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_LONG_KEY",1071));
 
104
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_KEY_COLUMN_DOES_NOT_EXITS",1072));
 
105
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BLOB_USED_AS_KEY",1073));
 
106
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_BIG_FIELDLENGTH",1074));
 
107
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_AUTO_KEY",1075));
 
108
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_READY",1076));
 
109
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NORMAL_SHUTDOWN",1077));
 
110
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_GOT_SIGNAL",1078));
 
111
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SHUTDOWN_COMPLETE",1079));
 
112
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FORCING_CLOSE",1080));
 
113
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_IPSOCK_ERROR",1081));
 
114
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_SUCH_INDEX",1082));
 
115
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_FIELD_TERMINATORS",1083));
 
116
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BLOBS_AND_NO_TERMINATED",1084));
 
117
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TEXTFILE_NOT_READABLE",1085));
 
118
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FILE_EXISTS_ERROR",1086));
 
119
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOAD_INFO",1087));
 
120
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ALTER_INFO",1088));
 
121
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_SUB_KEY",1089));
 
122
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_REMOVE_ALL_FIELDS",1090));
 
123
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_DROP_FIELD_OR_KEY",1091));
 
124
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_INSERT_INFO",1092));
 
125
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UPDATE_TABLE_USED",1093));
 
126
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_SUCH_THREAD",1094));
 
127
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_KILL_DENIED_ERROR",1095));
 
128
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_TABLES_USED",1096));
 
129
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_BIG_SET",1097));
 
130
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_UNIQUE_LOGFILE",1098));
 
131
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLE_NOT_LOCKED_FOR_WRITE",1099));
 
132
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLE_NOT_LOCKED",1100));
 
133
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BLOB_CANT_HAVE_DEFAULT",1101));
 
134
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_DB_NAME",1102));
 
135
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_TABLE_NAME",1103));
 
136
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_BIG_SELECT",1104));
 
137
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_ERROR",1105));
 
138
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_PROCEDURE",1106));
 
139
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_PARAMCOUNT_TO_PROCEDURE",1107));
 
140
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_PARAMETERS_TO_PROCEDURE",1108));
 
141
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_TABLE",1109));
 
142
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FIELD_SPECIFIED_TWICE",1110));
 
143
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_INVALID_GROUP_FUNC_USE",1111));
 
144
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNSUPPORTED_EXTENSION",1112));
 
145
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLE_MUST_HAVE_COLUMNS",1113));
 
146
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_RECORD_FILE_FULL",1114));
 
147
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_CHARACTER_SET",1115));
 
148
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_MANY_TABLES",1116));
 
149
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_MANY_FIELDS",1117));
 
150
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_BIG_ROWSIZE",1118));
 
151
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_STACK_OVERRUN",1119));
 
152
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_OUTER_JOIN",1120));
 
153
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NULL_COLUMN_IN_INDEX",1121));
 
154
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_FIND_UDF",1122));
 
155
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_INITIALIZE_UDF",1123));
 
156
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UDF_NO_PATHS",1124));
 
157
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UDF_EXISTS",1125));
 
158
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_OPEN_LIBRARY",1126));
 
159
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_FIND_DL_ENTRY",1127));
 
160
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FUNCTION_NOT_DEFINED",1128));
 
161
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_HOST_IS_BLOCKED",1129));
 
162
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_HOST_NOT_PRIVILEGED",1130));
 
163
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PASSWORD_ANONYMOUS_USER",1131));
 
164
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PASSWORD_NOT_ALLOWED",1132));
 
165
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PASSWORD_NO_MATCH",1133));
 
166
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UPDATE_INFO",1134));
 
167
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_CREATE_THREAD",1135));
 
168
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_VALUE_COUNT_ON_ROW",1136));
 
169
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_REOPEN_TABLE",1137));
 
170
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_INVALID_USE_OF_NULL",1138));
 
171
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_REGEXP_ERROR",1139));
 
172
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MIX_OF_GROUP_FUNC_AND_FIELDS",1140));
 
173
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NONEXISTING_GRANT",1141));
 
174
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLEACCESS_DENIED_ERROR",1142));
 
175
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_COLUMNACCESS_DENIED_ERROR",1143));
 
176
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ILLEGAL_GRANT_FOR_TABLE",1144));
 
177
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_GRANT_WRONG_HOST_OR_USER",1145));
 
178
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_SUCH_TABLE",1146));
 
179
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NONEXISTING_TABLE_GRANT",1147));
 
180
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NOT_ALLOWED_COMMAND",1148));
 
181
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SYNTAX_ERROR",1149));
 
182
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DELAYED_CANT_CHANGE_LOCK",1150));
 
183
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_MANY_DELAYED_THREADS",1151));
 
184
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ABORTING_CONNECTION",1152));
 
185
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NET_PACKET_TOO_LARGE",1153));
 
186
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NET_READ_ERROR_FROM_PIPE",1154));
 
187
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NET_FCNTL_ERROR",1155));
 
188
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NET_PACKETS_OUT_OF_ORDER",1156));
 
189
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NET_UNCOMPRESS_ERROR",1157));
 
190
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NET_READ_ERROR",1158));
 
191
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NET_READ_INTERRUPTED",1159));
 
192
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NET_ERROR_ON_WRITE",1160));
 
193
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NET_WRITE_INTERRUPTED",1161));
 
194
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_LONG_STRING",1162));
 
195
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLE_CANT_HANDLE_BLOB",1163));
 
196
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLE_CANT_HANDLE_AUTO_INCREMENT",1164));
 
197
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DELAYED_INSERT_TABLE_LOCKED",1165));
 
198
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_COLUMN_NAME",1166));
 
199
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_KEY_COLUMN",1167));
 
200
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_MRG_TABLE",1168));
 
201
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DUP_UNIQUE",1169));
 
202
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BLOB_KEY_WITHOUT_LENGTH",1170));
 
203
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PRIMARY_CANT_HAVE_NULL",1171));
 
204
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_MANY_ROWS",1172));
 
205
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_REQUIRES_PRIMARY_KEY",1173));
 
206
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_RAID_COMPILED",1174));
 
207
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE",1175));
 
208
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_KEY_DOES_NOT_EXITS",1176));
 
209
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CHECK_NO_SUCH_TABLE",1177));
 
210
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CHECK_NOT_IMPLEMENTED",1178));
 
211
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_DO_THIS_DURING_AN_TRANSACTION",1179));
 
212
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ERROR_DURING_COMMIT",1180));
 
213
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ERROR_DURING_ROLLBACK",1181));
 
214
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ERROR_DURING_FLUSH_LOGS",1182));
 
215
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ERROR_DURING_CHECKPOINT",1183));
 
216
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NEW_ABORTING_CONNECTION",1184));
 
217
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DUMP_NOT_IMPLEMENTED",1185));
 
218
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FLUSH_MASTER_BINLOG_CLOSED",1186));
 
219
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_INDEX_REBUILD",1187));
 
220
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MASTER",1188));
 
221
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MASTER_NET_READ",1189));
 
222
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MASTER_NET_WRITE",1190));
 
223
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FT_MATCHING_KEY_NOT_FOUND",1191));
 
224
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOCK_OR_ACTIVE_TRANSACTION",1192));
 
225
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_SYSTEM_VARIABLE",1193));
 
226
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CRASHED_ON_USAGE",1194));
 
227
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CRASHED_ON_REPAIR",1195));
 
228
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARNING_NOT_COMPLETE_ROLLBACK",1196));
 
229
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRANS_CACHE_FULL",1197));
 
230
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_MUST_STOP",1198));
 
231
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_NOT_RUNNING",1199));
 
232
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BAD_SLAVE",1200));
 
233
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MASTER_INFO",1201));
 
234
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_THREAD",1202));
 
235
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_MANY_USER_CONNECTIONS",1203));
 
236
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SET_CONSTANTS_ONLY",1204));
 
237
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOCK_WAIT_TIMEOUT",1205));
 
238
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOCK_TABLE_FULL",1206));
 
239
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_READ_ONLY_TRANSACTION",1207));
 
240
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DROP_DB_WITH_READ_LOCK",1208));
 
241
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CREATE_DB_WITH_READ_LOCK",1209));
 
242
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_ARGUMENTS",1210));
 
243
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_PERMISSION_TO_CREATE_USER",1211));
 
244
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNION_TABLES_IN_DIFFERENT_DIR",1212));
 
245
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOCK_DEADLOCK",1213));
 
246
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLE_CANT_HANDLE_FT",1214));
 
247
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANNOT_ADD_FOREIGN",1215));
 
248
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_REFERENCED_ROW",1216));
 
249
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ROW_IS_REFERENCED",1217));
 
250
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CONNECT_TO_MASTER",1218));
 
251
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_QUERY_ON_MASTER",1219));
 
252
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ERROR_WHEN_EXECUTING_COMMAND",1220));
 
253
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_USAGE",1221));
 
254
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT",1222));
 
255
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_UPDATE_WITH_READLOCK",1223));
 
256
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MIXING_NOT_ALLOWED",1224));
 
257
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DUP_ARGUMENT",1225));
 
258
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_USER_LIMIT_REACHED",1226));
 
259
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SPECIFIC_ACCESS_DENIED_ERROR",1227));
 
260
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOCAL_VARIABLE",1228));
 
261
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_GLOBAL_VARIABLE",1229));
 
262
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_DEFAULT",1230));
 
263
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_VALUE_FOR_VAR",1231));
 
264
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_TYPE_FOR_VAR",1232));
 
265
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VAR_CANT_BE_READ",1233));
 
266
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_USE_OPTION_HERE",1234));
 
267
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NOT_SUPPORTED_YET",1235));
 
268
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MASTER_FATAL_ERROR_READING_BINLOG",1236));
 
269
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_IGNORED_TABLE",1237));
 
270
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_INCORRECT_GLOBAL_LOCAL_VAR",1238));
 
271
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_FK_DEF",1239));
 
272
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_KEY_REF_DO_NOT_MATCH_TABLE_REF",1240));
 
273
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_OPERAND_COLUMNS",1241));
 
274
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SUBQUERY_NO_1_ROW",1242));
 
275
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_STMT_HANDLER",1243));
 
276
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CORRUPT_HELP_DB",1244));
 
277
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CYCLIC_REFERENCE",1245));
 
278
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_AUTO_CONVERT",1246));
 
279
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ILLEGAL_REFERENCE",1247));
 
280
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DERIVED_MUST_HAVE_ALIAS",1248));
 
281
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SELECT_REDUCED",1249));
 
282
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLENAME_NOT_ALLOWED_HERE",1250));
 
283
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NOT_SUPPORTED_AUTH_MODE",1251));
 
284
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SPATIAL_CANT_HAVE_NULL",1252));
 
285
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_COLLATION_CHARSET_MISMATCH",1253));
 
286
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_WAS_RUNNING",1254));
 
287
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_WAS_NOT_RUNNING",1255));
 
288
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_BIG_FOR_UNCOMPRESS",1256));
 
289
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ZLIB_Z_MEM_ERROR",1257));
 
290
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ZLIB_Z_BUF_ERROR",1258));
 
291
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ZLIB_Z_DATA_ERROR",1259));
 
292
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CUT_VALUE_GROUP_CONCAT",1260));
 
293
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_TOO_FEW_RECORDS",1261));
 
294
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_TOO_MANY_RECORDS",1262));
 
295
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_NULL_TO_NOTNULL",1263));
 
296
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_DATA_OUT_OF_RANGE",1264));
 
297
    error_code_map.insert(std::pair<std::string, uint32_t>("WARN_DATA_TRUNCATED",1265));
 
298
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_USING_OTHER_HANDLER",1266));
 
299
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_AGGREGATE_2COLLATIONS",1267));
 
300
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DROP_USER",1268));
 
301
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_REVOKE_GRANTS",1269));
 
302
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_AGGREGATE_3COLLATIONS",1270));
 
303
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_AGGREGATE_NCOLLATIONS",1271));
 
304
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VARIABLE_IS_NOT_STRUCT",1272));
 
305
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_COLLATION",1273));
 
306
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_IGNORED_SSL_PARAMS",1274));
 
307
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SERVER_IS_IN_SECURE_AUTH_MODE",1275));
 
308
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_FIELD_RESOLVED",1276));
 
309
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BAD_SLAVE_UNTIL_COND",1277));
 
310
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MISSING_SKIP_SLAVE",1278));
 
311
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNTIL_COND_IGNORED",1279));
 
312
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_NAME_FOR_INDEX",1280));
 
313
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_NAME_FOR_CATALOG",1281));
 
314
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_QC_RESIZE",1282));
 
315
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BAD_FT_COLUMN",1283));
 
316
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_KEY_CACHE",1284));
 
317
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_HOSTNAME_WONT_WORK",1285));
 
318
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_STORAGE_ENGINE",1286));
 
319
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_DEPRECATED_SYNTAX",1287));
 
320
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NON_UPDATABLE_TABLE",1288));
 
321
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FEATURE_DISABLED",1289));
 
322
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_OPTION_PREVENTS_STATEMENT",1290));
 
323
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DUPLICATED_VALUE_IN_TYPE",1291));
 
324
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRUNCATED_WRONG_VALUE",1292));
 
325
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_MUCH_AUTO_TIMESTAMP_COLS",1293));
 
326
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_INVALID_ON_UPDATE",1294));
 
327
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNSUPPORTED_PS",1295));
 
328
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_GET_ERRMSG",1296));
 
329
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_GET_TEMPORARY_ERRMSG",1297));
 
330
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_TIME_ZONE",1298));
 
331
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_INVALID_TIMESTAMP",1299));
 
332
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_INVALID_CHARACTER_STRING",1300));
 
333
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_ALLOWED_PACKET_OVERFLOWED",1301));
 
334
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CONFLICTING_DECLARATIONS",1302));
 
335
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_NO_RECURSIVE_CREATE",1303));
 
336
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_ALREADY_EXISTS",1304));
 
337
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_DOES_NOT_EXIST",1305));
 
338
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_DROP_FAILED",1306));
 
339
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_STORE_FAILED",1307));
 
340
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_LILABEL_MISMATCH",1308));
 
341
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_LABEL_REDEFINE",1309));
 
342
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_LABEL_MISMATCH",1310));
 
343
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_UNINIT_VAR",1311));
 
344
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_BADSELECT",1312));
 
345
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_BADRETURN",1313));
 
346
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_BADSTATEMENT",1314));
 
347
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UPDATE_LOG_DEPRECATED_IGNORED",1315));
 
348
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UPDATE_LOG_DEPRECATED_TRANSLATED",1316));
 
349
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_QUERY_INTERRUPTED",1317));
 
350
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_WRONG_NO_OF_ARGS",1318));
 
351
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_COND_MISMATCH",1319));
 
352
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_NORETURN",1320));
 
353
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_NORETURNEND",1321));
 
354
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_BAD_CURSOR_QUERY",1322));
 
355
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_BAD_CURSOR_SELECT",1323));
 
356
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_CURSOR_MISMATCH",1324));
 
357
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_CURSOR_ALREADY_OPEN",1325));
 
358
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_CURSOR_NOT_OPEN",1326));
 
359
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_UNDECLARED_VAR",1327));
 
360
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_WRONG_NO_OF_FETCH_ARGS",1328));
 
361
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_FETCH_NO_DATA",1329));
 
362
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_DUP_PARAM",1330));
 
363
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_DUP_VAR",1331));
 
364
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_DUP_COND",1332));
 
365
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_DUP_CURS",1333));
 
366
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_CANT_ALTER",1334));
 
367
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_SUBSELECT_NYI",1335));
 
368
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG",1336));
 
369
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_VARCOND_AFTER_CURSHNDLR",1337));
 
370
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_CURSOR_AFTER_HANDLER",1338));
 
371
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_CASE_NOT_FOUND",1339));
 
372
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FPARSER_TOO_BIG_FILE",1340));
 
373
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FPARSER_BAD_HEADER",1341));
 
374
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FPARSER_EOF_IN_COMMENT",1342));
 
375
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FPARSER_ERROR_IN_PARAMETER",1343));
 
376
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER",1344));
 
377
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_NO_EXPLAIN",1345));
 
378
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FRM_UNKNOWN_TYPE",1346));
 
379
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_OBJECT",1347));
 
380
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NONUPDATEABLE_COLUMN",1348));
 
381
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_SELECT_DERIVED",1349));
 
382
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_SELECT_CLAUSE",1350));
 
383
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_SELECT_VARIABLE",1351));
 
384
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_SELECT_TMPTABLE",1352));
 
385
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_WRONG_LIST",1353));
 
386
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_VIEW_MERGE",1354));
 
387
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_VIEW_WITHOUT_KEY",1355));
 
388
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_INVALID",1356));
 
389
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_NO_DROP_SP",1357));
 
390
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_GOTO_IN_HNDLR",1358));
 
391
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_ALREADY_EXISTS",1359));
 
392
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_DOES_NOT_EXIST",1360));
 
393
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_ON_VIEW_OR_TEMP_TABLE",1361));
 
394
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_CANT_CHANGE_ROW",1362));
 
395
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_NO_SUCH_ROW_IN_TRG",1363));
 
396
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_DEFAULT_FOR_FIELD",1364));
 
397
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DIVISION_BY_ZERO",1365));
 
398
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRUNCATED_WRONG_VALUE_FOR_FIELD",1366));
 
399
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ILLEGAL_VALUE_FOR_TYPE",1367));
 
400
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_NONUPD_CHECK",1368));
 
401
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_CHECK_FAILED",1369));
 
402
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PROCACCESS_DENIED_ERROR",1370));
 
403
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_RELAY_LOG_FAIL",1371));
 
404
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PASSWD_LENGTH",1372));
 
405
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNKNOWN_TARGET_BINLOG",1373));
 
406
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_IO_ERR_LOG_INDEX_READ",1374));
 
407
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BINLOG_PURGE_PROHIBITED",1375));
 
408
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FSEEK_FAIL",1376));
 
409
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BINLOG_PURGE_FATAL_ERR",1377));
 
410
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOG_IN_USE",1378));
 
411
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOG_PURGE_UNKNOWN_ERR",1379));
 
412
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_RELAY_LOG_INIT",1380));
 
413
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_BINARY_LOGGING",1381));
 
414
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_RESERVED_SYNTAX",1382));
 
415
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WSAS_FAILED",1383));
 
416
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DIFF_GROUPS_PROC",1384));
 
417
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_GROUP_FOR_PROC",1385));
 
418
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ORDER_WITH_PROC",1386));
 
419
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOGGING_PROHIBIT_CHANGING_OF",1387));
 
420
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_FILE_MAPPING",1388));
 
421
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_MAGIC",1389));
 
422
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PS_MANY_PARAM",1390));
 
423
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_KEY_PART_0",1391));
 
424
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_CHECKSUM",1392));
 
425
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_MULTIUPDATE",1393));
 
426
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_NO_INSERT_FIELD_LIST",1394));
 
427
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_DELETE_MERGE_VIEW",1395));
 
428
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANNOT_USER",1396));
 
429
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_XAER_NOTA",1397));
 
430
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_XAER_INVAL",1398));
 
431
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_XAER_RMFAIL",1399));
 
432
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_XAER_OUTSIDE",1400));
 
433
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_XAER_RMERR",1401));
 
434
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_XA_RBROLLBACK",1402));
 
435
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NONEXISTING_PROC_GRANT",1403));
 
436
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PROC_AUTO_GRANT_FAIL",1404));
 
437
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PROC_AUTO_REVOKE_FAIL",1405));
 
438
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DATA_TOO_LONG",1406));
 
439
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_BAD_SQLSTATE",1407));
 
440
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_STARTUP",1408));
 
441
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR",1409));
 
442
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_CREATE_USER_WITH_GRANT",1410));
 
443
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_VALUE_FOR_TYPE",1411));
 
444
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLE_DEF_CHANGED",1412));
 
445
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_DUP_HANDLER",1413));
 
446
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_NOT_VAR_ARG",1414));
 
447
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_NO_RETSET",1415));
 
448
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_CREATE_GEOMETRY_OBJECT",1416));
 
449
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FAILED_ROUTINE_BREAK_BINLOG",1417));
 
450
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BINLOG_UNSAFE_ROUTINE",1418));
 
451
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BINLOG_CREATE_ROUTINE_NEED_SUPER",1419));
 
452
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EXEC_STMT_WITH_OPEN_CURSOR",1420));
 
453
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_STMT_HAS_NO_OPEN_CURSOR",1421));
 
454
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG",1422));
 
455
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_DEFAULT_FOR_VIEW_FIELD",1423));
 
456
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_NO_RECURSION",1424));
 
457
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_BIG_SCALE",1425));
 
458
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_BIG_PRECISION",1426));
 
459
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_M_BIGGER_THAN_D",1427));
 
460
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_LOCK_OF_SYSTEM_TABLE",1428));
 
461
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CONNECT_TO_FOREIGN_DATA_SOURCE",1429));
 
462
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_QUERY_ON_FOREIGN_DATA_SOURCE",1430));
 
463
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST",1431));
 
464
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE",1432));
 
465
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FOREIGN_DATA_STRING_INVALID",1433));
 
466
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_CREATE_FEDERATED_TABLE",1434));
 
467
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_IN_WRONG_SCHEMA",1435));
 
468
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_STACK_OVERRUN_NEED_MORE",1436));
 
469
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_LONG_BODY",1437));
 
470
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_CANT_DROP_DEFAULT_KEYCACHE",1438));
 
471
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_BIG_DISPLAYWIDTH",1439));
 
472
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_XAER_DUPID",1440));
 
473
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DATETIME_FUNCTION_OVERFLOW",1441));
 
474
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG",1442));
 
475
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_PREVENT_UPDATE",1443));
 
476
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PS_NO_RECURSION",1444));
 
477
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_CANT_SET_AUTOCOMMIT",1445));
 
478
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MALFORMED_DEFINER",1446));
 
479
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_FRM_NO_USER",1447));
 
480
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_OTHER_USER",1448));
 
481
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_SUCH_USER",1449));
 
482
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FORBID_SCHEMA_CHANGE",1450));
 
483
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ROW_IS_REFERENCED_2",1451));
 
484
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_REFERENCED_ROW_2",1452));
 
485
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_BAD_VAR_SHADOW",1453));
 
486
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_NO_DEFINER",1454));
 
487
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_OLD_FILE_FORMAT",1455));
 
488
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_RECURSION_LIMIT",1456));
 
489
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_PROC_TABLE_CORRUPT",1457));
 
490
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_WRONG_NAME",1458));
 
491
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLE_NEEDS_UPGRADE",1459));
 
492
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SP_NO_AGGREGATE",1460));
 
493
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MAX_PREPARED_STMT_COUNT_REACHED",1461));
 
494
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_RECURSIVE",1462));
 
495
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NON_GROUPING_FIELD_USED",1463));
 
496
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLE_CANT_HANDLE_SPKEYS",1464));
 
497
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA",1465));
 
498
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_REMOVED_SPACES",1466));
 
499
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_AUTOINC_READ_FAILED",1467));
 
500
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_USERNAME",1468));
 
501
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_HOSTNAME",1469));
 
502
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_STRING_LENGTH",1470));
 
503
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NON_INSERTABLE_TABLE",1471));
 
504
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ADMIN_WRONG_MRG_TABLE",1472));
 
505
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT",1473));
 
506
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NAME_BECOMES_EMPTY",1474));
 
507
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_AMBIGUOUS_FIELD_TERM",1475));
 
508
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FOREIGN_SERVER_EXISTS",1476));
 
509
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FOREIGN_SERVER_DOESNT_EXIST",1477));
 
510
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ILLEGAL_HA_CREATE_OPTION",1478));
 
511
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_REQUIRES_VALUES_ERROR",1479));
 
512
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_WRONG_VALUES_ERROR",1480));
 
513
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_MAXVALUE_ERROR",1481));
 
514
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_SUBPARTITION_ERROR",1482));
 
515
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_SUBPART_MIX_ERROR",1483));
 
516
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_WRONG_NO_PART_ERROR",1484));
 
517
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_WRONG_NO_SUBPART_ERROR",1485));
 
518
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CONST_EXPR_IN_PARTITION_FUNC_ERROR",1486));
 
519
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_CONST_EXPR_IN_RANGE_OR_LIST_ERROR",1487));
 
520
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FIELD_NOT_FOUND_PART_ERROR",1488));
 
521
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR",1489));
 
522
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_INCONSISTENT_PARTITION_INFO_ERROR",1490));
 
523
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_FUNC_NOT_ALLOWED_ERROR",1491));
 
524
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITIONS_MUST_BE_DEFINED_ERROR",1492));
 
525
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_RANGE_NOT_INCREASING_ERROR",1493));
 
526
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR",1494));
 
527
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR",1495));
 
528
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_ENTRY_ERROR",1496));
 
529
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_MIX_HANDLER_ERROR",1497));
 
530
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_NOT_DEFINED_ERROR",1498));
 
531
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TOO_MANY_PARTITIONS_ERROR",1499));
 
532
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SUBPARTITION_ERROR",1500));
 
533
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_CREATE_HANDLER_FILE",1501));
 
534
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BLOB_FIELD_IN_PART_FUNC_ERROR",1502));
 
535
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF",1503));
 
536
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_PARTS_ERROR",1504));
 
537
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_MGMT_ON_NONPARTITIONED",1505));
 
538
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FOREIGN_KEY_ON_PARTITIONED",1506));
 
539
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DROP_PARTITION_NON_EXISTENT",1507));
 
540
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DROP_LAST_PARTITION",1508));
 
541
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_COALESCE_ONLY_ON_HASH_PARTITION",1509));
 
542
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_REORG_HASH_ONLY_ON_SAME_NO",1510));
 
543
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_REORG_NO_PARAM_ERROR",1511));
 
544
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ONLY_ON_RANGE_LIST_PARTITION",1512));
 
545
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ADD_PARTITION_SUBPART_ERROR",1513));
 
546
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ADD_PARTITION_NO_NEW_PARTITION",1514));
 
547
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_COALESCE_PARTITION_NO_PARTITION",1515));
 
548
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_REORG_PARTITION_NOT_EXIST",1516));
 
549
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SAME_NAME_PARTITION",1517));
 
550
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_BINLOG_ERROR",1518));
 
551
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CONSECUTIVE_REORG_PARTITIONS",1519));
 
552
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_REORG_OUTSIDE_RANGE",1520));
 
553
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_FUNCTION_FAILURE",1521));
 
554
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PART_STATE_ERROR",1522));
 
555
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LIMITED_PART_RANGE",1523));
 
556
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PLUGIN_IS_NOT_LOADED",1524));
 
557
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_VALUE",1525));
 
558
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_PARTITION_FOR_GIVEN_VALUE",1526));
 
559
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FILEGROUP_OPTION_ONLY_ONCE",1527));
 
560
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CREATE_FILEGROUP_FAILED",1528));
 
561
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DROP_FILEGROUP_FAILED",1529));
 
562
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLESPACE_AUTO_EXTEND_ERROR",1530));
 
563
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_SIZE_NUMBER",1531));
 
564
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SIZE_OVERFLOW_ERROR",1532));
 
565
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ALTER_FILEGROUP_FAILED",1533));
 
566
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BINLOG_ROW_LOGGING_FAILED",1534));
 
567
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BINLOG_ROW_WRONG_TABLE_DEF",1535));
 
568
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BINLOG_ROW_RBR_TO_SBR",1536));
 
569
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_ALREADY_EXISTS",1537));
 
570
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_STORE_FAILED",1538));
 
571
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_DOES_NOT_EXIST",1539));
 
572
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_CANT_ALTER",1540));
 
573
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_DROP_FAILED",1541));
 
574
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG",1542));
 
575
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_ENDS_BEFORE_STARTS",1543));
 
576
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_EXEC_TIME_IN_THE_PAST",1544));
 
577
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_OPEN_TABLE_FAILED",1545));
 
578
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_NEITHER_M_EXPR_NOR_M_AT",1546));
 
579
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_COL_COUNT_DOESNT_MATCH_CORRUPTED",1547));
 
580
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANNOT_LOAD_FROM_TABLE",1548));
 
581
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_CANNOT_DELETE",1549));
 
582
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_COMPILE_ERROR",1550));
 
583
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_SAME_NAME",1551));
 
584
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_DATA_TOO_LONG",1552));
 
585
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DROP_INDEX_FK",1553));
 
586
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_DEPRECATED_SYNTAX_WITH_VER",1554));
 
587
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_WRITE_LOCK_LOG_TABLE",1555));
 
588
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_LOCK_LOG_TABLE",1556));
 
589
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_FOREIGN_DUPLICATE_KEY",1557));
 
590
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE",1558));
 
591
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR",1559));
 
592
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT",1560));
 
593
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NDB_CANT_SWITCH_BINLOG_FORMAT",1561));
 
594
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_NO_TEMPORARY",1562));
 
595
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_CONST_DOMAIN_ERROR",1563));
 
596
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_FUNCTION_IS_NOT_ALLOWED",1564));
 
597
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DDL_LOG_ERROR",1565));
 
598
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NULL_IN_VALUES_LESS_THAN",1566));
 
599
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_PARTITION_NAME",1567));
 
600
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_CHANGE_TX_ISOLATION",1568));
 
601
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DUP_ENTRY_AUTOINCREMENT_CASE",1569));
 
602
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_MODIFY_QUEUE_ERROR",1570));
 
603
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_SET_VAR_ERROR",1571));
 
604
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PARTITION_MERGE_ERROR",1572));
 
605
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_ACTIVATE_LOG",1573));
 
606
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_RBR_NOT_AVAILABLE",1574));
 
607
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BASE64_DECODE_ERROR",1575));
 
608
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_RECURSION_FORBIDDEN",1576));
 
609
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENTS_DB_ERROR",1577));
 
610
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_ONLY_INTEGERS_ALLOWED",1578));
 
611
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNSUPORTED_LOG_ENGINE",1579));
 
612
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BAD_LOG_STATEMENT",1580));
 
613
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_RENAME_LOG_TABLE",1581));
 
614
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT",1582));
 
615
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_PARAMETERS_TO_NATIVE_FCT",1583));
 
616
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_PARAMETERS_TO_STORED_FCT",1584));
 
617
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NATIVE_FCT_NAME_COLLISION",1585));
 
618
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DUP_ENTRY_WITH_KEY_NAME",1586));
 
619
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BINLOG_PURGE_EMFILE",1587));
 
620
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_CANNOT_CREATE_IN_THE_PAST",1588));
 
621
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_CANNOT_ALTER_IN_THE_PAST",1589));
 
622
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_INCIDENT",1590));
 
623
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT",1591));
 
624
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BINLOG_UNSAFE_STATEMENT",1592));
 
625
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_FATAL_ERROR",1593));
 
626
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_RELAY_LOG_READ_FAILURE",1594));
 
627
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_RELAY_LOG_WRITE_FAILURE",1595));
 
628
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_CREATE_EVENT_FAILURE",1596));
 
629
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_MASTER_COM_FAILURE",1597));
 
630
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BINLOG_LOGGING_IMPOSSIBLE",1598));
 
631
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_NO_CREATION_CTX",1599));
 
632
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIEW_INVALID_CREATION_CTX",1600));
 
633
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SR_INVALID_CREATION_CTX",1601));
 
634
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_CORRUPTED_FILE",1602));
 
635
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_NO_CREATION_CTX",1603));
 
636
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_INVALID_CREATION_CTX",1604));
 
637
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_EVENT_INVALID_CREATION_CTX",1605));
 
638
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TRG_CANT_OPEN_TABLE",1606));
 
639
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CANT_CREATE_SROUTINE",1607));
 
640
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_AMBIGOUS_EXEC_MODE",1608));
 
641
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT",1609));
 
642
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_CORRUPT_EVENT",1610));
 
643
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOAD_DATA_INVALID_COLUMN",1611));
 
644
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_LOG_PURGE_NO_FILE",1612));
 
645
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARN_AUTO_CONVERT_LOCK",1613));
 
646
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_AUTO_CONVERT_LOCK_STRICT",1614));
 
647
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_AUTO_CONVERT_LOCK_TRANSACTION",1615));
 
648
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_STORAGE_ENGINE",1616));
 
649
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_BACKUP_START",1617));
 
650
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_BACKUP_DONE",1618));
 
651
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_RESTORE_START",1619));
 
652
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_RESTORE_DONE",1620));
 
653
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_NOTHING_TO_BACKUP",1621));
 
654
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_CANNOT_INCLUDE_DB",1622));
 
655
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_BACKUP",1623));
 
656
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_RESTORE",1624));
 
657
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_RUNNING",1625));
 
658
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_BACKUP_PREPARE",1626));
 
659
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_RESTORE_PREPARE",1627));
 
660
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_INVALID_LOC",1628));
 
661
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_READ_LOC",1629));
 
662
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_WRITE_LOC",1630));
 
663
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_LIST_DBS",1631));
 
664
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_LIST_TABLES",1632));
 
665
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_LIST_DB_TABLES",1633));
 
666
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_SKIP_VIEW",1634));
 
667
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_NO_ENGINE",1635));
 
668
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_TABLE_OPEN",1636));
 
669
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_READ_HEADER",1637));
 
670
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_WRITE_HEADER",1638));
 
671
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_NO_BACKUP_DRIVER",1639));
 
672
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_NOT_ACCEPTED",1640));
 
673
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_CREATE_BACKUP_DRIVER",1641));
 
674
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_CREATE_RESTORE_DRIVER",1642));
 
675
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_TOO_MANY_IMAGES",1643));
 
676
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_WRITE_META",1644));
 
677
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_READ_META",1645));
 
678
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_CREATE_META",1646));
 
679
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_GET_BUF",1647));
 
680
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_WRITE_DATA",1648));
 
681
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_READ_DATA",1649));
 
682
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_NEXT_CHUNK",1650));
 
683
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_INIT_BACKUP_DRIVER",1651));
 
684
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_INIT_RESTORE_DRIVER",1652));
 
685
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_STOP_BACKUP_DRIVER",1653));
 
686
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_STOP_RESTORE_DRIVERS",1654));
 
687
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_PREPARE_DRIVER",1655));
 
688
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_CREATE_VP",1656));
 
689
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_UNLOCK_DRIVER",1657));
 
690
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_CANCEL_BACKUP",1658));
 
691
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_CANCEL_RESTORE",1659));
 
692
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_GET_DATA",1660));
 
693
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_SEND_DATA",1661));
 
694
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_SEND_DATA_RETRY",1662));
 
695
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_OPEN_TABLES",1663));
 
696
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_THREAD_INIT",1664));
 
697
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_PROGRESS_TABLES",1665));
 
698
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLESPACE_EXIST",1666));
 
699
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_NO_SUCH_TABLESPACE",1667));
 
700
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_HEARTBEAT_FAILURE",1668));
 
701
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE",1669));
 
702
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_LOG_WRITE_ERROR",1670));
 
703
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_TABLESPACE_NOT_EMPTY",1671));
 
704
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_BACKUP_TS_CHANGE",1672));
 
705
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VCOL_BASED_ON_VCOL",1673));
 
706
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_VIRTUAL_COLUMN_FUNCTION_IS_NOT_ALLOWED",1674));
 
707
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_DATA_CONVERSION_ERROR_FOR_VIRTUAL_COLUMN",1675));
 
708
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_PRIMARY_KEY_BASED_ON_VIRTUAL_COLUMN",1676));
 
709
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_KEY_BASED_ON_GENERATED_VIRTUAL_COLUMN",1677));
 
710
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WRONG_FK_OPTION_FOR_VIRTUAL_COLUMN",1678));
 
711
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_WARNING_NON_DEFAULT_VALUE_FOR_VIRTUAL_COLUMN",1679));
 
712
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_UNSUPPORTED_ACTION_ON_VIRTUAL_COLUMN",1680));
 
713
    error_code_map.insert(std::pair<std::string, uint32_t>("ER_CONST_EXPR_IN_VCOL",1681));
 
714
  }
 
715
 
 
716
  /* This method does not compile as const. error: no match for 'operator[]' */
 
717
  uint32_t getErrorCode(const std::string &error_msg) /* const */
 
718
  {
 
719
    return error_code_map[error_msg];
 
720
  }
 
721
 
 
722
private:
 
723
  std::map<std::string, uint32_t> error_code_map;
 
724
};
 
725
 
 
726
ErrorCodes global_error_names;
 
727
 
 
728
#endif /* _client_errname_h */