0001: /*
0002: Copyright (C) 2002-2007 MySQL AB
0003:
0004: This program is free software; you can redistribute it and/or modify
0005: it under the terms of version 2 of the GNU General Public License as
0006: published by the Free Software Foundation.
0007:
0008: There are special exceptions to the terms and conditions of the GPL
0009: as it is applied to this software. View the full text of the
0010: exception in file EXCEPTIONS-CONNECTOR-J in the directory of this
0011: software distribution.
0012:
0013: This program is distributed in the hope that it will be useful,
0014: but WITHOUT ANY WARRANTY; without even the implied warranty of
0015: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
0016: GNU General Public License for more details.
0017:
0018: You should have received a copy of the GNU General Public License
0019: along with this program; if not, write to the Free Software
0020: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0021:
0022:
0023:
0024: */
0025: package com.mysql.jdbc;
0026:
0027: import java.lang.reflect.Constructor;
0028: import java.lang.reflect.Method;
0029: import java.net.BindException;
0030: import java.sql.DataTruncation;
0031: import java.sql.SQLException;
0032: import java.sql.SQLWarning;
0033:
0034: import java.util.HashMap;
0035: import java.util.Hashtable;
0036: import java.util.Iterator;
0037: import java.util.Map;
0038: import java.util.TreeMap;
0039:
0040: import com.mysql.jdbc.exceptions.MySQLDataException;
0041: import com.mysql.jdbc.exceptions.MySQLIntegrityConstraintViolationException;
0042: import com.mysql.jdbc.exceptions.MySQLNonTransientConnectionException;
0043: import com.mysql.jdbc.exceptions.MySQLSyntaxErrorException;
0044: import com.mysql.jdbc.exceptions.MySQLTransactionRollbackException;
0045: import com.mysql.jdbc.exceptions.MySQLTransientConnectionException;
0046:
0047: /**
0048: * SQLError is a utility class that maps MySQL error codes to X/Open error codes
0049: * as is required by the JDBC spec.
0050: *
0051: * @author Mark Matthews <mmatthew_at_worldserver.com>
0052: * @version $Id: SQLError.java 5122 2006-04-03 15:37:11 +0000 (Mon, 03 Apr 2006)
0053: * mmatthews $
0054: */
0055: public class SQLError {
0056: static final int ER_WARNING_NOT_COMPLETE_ROLLBACK = 1196;
0057:
0058: private static Map mysqlToSql99State;
0059:
0060: private static Map mysqlToSqlState;
0061:
0062: public static final String SQL_STATE_BASE_TABLE_NOT_FOUND = "S0002"; //$NON-NLS-1$
0063:
0064: public static final String SQL_STATE_BASE_TABLE_OR_VIEW_ALREADY_EXISTS = "S0001"; //$NON-NLS-1$
0065:
0066: public static final String SQL_STATE_BASE_TABLE_OR_VIEW_NOT_FOUND = "42S02"; //$NON-NLS-1$
0067:
0068: public static final String SQL_STATE_COLUMN_ALREADY_EXISTS = "S0021"; //$NON-NLS-1$
0069:
0070: public static final String SQL_STATE_COLUMN_NOT_FOUND = "S0022"; //$NON-NLS-1$
0071:
0072: public static final String SQL_STATE_COMMUNICATION_LINK_FAILURE = "08S01"; //$NON-NLS-1$
0073:
0074: public static final String SQL_STATE_CONNECTION_FAIL_DURING_TX = "08007"; //$NON-NLS-1$
0075:
0076: public static final String SQL_STATE_CONNECTION_IN_USE = "08002"; //$NON-NLS-1$
0077:
0078: public static final String SQL_STATE_CONNECTION_NOT_OPEN = "08003"; //$NON-NLS-1$
0079:
0080: public static final String SQL_STATE_CONNECTION_REJECTED = "08004"; //$NON-NLS-1$
0081:
0082: public static final String SQL_STATE_DATE_TRUNCATED = "01004"; //$NON-NLS-1$
0083:
0084: public static final String SQL_STATE_DATETIME_FIELD_OVERFLOW = "22008"; //$NON-NLS-1$
0085:
0086: public static final String SQL_STATE_DEADLOCK = "41000"; //$NON-NLS-1$
0087:
0088: public static final String SQL_STATE_DISCONNECT_ERROR = "01002"; //$NON-NLS-1$
0089:
0090: public static final String SQL_STATE_DIVISION_BY_ZERO = "22012"; //$NON-NLS-1$
0091:
0092: public static final String SQL_STATE_DRIVER_NOT_CAPABLE = "S1C00"; //$NON-NLS-1$
0093:
0094: public static final String SQL_STATE_ERROR_IN_ROW = "01S01"; //$NON-NLS-1$
0095:
0096: public static final String SQL_STATE_GENERAL_ERROR = "S1000"; //$NON-NLS-1$
0097:
0098: public static final String SQL_STATE_ILLEGAL_ARGUMENT = "S1009"; //$NON-NLS-1$
0099:
0100: public static final String SQL_STATE_INDEX_ALREADY_EXISTS = "S0011"; //$NON-NLS-1$
0101:
0102: public static final String SQL_STATE_INDEX_NOT_FOUND = "S0012"; //$NON-NLS-1$
0103:
0104: public static final String SQL_STATE_INSERT_VALUE_LIST_NO_MATCH_COL_LIST = "21S01"; //$NON-NLS-1$
0105:
0106: public static final String SQL_STATE_INVALID_AUTH_SPEC = "28000"; //$NON-NLS-1$
0107:
0108: public static final String SQL_STATE_INVALID_CHARACTER_VALUE_FOR_CAST = "22018"; // $NON_NLS-1$
0109:
0110: public static final String SQL_STATE_INVALID_COLUMN_NUMBER = "S1002"; //$NON-NLS-1$
0111:
0112: public static final String SQL_STATE_INVALID_CONNECTION_ATTRIBUTE = "01S00"; //$NON-NLS-1$
0113:
0114: public static final String SQL_STATE_MEMORY_ALLOCATION_FAILURE = "S1001"; //$NON-NLS-1$
0115:
0116: public static final String SQL_STATE_MORE_THAN_ONE_ROW_UPDATED_OR_DELETED = "01S04"; //$NON-NLS-1$
0117:
0118: public static final String SQL_STATE_NO_DEFAULT_FOR_COLUMN = "S0023"; //$NON-NLS-1$
0119:
0120: public static final String SQL_STATE_NO_ROWS_UPDATED_OR_DELETED = "01S03"; //$NON-NLS-1$
0121:
0122: public static final String SQL_STATE_NUMERIC_VALUE_OUT_OF_RANGE = "22003"; //$NON-NLS-1$
0123:
0124: public static final String SQL_STATE_PRIVILEGE_NOT_REVOKED = "01006"; //$NON-NLS-1$
0125:
0126: public static final String SQL_STATE_SYNTAX_ERROR = "42000"; //$NON-NLS-1$
0127:
0128: public static final String SQL_STATE_TIMEOUT_EXPIRED = "S1T00"; //$NON-NLS-1$
0129:
0130: public static final String SQL_STATE_TRANSACTION_RESOLUTION_UNKNOWN = "08007"; // $NON_NLS-1$
0131:
0132: public static final String SQL_STATE_UNABLE_TO_CONNECT_TO_DATASOURCE = "08001"; //$NON-NLS-1$
0133:
0134: public static final String SQL_STATE_WRONG_NO_OF_PARAMETERS = "07001"; //$NON-NLS-1$
0135:
0136: public static final String SQL_STATE_INVALID_TRANSACTION_TERMINATION = "2D000"; // $NON_NLS-1$
0137:
0138: private static Map sqlStateMessages;
0139:
0140: private static final long DEFAULT_WAIT_TIMEOUT_SECONDS = 28800;
0141:
0142: private static final int DUE_TO_TIMEOUT_FALSE = 0;
0143:
0144: private static final int DUE_TO_TIMEOUT_MAYBE = 2;
0145:
0146: private static final int DUE_TO_TIMEOUT_TRUE = 1;
0147:
0148: private static final Constructor JDBC_4_COMMUNICATIONS_EXCEPTION_CTOR;
0149:
0150: private static Method THROWABLE_INIT_CAUSE_METHOD;
0151:
0152: static {
0153: if (Util.isJdbc4()) {
0154: try {
0155: JDBC_4_COMMUNICATIONS_EXCEPTION_CTOR = Class
0156: .forName(
0157: "com.mysql.jdbc.exceptions.jdbc4.CommunicationsException")
0158: .getConstructor(
0159: new Class[] { ConnectionImpl.class,
0160: Long.TYPE, Exception.class });
0161: } catch (SecurityException e) {
0162: throw new RuntimeException(e);
0163: } catch (NoSuchMethodException e) {
0164: throw new RuntimeException(e);
0165: } catch (ClassNotFoundException e) {
0166: throw new RuntimeException(e);
0167: }
0168: } else {
0169: JDBC_4_COMMUNICATIONS_EXCEPTION_CTOR = null;
0170: }
0171:
0172: try {
0173: THROWABLE_INIT_CAUSE_METHOD = Throwable.class.getMethod(
0174: "initCause", new Class[] { Throwable.class });
0175: } catch (Throwable t) {
0176: // we're not on a VM that has it
0177: THROWABLE_INIT_CAUSE_METHOD = null;
0178: }
0179:
0180: sqlStateMessages = new HashMap();
0181: sqlStateMessages.put(SQL_STATE_DISCONNECT_ERROR, Messages
0182: .getString("SQLError.35")); //$NON-NLS-1$
0183: sqlStateMessages.put(SQL_STATE_DATE_TRUNCATED, Messages
0184: .getString("SQLError.36")); //$NON-NLS-1$
0185: sqlStateMessages.put(SQL_STATE_PRIVILEGE_NOT_REVOKED, Messages
0186: .getString("SQLError.37")); //$NON-NLS-1$
0187: sqlStateMessages.put(SQL_STATE_INVALID_CONNECTION_ATTRIBUTE,
0188: Messages.getString("SQLError.38")); //$NON-NLS-1$
0189: sqlStateMessages.put(SQL_STATE_ERROR_IN_ROW, Messages
0190: .getString("SQLError.39")); //$NON-NLS-1$
0191: sqlStateMessages.put(SQL_STATE_NO_ROWS_UPDATED_OR_DELETED,
0192: Messages.getString("SQLError.40")); //$NON-NLS-1$
0193: sqlStateMessages.put(
0194: SQL_STATE_MORE_THAN_ONE_ROW_UPDATED_OR_DELETED,
0195: Messages.getString("SQLError.41")); //$NON-NLS-1$
0196: sqlStateMessages.put(SQL_STATE_WRONG_NO_OF_PARAMETERS, Messages
0197: .getString("SQLError.42")); //$NON-NLS-1$
0198: sqlStateMessages.put(SQL_STATE_UNABLE_TO_CONNECT_TO_DATASOURCE,
0199: Messages.getString("SQLError.43")); //$NON-NLS-1$
0200: sqlStateMessages.put(SQL_STATE_CONNECTION_IN_USE, Messages
0201: .getString("SQLError.44")); //$NON-NLS-1$
0202: sqlStateMessages.put(SQL_STATE_CONNECTION_NOT_OPEN, Messages
0203: .getString("SQLError.45")); //$NON-NLS-1$
0204: sqlStateMessages.put(SQL_STATE_CONNECTION_REJECTED, Messages
0205: .getString("SQLError.46")); //$NON-NLS-1$
0206: sqlStateMessages.put(SQL_STATE_CONNECTION_FAIL_DURING_TX,
0207: Messages.getString("SQLError.47")); //$NON-NLS-1$
0208: sqlStateMessages.put(SQL_STATE_COMMUNICATION_LINK_FAILURE,
0209: Messages.getString("SQLError.48")); //$NON-NLS-1$
0210: sqlStateMessages.put(
0211: SQL_STATE_INSERT_VALUE_LIST_NO_MATCH_COL_LIST, Messages
0212: .getString("SQLError.49")); //$NON-NLS-1$
0213: sqlStateMessages.put(SQL_STATE_NUMERIC_VALUE_OUT_OF_RANGE,
0214: Messages.getString("SQLError.50")); //$NON-NLS-1$
0215: sqlStateMessages.put(SQL_STATE_DATETIME_FIELD_OVERFLOW,
0216: Messages.getString("SQLError.51")); //$NON-NLS-1$
0217: sqlStateMessages.put(SQL_STATE_DIVISION_BY_ZERO, Messages
0218: .getString("SQLError.52")); //$NON-NLS-1$
0219: sqlStateMessages.put(SQL_STATE_DEADLOCK, Messages
0220: .getString("SQLError.53")); //$NON-NLS-1$
0221: sqlStateMessages.put(SQL_STATE_INVALID_AUTH_SPEC, Messages
0222: .getString("SQLError.54")); //$NON-NLS-1$
0223: sqlStateMessages.put(SQL_STATE_SYNTAX_ERROR, Messages
0224: .getString("SQLError.55")); //$NON-NLS-1$
0225: sqlStateMessages.put(SQL_STATE_BASE_TABLE_OR_VIEW_NOT_FOUND,
0226: Messages.getString("SQLError.56")); //$NON-NLS-1$
0227: sqlStateMessages.put(
0228: SQL_STATE_BASE_TABLE_OR_VIEW_ALREADY_EXISTS, Messages
0229: .getString("SQLError.57")); //$NON-NLS-1$
0230: sqlStateMessages.put(SQL_STATE_BASE_TABLE_NOT_FOUND, Messages
0231: .getString("SQLError.58")); //$NON-NLS-1$
0232: sqlStateMessages.put(SQL_STATE_INDEX_ALREADY_EXISTS, Messages
0233: .getString("SQLError.59")); //$NON-NLS-1$
0234: sqlStateMessages.put(SQL_STATE_INDEX_NOT_FOUND, Messages
0235: .getString("SQLError.60")); //$NON-NLS-1$
0236: sqlStateMessages.put(SQL_STATE_COLUMN_ALREADY_EXISTS, Messages
0237: .getString("SQLError.61")); //$NON-NLS-1$
0238: sqlStateMessages.put(SQL_STATE_COLUMN_NOT_FOUND, Messages
0239: .getString("SQLError.62")); //$NON-NLS-1$
0240: sqlStateMessages.put(SQL_STATE_NO_DEFAULT_FOR_COLUMN, Messages
0241: .getString("SQLError.63")); //$NON-NLS-1$
0242: sqlStateMessages.put(SQL_STATE_GENERAL_ERROR, Messages
0243: .getString("SQLError.64")); //$NON-NLS-1$
0244: sqlStateMessages.put(SQL_STATE_MEMORY_ALLOCATION_FAILURE,
0245: Messages.getString("SQLError.65")); //$NON-NLS-1$
0246: sqlStateMessages.put(SQL_STATE_INVALID_COLUMN_NUMBER, Messages
0247: .getString("SQLError.66")); //$NON-NLS-1$
0248: sqlStateMessages.put(SQL_STATE_ILLEGAL_ARGUMENT, Messages
0249: .getString("SQLError.67")); //$NON-NLS-1$
0250: sqlStateMessages.put(SQL_STATE_DRIVER_NOT_CAPABLE, Messages
0251: .getString("SQLError.68")); //$NON-NLS-1$
0252: sqlStateMessages.put(SQL_STATE_TIMEOUT_EXPIRED, Messages
0253: .getString("SQLError.69")); //$NON-NLS-1$
0254:
0255: mysqlToSqlState = new Hashtable();
0256:
0257: //
0258: // Communications Errors
0259: //
0260: // ER_CON_COUNT_ERROR 1040
0261: // ER_BAD_HOST_ERROR 1042
0262: // ER_HANDSHAKE_ERROR 1043
0263: // ER_UNKNOWN_COM_ERROR 1047
0264: // ER_IPSOCK_ERROR 1081
0265: //
0266: mysqlToSqlState.put(Constants.integerValueOf(1040),
0267: SQL_STATE_CONNECTION_REJECTED);
0268: mysqlToSqlState.put(Constants.integerValueOf(1042),
0269: SQL_STATE_CONNECTION_REJECTED);
0270: mysqlToSqlState.put(Constants.integerValueOf(1043),
0271: SQL_STATE_CONNECTION_REJECTED);
0272: mysqlToSqlState.put(Constants.integerValueOf(1047),
0273: SQL_STATE_COMMUNICATION_LINK_FAILURE);
0274: mysqlToSqlState.put(Constants.integerValueOf(1081),
0275: SQL_STATE_COMMUNICATION_LINK_FAILURE);
0276:
0277: // ER_HOST_IS_BLOCKED 1129
0278: // ER_HOST_NOT_PRIVILEGED 1130
0279: mysqlToSqlState.put(Constants.integerValueOf(1129),
0280: SQL_STATE_CONNECTION_REJECTED);
0281: mysqlToSqlState.put(Constants.integerValueOf(1130),
0282: SQL_STATE_CONNECTION_REJECTED);
0283:
0284: //
0285: // Authentication Errors
0286: //
0287: // ER_ACCESS_DENIED_ERROR 1045
0288: //
0289: mysqlToSqlState.put(Constants.integerValueOf(1045),
0290: SQL_STATE_INVALID_AUTH_SPEC);
0291:
0292: //
0293: // Resource errors
0294: //
0295: // ER_CANT_CREATE_FILE 1004
0296: // ER_CANT_CREATE_TABLE 1005
0297: // ER_CANT_LOCK 1015
0298: // ER_DISK_FULL 1021
0299: // ER_CON_COUNT_ERROR 1040
0300: // ER_OUT_OF_RESOURCES 1041
0301: //
0302: // Out-of-memory errors
0303: //
0304: // ER_OUTOFMEMORY 1037
0305: // ER_OUT_OF_SORTMEMORY 1038
0306: //
0307: mysqlToSqlState.put(Constants.integerValueOf(1037),
0308: SQL_STATE_MEMORY_ALLOCATION_FAILURE);
0309: mysqlToSqlState.put(Constants.integerValueOf(1038),
0310: SQL_STATE_MEMORY_ALLOCATION_FAILURE);
0311:
0312: //
0313: // Syntax Errors
0314: //
0315: // ER_PARSE_ERROR 1064
0316: // ER_EMPTY_QUERY 1065
0317: //
0318: mysqlToSqlState.put(Constants.integerValueOf(1064),
0319: SQL_STATE_SYNTAX_ERROR);
0320: mysqlToSqlState.put(Constants.integerValueOf(1065),
0321: SQL_STATE_SYNTAX_ERROR);
0322:
0323: //
0324: // Invalid argument errors
0325: //
0326: // ER_WRONG_FIELD_WITH_GROUP 1055
0327: // ER_WRONG_GROUP_FIELD 1056
0328: // ER_WRONG_SUM_SELECT 1057
0329: // ER_TOO_LONG_IDENT 1059
0330: // ER_DUP_FIELDNAME 1060
0331: // ER_DUP_KEYNAME 1061
0332: // ER_DUP_ENTRY 1062
0333: // ER_WRONG_FIELD_SPEC 1063
0334: // ER_NONUNIQ_TABLE 1066
0335: // ER_INVALID_DEFAULT 1067
0336: // ER_MULTIPLE_PRI_KEY 1068
0337: // ER_TOO_MANY_KEYS 1069
0338: // ER_TOO_MANY_KEY_PARTS 1070
0339: // ER_TOO_LONG_KEY 1071
0340: // ER_KEY_COLUMN_DOES_NOT_EXIST 1072
0341: // ER_BLOB_USED_AS_KEY 1073
0342: // ER_TOO_BIG_FIELDLENGTH 1074
0343: // ER_WRONG_AUTO_KEY 1075
0344: // ER_NO_SUCH_INDEX 1082
0345: // ER_WRONG_FIELD_TERMINATORS 1083
0346: // ER_BLOBS_AND_NO_TERMINATED 1084
0347: //
0348: mysqlToSqlState.put(Constants.integerValueOf(1055),
0349: SQL_STATE_ILLEGAL_ARGUMENT);
0350: mysqlToSqlState.put(Constants.integerValueOf(1056),
0351: SQL_STATE_ILLEGAL_ARGUMENT);
0352: mysqlToSqlState.put(Constants.integerValueOf(1057),
0353: SQL_STATE_ILLEGAL_ARGUMENT);
0354: mysqlToSqlState.put(Constants.integerValueOf(1059),
0355: SQL_STATE_ILLEGAL_ARGUMENT);
0356: mysqlToSqlState.put(Constants.integerValueOf(1060),
0357: SQL_STATE_ILLEGAL_ARGUMENT);
0358: mysqlToSqlState.put(Constants.integerValueOf(1061),
0359: SQL_STATE_ILLEGAL_ARGUMENT);
0360: mysqlToSqlState.put(Constants.integerValueOf(1062),
0361: SQL_STATE_ILLEGAL_ARGUMENT);
0362: mysqlToSqlState.put(Constants.integerValueOf(1063),
0363: SQL_STATE_ILLEGAL_ARGUMENT);
0364: mysqlToSqlState.put(Constants.integerValueOf(1066),
0365: SQL_STATE_ILLEGAL_ARGUMENT);
0366: mysqlToSqlState.put(Constants.integerValueOf(1067),
0367: SQL_STATE_ILLEGAL_ARGUMENT);
0368: mysqlToSqlState.put(Constants.integerValueOf(1068),
0369: SQL_STATE_ILLEGAL_ARGUMENT);
0370: mysqlToSqlState.put(Constants.integerValueOf(1069),
0371: SQL_STATE_ILLEGAL_ARGUMENT);
0372: mysqlToSqlState.put(Constants.integerValueOf(1070),
0373: SQL_STATE_ILLEGAL_ARGUMENT);
0374: mysqlToSqlState.put(Constants.integerValueOf(1071),
0375: SQL_STATE_ILLEGAL_ARGUMENT);
0376: mysqlToSqlState.put(Constants.integerValueOf(1072),
0377: SQL_STATE_ILLEGAL_ARGUMENT);
0378: mysqlToSqlState.put(Constants.integerValueOf(1073),
0379: SQL_STATE_ILLEGAL_ARGUMENT);
0380: mysqlToSqlState.put(Constants.integerValueOf(1074),
0381: SQL_STATE_ILLEGAL_ARGUMENT);
0382: mysqlToSqlState.put(Constants.integerValueOf(1075),
0383: SQL_STATE_ILLEGAL_ARGUMENT);
0384: mysqlToSqlState.put(Constants.integerValueOf(1082),
0385: SQL_STATE_ILLEGAL_ARGUMENT);
0386: mysqlToSqlState.put(Constants.integerValueOf(1083),
0387: SQL_STATE_ILLEGAL_ARGUMENT);
0388: mysqlToSqlState.put(Constants.integerValueOf(1084),
0389: SQL_STATE_ILLEGAL_ARGUMENT);
0390:
0391: //
0392: // ER_WRONG_VALUE_COUNT 1058
0393: //
0394: mysqlToSqlState.put(Constants.integerValueOf(1058),
0395: SQL_STATE_INSERT_VALUE_LIST_NO_MATCH_COL_LIST);
0396:
0397: // ER_CANT_CREATE_DB 1006
0398: // ER_DB_CREATE_EXISTS 1007
0399: // ER_DB_DROP_EXISTS 1008
0400: // ER_DB_DROP_DELETE 1009
0401: // ER_DB_DROP_RMDIR 1010
0402: // ER_CANT_DELETE_FILE 1011
0403: // ER_CANT_FIND_SYSTEM_REC 1012
0404: // ER_CANT_GET_STAT 1013
0405: // ER_CANT_GET_WD 1014
0406: // ER_UNEXPECTED_EOF 1039
0407: // ER_CANT_OPEN_FILE 1016
0408: // ER_FILE_NOT_FOUND 1017
0409: // ER_CANT_READ_DIR 1018
0410: // ER_CANT_SET_WD 1019
0411: // ER_CHECKREAD 1020
0412: // ER_DUP_KEY 1022
0413: // ER_ERROR_ON_CLOSE 1023
0414: // ER_ERROR_ON_READ 1024
0415: // ER_ERROR_ON_RENAME 1025
0416: // ER_ERROR_ON_WRITE 1026
0417: // ER_FILE_USED 1027
0418: // ER_FILSORT_ABORT 1028
0419: // ER_FORM_NOT_FOUND 1029
0420: // ER_GET_ERRNO 1030
0421: // ER_ILLEGAL_HA 1031
0422: // ER_KEY_NOT_FOUND 1032
0423: // ER_NOT_FORM_FILE 1033
0424: // ER_DBACCESS_DENIED_ERROR 1044
0425: // ER_NO_DB_ERROR 1046
0426: // ER_BAD_NULL_ERROR 1048
0427: // ER_BAD_DB_ERROR 1049
0428: // ER_TABLE_EXISTS_ERROR 1050
0429: // ER_BAD_TABLE_ERROR 1051
0430: mysqlToSqlState.put(Constants.integerValueOf(1051),
0431: SQL_STATE_BASE_TABLE_OR_VIEW_NOT_FOUND);
0432:
0433: // ER_NON_UNIQ_ERROR 1052
0434: // ER_BAD_FIELD_ERROR 1054
0435: mysqlToSqlState.put(Constants.integerValueOf(1054),
0436: SQL_STATE_COLUMN_NOT_FOUND);
0437:
0438: // ER_TEXTFILE_NOT_READABLE 1085
0439: // ER_FILE_EXISTS_ERROR 1086
0440: // ER_LOAD_INFO 1087
0441: // ER_ALTER_INFO 1088
0442: // ER_WRONG_SUB_KEY 1089
0443: // ER_CANT_REMOVE_ALL_FIELDS 1090
0444: // ER_CANT_DROP_FIELD_OR_KEY 1091
0445: // ER_INSERT_INFO 1092
0446: // ER_INSERT_TABLE_USED 1093
0447: // ER_LOCK_DEADLOCK 1213
0448: mysqlToSqlState.put(Constants.integerValueOf(1205),
0449: SQL_STATE_DEADLOCK);
0450: mysqlToSqlState.put(Constants.integerValueOf(1213),
0451: SQL_STATE_DEADLOCK);
0452:
0453: mysqlToSql99State = new HashMap();
0454:
0455: mysqlToSql99State.put(Constants.integerValueOf(1205),
0456: SQL_STATE_DEADLOCK);
0457: mysqlToSql99State.put(Constants.integerValueOf(1213),
0458: SQL_STATE_DEADLOCK);
0459: mysqlToSql99State.put(Constants
0460: .integerValueOf(MysqlErrorNumbers.ER_DUP_KEY), "23000");
0461: mysqlToSql99State.put(Constants
0462: .integerValueOf(MysqlErrorNumbers.ER_OUTOFMEMORY),
0463: "HY001");
0464: mysqlToSql99State
0465: .put(
0466: Constants
0467: .integerValueOf(MysqlErrorNumbers.ER_OUT_OF_SORTMEMORY),
0468: "HY001");
0469: mysqlToSql99State.put(Constants
0470: .integerValueOf(MysqlErrorNumbers.ER_CON_COUNT_ERROR),
0471: "08004");
0472: mysqlToSql99State.put(Constants
0473: .integerValueOf(MysqlErrorNumbers.ER_BAD_HOST_ERROR),
0474: "08S01");
0475: mysqlToSql99State.put(Constants
0476: .integerValueOf(MysqlErrorNumbers.ER_HANDSHAKE_ERROR),
0477: "08S01");
0478: mysqlToSql99State
0479: .put(
0480: Constants
0481: .integerValueOf(MysqlErrorNumbers.ER_DBACCESS_DENIED_ERROR),
0482: "42000");
0483: mysqlToSql99State
0484: .put(
0485: Constants
0486: .integerValueOf(MysqlErrorNumbers.ER_ACCESS_DENIED_ERROR),
0487: "28000");
0488: mysqlToSql99State
0489: .put(
0490: Constants
0491: .integerValueOf(MysqlErrorNumbers.ER_TABLE_EXISTS_ERROR),
0492: "42S01");
0493: mysqlToSql99State.put(Constants
0494: .integerValueOf(MysqlErrorNumbers.ER_BAD_TABLE_ERROR),
0495: "42S02");
0496: mysqlToSql99State.put(Constants
0497: .integerValueOf(MysqlErrorNumbers.ER_NON_UNIQ_ERROR),
0498: "23000");
0499: mysqlToSql99State.put(Constants
0500: .integerValueOf(MysqlErrorNumbers.ER_SERVER_SHUTDOWN),
0501: "08S01");
0502: mysqlToSql99State.put(Constants
0503: .integerValueOf(MysqlErrorNumbers.ER_BAD_FIELD_ERROR),
0504: "42S22");
0505: mysqlToSql99State
0506: .put(
0507: Constants
0508: .integerValueOf(MysqlErrorNumbers.ER_WRONG_FIELD_WITH_GROUP),
0509: "42000");
0510: mysqlToSql99State
0511: .put(
0512: Constants
0513: .integerValueOf(MysqlErrorNumbers.ER_WRONG_GROUP_FIELD),
0514: "42000");
0515: mysqlToSql99State.put(Constants
0516: .integerValueOf(MysqlErrorNumbers.ER_WRONG_SUM_SELECT),
0517: "42000");
0518: mysqlToSql99State
0519: .put(
0520: Constants
0521: .integerValueOf(MysqlErrorNumbers.ER_WRONG_VALUE_COUNT),
0522: "21S01");
0523: mysqlToSql99State.put(Constants
0524: .integerValueOf(MysqlErrorNumbers.ER_TOO_LONG_IDENT),
0525: "42000");
0526: mysqlToSql99State.put(Constants
0527: .integerValueOf(MysqlErrorNumbers.ER_DUP_FIELDNAME),
0528: "42S21");
0529: mysqlToSql99State.put(Constants
0530: .integerValueOf(MysqlErrorNumbers.ER_DUP_KEYNAME),
0531: "42000");
0532: mysqlToSql99State.put(Constants
0533: .integerValueOf(MysqlErrorNumbers.ER_DUP_ENTRY),
0534: "23000");
0535: mysqlToSql99State.put(Constants
0536: .integerValueOf(MysqlErrorNumbers.ER_WRONG_FIELD_SPEC),
0537: "42000");
0538: mysqlToSql99State.put(Constants
0539: .integerValueOf(MysqlErrorNumbers.ER_PARSE_ERROR),
0540: "42000");
0541: mysqlToSql99State.put(Constants
0542: .integerValueOf(MysqlErrorNumbers.ER_EMPTY_QUERY),
0543: "42000");
0544: mysqlToSql99State.put(Constants
0545: .integerValueOf(MysqlErrorNumbers.ER_NONUNIQ_TABLE),
0546: "42000");
0547: mysqlToSql99State.put(Constants
0548: .integerValueOf(MysqlErrorNumbers.ER_INVALID_DEFAULT),
0549: "42000");
0550: mysqlToSql99State.put(Constants
0551: .integerValueOf(MysqlErrorNumbers.ER_MULTIPLE_PRI_KEY),
0552: "42000");
0553: mysqlToSql99State.put(Constants
0554: .integerValueOf(MysqlErrorNumbers.ER_TOO_MANY_KEYS),
0555: "42000");
0556: mysqlToSql99State
0557: .put(
0558: Constants
0559: .integerValueOf(MysqlErrorNumbers.ER_TOO_MANY_KEY_PARTS),
0560: "42000");
0561: mysqlToSql99State.put(Constants
0562: .integerValueOf(MysqlErrorNumbers.ER_TOO_LONG_KEY),
0563: "42000");
0564: mysqlToSql99State
0565: .put(
0566: Constants
0567: .integerValueOf(MysqlErrorNumbers.ER_KEY_COLUMN_DOES_NOT_EXITS),
0568: "42000");
0569: mysqlToSql99State.put(Constants
0570: .integerValueOf(MysqlErrorNumbers.ER_BLOB_USED_AS_KEY),
0571: "42000");
0572: mysqlToSql99State
0573: .put(
0574: Constants
0575: .integerValueOf(MysqlErrorNumbers.ER_TOO_BIG_FIELDLENGTH),
0576: "42000");
0577: mysqlToSql99State.put(Constants
0578: .integerValueOf(MysqlErrorNumbers.ER_WRONG_AUTO_KEY),
0579: "42000");
0580: mysqlToSql99State.put(Constants
0581: .integerValueOf(MysqlErrorNumbers.ER_FORCING_CLOSE),
0582: "08S01");
0583: mysqlToSql99State.put(Constants
0584: .integerValueOf(MysqlErrorNumbers.ER_IPSOCK_ERROR),
0585: "08S01");
0586: mysqlToSql99State.put(Constants
0587: .integerValueOf(MysqlErrorNumbers.ER_NO_SUCH_INDEX),
0588: "42S12");
0589: mysqlToSql99State
0590: .put(
0591: Constants
0592: .integerValueOf(MysqlErrorNumbers.ER_WRONG_FIELD_TERMINATORS),
0593: "42000");
0594: mysqlToSql99State
0595: .put(
0596: Constants
0597: .integerValueOf(MysqlErrorNumbers.ER_BLOBS_AND_NO_TERMINATED),
0598: "42000");
0599: mysqlToSql99State
0600: .put(
0601: Constants
0602: .integerValueOf(MysqlErrorNumbers.ER_CANT_REMOVE_ALL_FIELDS),
0603: "42000");
0604: mysqlToSql99State
0605: .put(
0606: Constants
0607: .integerValueOf(MysqlErrorNumbers.ER_CANT_DROP_FIELD_OR_KEY),
0608: "42000");
0609: mysqlToSql99State
0610: .put(
0611: Constants
0612: .integerValueOf(MysqlErrorNumbers.ER_BLOB_CANT_HAVE_DEFAULT),
0613: "42000");
0614: mysqlToSql99State.put(Constants
0615: .integerValueOf(MysqlErrorNumbers.ER_WRONG_DB_NAME),
0616: "42000");
0617: mysqlToSql99State.put(Constants
0618: .integerValueOf(MysqlErrorNumbers.ER_WRONG_TABLE_NAME),
0619: "42000");
0620: mysqlToSql99State.put(Constants
0621: .integerValueOf(MysqlErrorNumbers.ER_TOO_BIG_SELECT),
0622: "42000");
0623: mysqlToSql99State
0624: .put(
0625: Constants
0626: .integerValueOf(MysqlErrorNumbers.ER_UNKNOWN_PROCEDURE),
0627: "42000");
0628: mysqlToSql99State
0629: .put(
0630: Constants
0631: .integerValueOf(MysqlErrorNumbers.ER_WRONG_PARAMCOUNT_TO_PROCEDURE),
0632: "42000");
0633: mysqlToSql99State.put(Constants
0634: .integerValueOf(MysqlErrorNumbers.ER_UNKNOWN_TABLE),
0635: "42S02");
0636: mysqlToSql99State
0637: .put(
0638: Constants
0639: .integerValueOf(MysqlErrorNumbers.ER_FIELD_SPECIFIED_TWICE),
0640: "42000");
0641: mysqlToSql99State
0642: .put(
0643: Constants
0644: .integerValueOf(MysqlErrorNumbers.ER_UNSUPPORTED_EXTENSION),
0645: "42000");
0646: mysqlToSql99State
0647: .put(
0648: Constants
0649: .integerValueOf(MysqlErrorNumbers.ER_TABLE_MUST_HAVE_COLUMNS),
0650: "42000");
0651: mysqlToSql99State
0652: .put(
0653: Constants
0654: .integerValueOf(MysqlErrorNumbers.ER_UNKNOWN_CHARACTER_SET),
0655: "42000");
0656: mysqlToSql99State.put(Constants
0657: .integerValueOf(MysqlErrorNumbers.ER_TOO_BIG_ROWSIZE),
0658: "42000");
0659: mysqlToSql99State.put(Constants
0660: .integerValueOf(MysqlErrorNumbers.ER_WRONG_OUTER_JOIN),
0661: "42000");
0662: mysqlToSql99State
0663: .put(
0664: Constants
0665: .integerValueOf(MysqlErrorNumbers.ER_NULL_COLUMN_IN_INDEX),
0666: "42000");
0667: mysqlToSql99State
0668: .put(
0669: Constants
0670: .integerValueOf(MysqlErrorNumbers.ER_PASSWORD_ANONYMOUS_USER),
0671: "42000");
0672: mysqlToSql99State
0673: .put(
0674: Constants
0675: .integerValueOf(MysqlErrorNumbers.ER_PASSWORD_NOT_ALLOWED),
0676: "42000");
0677: mysqlToSql99State
0678: .put(
0679: Constants
0680: .integerValueOf(MysqlErrorNumbers.ER_PASSWORD_NO_MATCH),
0681: "42000");
0682: mysqlToSql99State
0683: .put(
0684: Constants
0685: .integerValueOf(MysqlErrorNumbers.ER_WRONG_VALUE_COUNT_ON_ROW),
0686: "21S01");
0687: mysqlToSql99State
0688: .put(
0689: Constants
0690: .integerValueOf(MysqlErrorNumbers.ER_INVALID_USE_OF_NULL),
0691: "42000");
0692: mysqlToSql99State.put(Constants
0693: .integerValueOf(MysqlErrorNumbers.ER_REGEXP_ERROR),
0694: "42000");
0695: mysqlToSql99State
0696: .put(
0697: Constants
0698: .integerValueOf(MysqlErrorNumbers.ER_MIX_OF_GROUP_FUNC_AND_FIELDS),
0699: "42000");
0700: mysqlToSql99State
0701: .put(
0702: Constants
0703: .integerValueOf(MysqlErrorNumbers.ER_NONEXISTING_GRANT),
0704: "42000");
0705: mysqlToSql99State
0706: .put(
0707: Constants
0708: .integerValueOf(MysqlErrorNumbers.ER_TABLEACCESS_DENIED_ERROR),
0709: "42000");
0710: mysqlToSql99State
0711: .put(
0712: Constants
0713: .integerValueOf(MysqlErrorNumbers.ER_COLUMNACCESS_DENIED_ERROR),
0714: "42000");
0715: mysqlToSql99State
0716: .put(
0717: Constants
0718: .integerValueOf(MysqlErrorNumbers.ER_ILLEGAL_GRANT_FOR_TABLE),
0719: "42000");
0720: mysqlToSql99State
0721: .put(
0722: Constants
0723: .integerValueOf(MysqlErrorNumbers.ER_GRANT_WRONG_HOST_OR_USER),
0724: "42000");
0725: mysqlToSql99State.put(Constants
0726: .integerValueOf(MysqlErrorNumbers.ER_NO_SUCH_TABLE),
0727: "42S02");
0728: mysqlToSql99State
0729: .put(
0730: Constants
0731: .integerValueOf(MysqlErrorNumbers.ER_NONEXISTING_TABLE_GRANT),
0732: "42000");
0733: mysqlToSql99State
0734: .put(
0735: Constants
0736: .integerValueOf(MysqlErrorNumbers.ER_NOT_ALLOWED_COMMAND),
0737: "42000");
0738: mysqlToSql99State.put(Constants
0739: .integerValueOf(MysqlErrorNumbers.ER_SYNTAX_ERROR),
0740: "42000");
0741: mysqlToSql99State
0742: .put(
0743: Constants
0744: .integerValueOf(MysqlErrorNumbers.ER_ABORTING_CONNECTION),
0745: "08S01");
0746: mysqlToSql99State
0747: .put(
0748: Constants
0749: .integerValueOf(MysqlErrorNumbers.ER_NET_PACKET_TOO_LARGE),
0750: "08S01");
0751: mysqlToSql99State
0752: .put(
0753: Constants
0754: .integerValueOf(MysqlErrorNumbers.ER_NET_READ_ERROR_FROM_PIPE),
0755: "08S01");
0756: mysqlToSql99State.put(Constants
0757: .integerValueOf(MysqlErrorNumbers.ER_NET_FCNTL_ERROR),
0758: "08S01");
0759: mysqlToSql99State
0760: .put(
0761: Constants
0762: .integerValueOf(MysqlErrorNumbers.ER_NET_PACKETS_OUT_OF_ORDER),
0763: "08S01");
0764: mysqlToSql99State
0765: .put(
0766: Constants
0767: .integerValueOf(MysqlErrorNumbers.ER_NET_UNCOMPRESS_ERROR),
0768: "08S01");
0769: mysqlToSql99State.put(Constants
0770: .integerValueOf(MysqlErrorNumbers.ER_NET_READ_ERROR),
0771: "08S01");
0772: mysqlToSql99State
0773: .put(
0774: Constants
0775: .integerValueOf(MysqlErrorNumbers.ER_NET_READ_INTERRUPTED),
0776: "08S01");
0777: mysqlToSql99State
0778: .put(
0779: Constants
0780: .integerValueOf(MysqlErrorNumbers.ER_NET_ERROR_ON_WRITE),
0781: "08S01");
0782: mysqlToSql99State
0783: .put(
0784: Constants
0785: .integerValueOf(MysqlErrorNumbers.ER_NET_WRITE_INTERRUPTED),
0786: "08S01");
0787: mysqlToSql99State.put(Constants
0788: .integerValueOf(MysqlErrorNumbers.ER_TOO_LONG_STRING),
0789: "42000");
0790: mysqlToSql99State
0791: .put(
0792: Constants
0793: .integerValueOf(MysqlErrorNumbers.ER_TABLE_CANT_HANDLE_BLOB),
0794: "42000");
0795: mysqlToSql99State
0796: .put(
0797: Constants
0798: .integerValueOf(MysqlErrorNumbers.ER_TABLE_CANT_HANDLE_AUTO_INCREMENT),
0799: "42000");
0800: mysqlToSql99State
0801: .put(
0802: Constants
0803: .integerValueOf(MysqlErrorNumbers.ER_WRONG_COLUMN_NAME),
0804: "42000");
0805: mysqlToSql99State.put(Constants
0806: .integerValueOf(MysqlErrorNumbers.ER_WRONG_KEY_COLUMN),
0807: "42000");
0808: mysqlToSql99State.put(Constants
0809: .integerValueOf(MysqlErrorNumbers.ER_DUP_UNIQUE),
0810: "23000");
0811: mysqlToSql99State
0812: .put(
0813: Constants
0814: .integerValueOf(MysqlErrorNumbers.ER_BLOB_KEY_WITHOUT_LENGTH),
0815: "42000");
0816: mysqlToSql99State
0817: .put(
0818: Constants
0819: .integerValueOf(MysqlErrorNumbers.ER_PRIMARY_CANT_HAVE_NULL),
0820: "42000");
0821: mysqlToSql99State.put(Constants
0822: .integerValueOf(MysqlErrorNumbers.ER_TOO_MANY_ROWS),
0823: "42000");
0824: mysqlToSql99State
0825: .put(
0826: Constants
0827: .integerValueOf(MysqlErrorNumbers.ER_REQUIRES_PRIMARY_KEY),
0828: "42000");
0829: mysqlToSql99State
0830: .put(
0831: Constants
0832: .integerValueOf(MysqlErrorNumbers.ER_CHECK_NO_SUCH_TABLE),
0833: "42000");
0834: mysqlToSql99State
0835: .put(
0836: Constants
0837: .integerValueOf(MysqlErrorNumbers.ER_CHECK_NOT_IMPLEMENTED),
0838: "42000");
0839: mysqlToSql99State
0840: .put(
0841: Constants
0842: .integerValueOf(MysqlErrorNumbers.ER_CANT_DO_THIS_DURING_AN_TRANSACTION),
0843: "25000");
0844: mysqlToSql99State
0845: .put(
0846: Constants
0847: .integerValueOf(MysqlErrorNumbers.ER_NEW_ABORTING_CONNECTION),
0848: "08S01");
0849: mysqlToSql99State.put(Constants
0850: .integerValueOf(MysqlErrorNumbers.ER_MASTER_NET_READ),
0851: "08S01");
0852: mysqlToSql99State.put(Constants
0853: .integerValueOf(MysqlErrorNumbers.ER_MASTER_NET_WRITE),
0854: "08S01");
0855: mysqlToSql99State
0856: .put(
0857: Constants
0858: .integerValueOf(MysqlErrorNumbers.ER_TOO_MANY_USER_CONNECTIONS),
0859: "42000");
0860: mysqlToSql99State
0861: .put(
0862: Constants
0863: .integerValueOf(MysqlErrorNumbers.ER_READ_ONLY_TRANSACTION),
0864: "25000");
0865: mysqlToSql99State
0866: .put(
0867: Constants
0868: .integerValueOf(MysqlErrorNumbers.ER_NO_PERMISSION_TO_CREATE_USER),
0869: "42000");
0870: mysqlToSql99State.put(Constants
0871: .integerValueOf(MysqlErrorNumbers.ER_LOCK_DEADLOCK),
0872: "40001");
0873: mysqlToSql99State
0874: .put(
0875: Constants
0876: .integerValueOf(MysqlErrorNumbers.ER_NO_REFERENCED_ROW),
0877: "23000");
0878: mysqlToSql99State
0879: .put(
0880: Constants
0881: .integerValueOf(MysqlErrorNumbers.ER_ROW_IS_REFERENCED),
0882: "23000");
0883: mysqlToSql99State
0884: .put(
0885: Constants
0886: .integerValueOf(MysqlErrorNumbers.ER_CONNECT_TO_MASTER),
0887: "08S01");
0888: mysqlToSql99State
0889: .put(
0890: Constants
0891: .integerValueOf(MysqlErrorNumbers.ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT),
0892: "21000");
0893: mysqlToSql99State
0894: .put(
0895: Constants
0896: .integerValueOf(MysqlErrorNumbers.ER_USER_LIMIT_REACHED),
0897: "42000");
0898: mysqlToSql99State.put(Constants
0899: .integerValueOf(MysqlErrorNumbers.ER_NO_DEFAULT),
0900: "42000");
0901: mysqlToSql99State
0902: .put(
0903: Constants
0904: .integerValueOf(MysqlErrorNumbers.ER_WRONG_VALUE_FOR_VAR),
0905: "42000");
0906: mysqlToSql99State
0907: .put(
0908: Constants
0909: .integerValueOf(MysqlErrorNumbers.ER_WRONG_TYPE_FOR_VAR),
0910: "42000");
0911: mysqlToSql99State
0912: .put(
0913: Constants
0914: .integerValueOf(MysqlErrorNumbers.ER_CANT_USE_OPTION_HERE),
0915: "42000");
0916: mysqlToSql99State
0917: .put(
0918: Constants
0919: .integerValueOf(MysqlErrorNumbers.ER_NOT_SUPPORTED_YET),
0920: "42000");
0921: mysqlToSql99State.put(Constants
0922: .integerValueOf(MysqlErrorNumbers.ER_WRONG_FK_DEF),
0923: "42000");
0924: mysqlToSql99State.put(Constants
0925: .integerValueOf(MysqlErrorNumbers.ER_OPERAND_COLUMNS),
0926: "21000");
0927: mysqlToSql99State
0928: .put(
0929: Constants
0930: .integerValueOf(MysqlErrorNumbers.ER_SUBQUERY_NO_1_ROW),
0931: "21000");
0932: mysqlToSql99State
0933: .put(
0934: Constants
0935: .integerValueOf(MysqlErrorNumbers.ER_ILLEGAL_REFERENCE),
0936: "42S22");
0937: mysqlToSql99State
0938: .put(
0939: Constants
0940: .integerValueOf(MysqlErrorNumbers.ER_DERIVED_MUST_HAVE_ALIAS),
0941: "42000");
0942: mysqlToSql99State.put(Constants
0943: .integerValueOf(MysqlErrorNumbers.ER_SELECT_REDUCED),
0944: "01000");
0945: mysqlToSql99State
0946: .put(
0947: Constants
0948: .integerValueOf(MysqlErrorNumbers.ER_TABLENAME_NOT_ALLOWED_HERE),
0949: "42000");
0950: mysqlToSql99State
0951: .put(
0952: Constants
0953: .integerValueOf(MysqlErrorNumbers.ER_NOT_SUPPORTED_AUTH_MODE),
0954: "08004");
0955: mysqlToSql99State
0956: .put(
0957: Constants
0958: .integerValueOf(MysqlErrorNumbers.ER_SPATIAL_CANT_HAVE_NULL),
0959: "42000");
0960: mysqlToSql99State
0961: .put(
0962: Constants
0963: .integerValueOf(MysqlErrorNumbers.ER_COLLATION_CHARSET_MISMATCH),
0964: "42000");
0965: mysqlToSql99State
0966: .put(
0967: Constants
0968: .integerValueOf(MysqlErrorNumbers.ER_WARN_TOO_FEW_RECORDS),
0969: "01000");
0970: mysqlToSql99State
0971: .put(
0972: Constants
0973: .integerValueOf(MysqlErrorNumbers.ER_WARN_TOO_MANY_RECORDS),
0974: "01000");
0975: mysqlToSql99State
0976: .put(
0977: Constants
0978: .integerValueOf(MysqlErrorNumbers.ER_WARN_NULL_TO_NOTNULL),
0979: "01000");
0980: mysqlToSql99State
0981: .put(
0982: Constants
0983: .integerValueOf(MysqlErrorNumbers.ER_WARN_DATA_OUT_OF_RANGE),
0984: "01000");
0985: mysqlToSql99State
0986: .put(
0987: Constants
0988: .integerValueOf(MysqlErrorNumbers.ER_WARN_DATA_TRUNCATED),
0989: "01000");
0990: mysqlToSql99State
0991: .put(
0992: Constants
0993: .integerValueOf(MysqlErrorNumbers.ER_WRONG_NAME_FOR_INDEX),
0994: "42000");
0995: mysqlToSql99State
0996: .put(
0997: Constants
0998: .integerValueOf(MysqlErrorNumbers.ER_WRONG_NAME_FOR_CATALOG),
0999: "42000");
1000: mysqlToSql99State
1001: .put(
1002: Constants
1003: .integerValueOf(MysqlErrorNumbers.ER_UNKNOWN_STORAGE_ENGINE),
1004: "42000");
1005: }
1006:
1007: /**
1008: * Turns output of 'SHOW WARNINGS' into JDBC SQLWarning instances.
1009: *
1010: * If 'forTruncationOnly' is true, only looks for truncation warnings, and
1011: * actually throws DataTruncation as an exception.
1012: *
1013: * @param connection
1014: * the connection to use for getting warnings.
1015: *
1016: * @return the SQLWarning chain (or null if no warnings)
1017: *
1018: * @throws SQLException
1019: * if the warnings could not be retrieved
1020: */
1021: static SQLWarning convertShowWarningsToSQLWarnings(
1022: Connection connection) throws SQLException {
1023: return convertShowWarningsToSQLWarnings(connection, 0, false);
1024: }
1025:
1026: /**
1027: * Turns output of 'SHOW WARNINGS' into JDBC SQLWarning instances.
1028: *
1029: * If 'forTruncationOnly' is true, only looks for truncation warnings, and
1030: * actually throws DataTruncation as an exception.
1031: *
1032: * @param connection
1033: * the connection to use for getting warnings.
1034: * @param warningCountIfKnown
1035: * the warning count (if known), otherwise set it to 0.
1036: * @param forTruncationOnly
1037: * if this method should only scan for data truncation warnings
1038: *
1039: * @return the SQLWarning chain (or null if no warnings)
1040: *
1041: * @throws SQLException
1042: * if the warnings could not be retrieved, or if data truncation
1043: * is being scanned for and truncations were found.
1044: */
1045: static SQLWarning convertShowWarningsToSQLWarnings(
1046: Connection connection, int warningCountIfKnown,
1047: boolean forTruncationOnly) throws SQLException {
1048: java.sql.Statement stmt = null;
1049: java.sql.ResultSet warnRs = null;
1050:
1051: SQLWarning currentWarning = null;
1052:
1053: try {
1054: if (warningCountIfKnown < 100) {
1055: stmt = connection.createStatement();
1056:
1057: if (stmt.getMaxRows() != 0) {
1058: stmt.setMaxRows(0);
1059: }
1060: } else {
1061: // stream large warning counts
1062: stmt = connection.createStatement(
1063: java.sql.ResultSet.TYPE_FORWARD_ONLY,
1064: java.sql.ResultSet.CONCUR_READ_ONLY);
1065: stmt.setFetchSize(Integer.MIN_VALUE);
1066: }
1067:
1068: /*
1069: * +---------+------+---------------------------------------------+ |
1070: * Level | Code | Message |
1071: * +---------+------+---------------------------------------------+ |
1072: * Warning | 1265 | Data truncated for column 'field1' at row 1 |
1073: * +---------+------+---------------------------------------------+
1074: */
1075: warnRs = stmt.executeQuery("SHOW WARNINGS"); //$NON-NLS-1$
1076:
1077: while (warnRs.next()) {
1078: int code = warnRs.getInt("Code"); //$NON-NLS-1$
1079:
1080: if (forTruncationOnly) {
1081: if (code == 1265 || code == 1264) {
1082: DataTruncation newTruncation = new MysqlDataTruncation(
1083: warnRs.getString("Message"), 0, false, false, 0, 0); //$NON-NLS-1$
1084:
1085: if (currentWarning == null) {
1086: currentWarning = newTruncation;
1087: } else {
1088: currentWarning
1089: .setNextWarning(newTruncation);
1090: }
1091: }
1092: } else {
1093: String level = warnRs.getString("Level"); //$NON-NLS-1$
1094: String message = warnRs.getString("Message"); //$NON-NLS-1$
1095:
1096: SQLWarning newWarning = new SQLWarning(message,
1097: SQLError.mysqlToSqlState(code, connection
1098: .getUseSqlStateCodes()), code);
1099:
1100: if (currentWarning == null) {
1101: currentWarning = newWarning;
1102: } else {
1103: currentWarning.setNextWarning(newWarning);
1104: }
1105: }
1106: }
1107:
1108: if (forTruncationOnly && (currentWarning != null)) {
1109: throw currentWarning;
1110: }
1111:
1112: return currentWarning;
1113: } finally {
1114: SQLException reThrow = null;
1115:
1116: if (warnRs != null) {
1117: try {
1118: warnRs.close();
1119: } catch (SQLException sqlEx) {
1120: reThrow = sqlEx;
1121: }
1122: }
1123:
1124: if (stmt != null) {
1125: try {
1126: stmt.close();
1127: } catch (SQLException sqlEx) {
1128: // ideally, we'd use chained exceptions here,
1129: // but we still support JDK-1.2.x with this driver
1130: // which doesn't have them....
1131: reThrow = sqlEx;
1132: }
1133: }
1134:
1135: if (reThrow != null) {
1136: throw reThrow;
1137: }
1138: }
1139: }
1140:
1141: public static void dumpSqlStatesMappingsAsXml() throws Exception {
1142: TreeMap allErrorNumbers = new TreeMap();
1143: Map mysqlErrorNumbersToNames = new HashMap();
1144:
1145: Integer errorNumber = null;
1146:
1147: //
1148: // First create a list of all 'known' error numbers that
1149: // are mapped.
1150: //
1151: for (Iterator mysqlErrorNumbers = mysqlToSql99State.keySet()
1152: .iterator(); mysqlErrorNumbers.hasNext();) {
1153: errorNumber = (Integer) mysqlErrorNumbers.next();
1154: allErrorNumbers.put(errorNumber, errorNumber);
1155: }
1156:
1157: for (Iterator mysqlErrorNumbers = mysqlToSqlState.keySet()
1158: .iterator(); mysqlErrorNumbers.hasNext();) {
1159: errorNumber = (Integer) mysqlErrorNumbers.next();
1160: allErrorNumbers.put(errorNumber, errorNumber);
1161: }
1162:
1163: //
1164: // Now create a list of the actual MySQL error numbers we know about
1165: //
1166: java.lang.reflect.Field[] possibleFields = MysqlErrorNumbers.class
1167: .getDeclaredFields();
1168:
1169: for (int i = 0; i < possibleFields.length; i++) {
1170: String fieldName = possibleFields[i].getName();
1171:
1172: if (fieldName.startsWith("ER_")) {
1173: mysqlErrorNumbersToNames.put(possibleFields[i]
1174: .get(null), fieldName);
1175: }
1176: }
1177:
1178: System.out.println("<ErrorMappings>");
1179:
1180: for (Iterator allErrorNumbersIter = allErrorNumbers.keySet()
1181: .iterator(); allErrorNumbersIter.hasNext();) {
1182: errorNumber = (Integer) allErrorNumbersIter.next();
1183:
1184: String sql92State = mysqlToSql99(errorNumber.intValue());
1185: String oldSqlState = mysqlToXOpen(errorNumber.intValue());
1186:
1187: System.out
1188: .println(" <ErrorMapping mysqlErrorNumber=\""
1189: + errorNumber
1190: + "\" mysqlErrorName=\""
1191: + mysqlErrorNumbersToNames.get(errorNumber)
1192: + "\" legacySqlState=\""
1193: + ((oldSqlState == null) ? "" : oldSqlState)
1194: + "\" sql92SqlState=\""
1195: + ((sql92State == null) ? "" : sql92State)
1196: + "\"/>");
1197: }
1198:
1199: System.out.println("</ErrorMappings>");
1200: }
1201:
1202: static String get(String stateCode) {
1203: return (String) sqlStateMessages.get(stateCode);
1204: }
1205:
1206: private static String mysqlToSql99(int errno) {
1207: Integer err = Constants.integerValueOf(errno);
1208:
1209: if (mysqlToSql99State.containsKey(err)) {
1210: return (String) mysqlToSql99State.get(err);
1211: }
1212:
1213: return "HY000";
1214: }
1215:
1216: /**
1217: * Map MySQL error codes to X/Open or SQL-92 error codes
1218: *
1219: * @param errno
1220: * the MySQL error code
1221: *
1222: * @return the corresponding X/Open or SQL-92 error code
1223: */
1224: static String mysqlToSqlState(int errno, boolean useSql92States) {
1225: if (useSql92States) {
1226: return mysqlToSql99(errno);
1227: }
1228:
1229: return mysqlToXOpen(errno);
1230: }
1231:
1232: private static String mysqlToXOpen(int errno) {
1233: Integer err = Constants.integerValueOf(errno);
1234:
1235: if (mysqlToSqlState.containsKey(err)) {
1236: return (String) mysqlToSqlState.get(err);
1237: }
1238:
1239: return SQL_STATE_GENERAL_ERROR;
1240: }
1241:
1242: /*
1243: * SQL State Class SQLNonTransientException Subclass 08
1244: * SQLNonTransientConnectionException 22 SQLDataException 23
1245: * SQLIntegrityConstraintViolationException N/A
1246: * SQLInvalidAuthorizationException 42 SQLSyntaxErrorException
1247: *
1248: * SQL State Class SQLTransientException Subclass 08
1249: * SQLTransientConnectionException 40 SQLTransactionRollbackException N/A
1250: * SQLTimeoutException
1251: */
1252:
1253: public static SQLException createSQLException(String message,
1254: String sqlState) {
1255: return createSQLException(message, sqlState, 0);
1256: }
1257:
1258: public static SQLException createSQLException(String message) {
1259: return new SQLException(message);
1260: }
1261:
1262: public static SQLException createSQLException(String message,
1263: String sqlState, Throwable cause) {
1264: if (THROWABLE_INIT_CAUSE_METHOD == null) {
1265: if (cause != null) {
1266: message = message + " due to " + cause.toString();
1267: }
1268: }
1269:
1270: SQLException sqlEx = createSQLException(message, sqlState);
1271:
1272: if (cause != null && THROWABLE_INIT_CAUSE_METHOD != null) {
1273: try {
1274: THROWABLE_INIT_CAUSE_METHOD.invoke(sqlEx,
1275: new Object[] { cause });
1276: } catch (Throwable t) {
1277: // we're not going to muck with that here, since it's
1278: // an error condition anyway!
1279: }
1280: }
1281:
1282: return sqlEx;
1283: }
1284:
1285: public static SQLException createSQLException(String message,
1286: String sqlState, int vendorErrorCode) {
1287: return createSQLException(message, sqlState, vendorErrorCode,
1288: false);
1289: }
1290:
1291: public static SQLException createSQLException(String message,
1292: String sqlState, int vendorErrorCode, boolean isTransient) {
1293: try {
1294: if (sqlState != null) {
1295: if (sqlState.startsWith("08")) {
1296: if (isTransient) {
1297: if (!Util.isJdbc4()) {
1298: return new MySQLTransientConnectionException(
1299: message, sqlState, vendorErrorCode);
1300: }
1301:
1302: return (SQLException) Util
1303: .getInstance(
1304: "com.mysql.jdbc.exceptions.jdbc4.MySQLTransientConnectionException",
1305: new Class[] { String.class,
1306: String.class,
1307: Integer.TYPE },
1308: new Object[] {
1309: message,
1310: sqlState,
1311: Constants
1312: .integerValueOf(vendorErrorCode) });
1313: }
1314:
1315: if (!Util.isJdbc4()) {
1316: return new MySQLNonTransientConnectionException(
1317: message, sqlState, vendorErrorCode);
1318: }
1319:
1320: return (SQLException) Util
1321: .getInstance(
1322: "com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException",
1323: new Class[] { String.class,
1324: String.class, Integer.TYPE },
1325: new Object[] {
1326: message,
1327: sqlState,
1328: Constants
1329: .integerValueOf(vendorErrorCode) });
1330: }
1331:
1332: if (sqlState.startsWith("22")) {
1333: if (!Util.isJdbc4()) {
1334: return new MySQLDataException(message,
1335: sqlState, vendorErrorCode);
1336: }
1337:
1338: return (SQLException) Util
1339: .getInstance(
1340: "com.mysql.jdbc.exceptions.jdbc4.MySQLDataException",
1341: new Class[] { String.class,
1342: String.class, Integer.TYPE },
1343: new Object[] {
1344: message,
1345: sqlState,
1346: Constants
1347: .integerValueOf(vendorErrorCode) });
1348: }
1349:
1350: if (sqlState.startsWith("23")) {
1351:
1352: if (!Util.isJdbc4()) {
1353: return new MySQLIntegrityConstraintViolationException(
1354: message, sqlState, vendorErrorCode);
1355: }
1356:
1357: return (SQLException) Util
1358: .getInstance(
1359: "com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException",
1360: new Class[] { String.class,
1361: String.class, Integer.TYPE },
1362: new Object[] {
1363: message,
1364: sqlState,
1365: Constants
1366: .integerValueOf(vendorErrorCode) });
1367: }
1368:
1369: if (sqlState.startsWith("42")) {
1370: if (!Util.isJdbc4()) {
1371: return new MySQLSyntaxErrorException(message,
1372: sqlState, vendorErrorCode);
1373: }
1374:
1375: return (SQLException) Util
1376: .getInstance(
1377: "com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException",
1378: new Class[] { String.class,
1379: String.class, Integer.TYPE },
1380: new Object[] {
1381: message,
1382: sqlState,
1383: Constants
1384: .integerValueOf(vendorErrorCode) });
1385: }
1386:
1387: if (sqlState.startsWith("40")) {
1388: if (!Util.isJdbc4()) {
1389: return new MySQLTransactionRollbackException(
1390: message, sqlState, vendorErrorCode);
1391: }
1392:
1393: return (SQLException) Util
1394: .getInstance(
1395: "com.mysql.jdbc.exceptions.jdbc4.MySQLTransactionRollbackException",
1396: new Class[] { String.class,
1397: String.class, Integer.TYPE },
1398: new Object[] {
1399: message,
1400: sqlState,
1401: Constants
1402: .integerValueOf(vendorErrorCode) });
1403: }
1404: }
1405:
1406: return new SQLException(message, sqlState, vendorErrorCode);
1407: } catch (SQLException sqlEx) {
1408: return new SQLException(
1409: "Unable to create correct SQLException class instance, error class/codes may be incorrect. Reason: "
1410: + Util.stackTraceToString(sqlEx),
1411: SQL_STATE_GENERAL_ERROR);
1412: }
1413: }
1414:
1415: public static SQLException createCommunicationsException(
1416: ConnectionImpl conn, long lastPacketSentTimeMs,
1417: Exception underlyingException) {
1418: SQLException exToReturn = null;
1419:
1420: if (!Util.isJdbc4()) {
1421: exToReturn = new CommunicationsException(conn,
1422: lastPacketSentTimeMs, underlyingException);
1423: } else {
1424:
1425: try {
1426: exToReturn = (SQLException) Util
1427: .handleNewInstance(
1428: JDBC_4_COMMUNICATIONS_EXCEPTION_CTOR,
1429: new Object[] {
1430: conn,
1431: Constants
1432: .longValueOf(lastPacketSentTimeMs),
1433: underlyingException });
1434: } catch (SQLException sqlEx) {
1435: // We should _never_ get this, but let's not swallow it either
1436:
1437: return sqlEx;
1438: }
1439: }
1440:
1441: if (THROWABLE_INIT_CAUSE_METHOD != null
1442: && underlyingException != null) {
1443: try {
1444: THROWABLE_INIT_CAUSE_METHOD.invoke(exToReturn,
1445: new Object[] { underlyingException });
1446: } catch (Throwable t) {
1447: // we're not going to muck with that here, since it's
1448: // an error condition anyway!
1449: }
1450: }
1451:
1452: return exToReturn;
1453: }
1454:
1455: /**
1456: * Creates a communications link failure message to be used
1457: * in CommunicationsException that (hopefully) has some better
1458: * information and suggestions based on heuristics.
1459: *
1460: * @param conn
1461: * @param lastPacketSentTimeMs
1462: * @param underlyingException
1463: * @param streamingResultSetInPlay
1464: * @return
1465: */
1466: public static String createLinkFailureMessageBasedOnHeuristics(
1467: ConnectionImpl conn, long lastPacketSentTimeMs,
1468: Exception underlyingException,
1469: boolean streamingResultSetInPlay) {
1470: long serverTimeoutSeconds = 0;
1471: boolean isInteractiveClient = false;
1472:
1473: if (conn != null) {
1474: isInteractiveClient = conn.getInteractiveClient();
1475:
1476: String serverTimeoutSecondsStr = null;
1477:
1478: if (isInteractiveClient) {
1479: serverTimeoutSecondsStr = conn
1480: .getServerVariable("interactive_timeout"); //$NON-NLS-1$
1481: } else {
1482: serverTimeoutSecondsStr = conn
1483: .getServerVariable("wait_timeout"); //$NON-NLS-1$
1484: }
1485:
1486: if (serverTimeoutSecondsStr != null) {
1487: try {
1488: serverTimeoutSeconds = Long
1489: .parseLong(serverTimeoutSecondsStr);
1490: } catch (NumberFormatException nfe) {
1491: serverTimeoutSeconds = 0;
1492: }
1493: }
1494: }
1495:
1496: StringBuffer exceptionMessageBuf = new StringBuffer();
1497:
1498: if (lastPacketSentTimeMs == 0) {
1499: lastPacketSentTimeMs = System.currentTimeMillis();
1500: }
1501:
1502: long timeSinceLastPacket = (System.currentTimeMillis() - lastPacketSentTimeMs) / 1000;
1503:
1504: int dueToTimeout = DUE_TO_TIMEOUT_FALSE;
1505:
1506: StringBuffer timeoutMessageBuf = null;
1507:
1508: if (streamingResultSetInPlay) {
1509: exceptionMessageBuf
1510: .append(Messages
1511: .getString("CommunicationsException.ClientWasStreaming")); //$NON-NLS-1$
1512: } else {
1513: if (serverTimeoutSeconds != 0) {
1514: if (timeSinceLastPacket > serverTimeoutSeconds) {
1515: dueToTimeout = DUE_TO_TIMEOUT_TRUE;
1516:
1517: timeoutMessageBuf = new StringBuffer();
1518:
1519: timeoutMessageBuf.append(Messages
1520: .getString("CommunicationsException.2")); //$NON-NLS-1$
1521:
1522: if (!isInteractiveClient) {
1523: timeoutMessageBuf
1524: .append(Messages
1525: .getString("CommunicationsException.3")); //$NON-NLS-1$
1526: } else {
1527: timeoutMessageBuf
1528: .append(Messages
1529: .getString("CommunicationsException.4")); //$NON-NLS-1$
1530: }
1531:
1532: }
1533: } else if (timeSinceLastPacket > DEFAULT_WAIT_TIMEOUT_SECONDS) {
1534: dueToTimeout = DUE_TO_TIMEOUT_MAYBE;
1535:
1536: timeoutMessageBuf = new StringBuffer();
1537:
1538: timeoutMessageBuf.append(Messages
1539: .getString("CommunicationsException.5")); //$NON-NLS-1$
1540: timeoutMessageBuf.append(Messages
1541: .getString("CommunicationsException.6")); //$NON-NLS-1$
1542: timeoutMessageBuf.append(Messages
1543: .getString("CommunicationsException.7")); //$NON-NLS-1$
1544: timeoutMessageBuf.append(Messages
1545: .getString("CommunicationsException.8")); //$NON-NLS-1$
1546: }
1547:
1548: if (dueToTimeout == DUE_TO_TIMEOUT_TRUE
1549: || dueToTimeout == DUE_TO_TIMEOUT_MAYBE) {
1550:
1551: exceptionMessageBuf.append(Messages
1552: .getString("CommunicationsException.9")); //$NON-NLS-1$
1553: exceptionMessageBuf.append(timeSinceLastPacket);
1554: exceptionMessageBuf.append(Messages
1555: .getString("CommunicationsException.10")); //$NON-NLS-1$
1556:
1557: if (timeoutMessageBuf != null) {
1558: exceptionMessageBuf.append(timeoutMessageBuf);
1559: }
1560:
1561: exceptionMessageBuf.append(Messages
1562: .getString("CommunicationsException.11")); //$NON-NLS-1$
1563: exceptionMessageBuf.append(Messages
1564: .getString("CommunicationsException.12")); //$NON-NLS-1$
1565: exceptionMessageBuf.append(Messages
1566: .getString("CommunicationsException.13")); //$NON-NLS-1$
1567:
1568: } else {
1569: //
1570: // Attempt to determine the reason for the underlying exception
1571: // (we can only make a best-guess here)
1572: //
1573:
1574: if (underlyingException instanceof BindException) {
1575: if (conn.getLocalSocketAddress() != null
1576: && !Util.interfaceExists(conn
1577: .getLocalSocketAddress())) {
1578: exceptionMessageBuf
1579: .append(Messages
1580: .getString("CommunicationsException.19a")); //$NON-NLS-1$
1581: } else {
1582: // too many client connections???
1583: exceptionMessageBuf
1584: .append(Messages
1585: .getString("CommunicationsException.14")); //$NON-NLS-1$
1586: exceptionMessageBuf
1587: .append(Messages
1588: .getString("CommunicationsException.15")); //$NON-NLS-1$
1589: exceptionMessageBuf
1590: .append(Messages
1591: .getString("CommunicationsException.16")); //$NON-NLS-1$
1592: exceptionMessageBuf
1593: .append(Messages
1594: .getString("CommunicationsException.17")); //$NON-NLS-1$
1595: exceptionMessageBuf
1596: .append(Messages
1597: .getString("CommunicationsException.18")); //$NON-NLS-1$
1598: exceptionMessageBuf
1599: .append(Messages
1600: .getString("CommunicationsException.19")); //$NON-NLS-1$
1601: }
1602: }
1603: }
1604: }
1605:
1606: if (exceptionMessageBuf.length() == 0) {
1607: // We haven't figured out a good reason, so copy it.
1608: exceptionMessageBuf.append(Messages
1609: .getString("CommunicationsException.20")); //$NON-NLS-1$
1610:
1611: if (THROWABLE_INIT_CAUSE_METHOD == null
1612: && underlyingException != null) {
1613: exceptionMessageBuf.append(Messages
1614: .getString("CommunicationsException.21")); //$NON-NLS-1$
1615: exceptionMessageBuf.append(Util
1616: .stackTraceToString(underlyingException));
1617: }
1618:
1619: if (conn != null && conn.getMaintainTimeStats()
1620: && !conn.getParanoid()) {
1621: exceptionMessageBuf
1622: .append("\n\nLast packet sent to the server was ");
1623: exceptionMessageBuf.append(System.currentTimeMillis()
1624: - lastPacketSentTimeMs);
1625: exceptionMessageBuf.append(" ms ago.");
1626: }
1627: }
1628:
1629: return exceptionMessageBuf.toString();
1630: }
1631: }
|