// Nullable?			if (nullabilityInfo != null) {				if (nullabilityInfo.equals("YES")) {					this.nullability = java.sql.DatabaseMetaData.columnNullable;					this.isNullable = "YES";					// IS_NULLABLE				} else {					this.nullability = java.sql.DatabaseMetaData.columnNoNulls;					this.isNullable = "NO";				}			} else {				this.nullability = java.sql.DatabaseMetaData.columnNoNulls;				this.isNullable = "NO";			}		}	}	private static String mysqlKeywordsThatArentSQL92;	private static final int DEFERRABILITY = 13;	private static final int DELETE_RULE = 10;	private static final int FK_NAME = 11;	private static final int FKCOLUMN_NAME = 7;	private static final int FKTABLE_CAT = 4;	private static final int FKTABLE_NAME = 6;	private static final int FKTABLE_SCHEM = 5;	private static final int KEY_SEQ = 8;	private static final int PK_NAME = 12;	private static final int PKCOLUMN_NAME = 3;	//	// Column indexes used by all DBMD foreign key	// ResultSets	//	private static final int PKTABLE_CAT = 0;	private static final int PKTABLE_NAME = 2;	private static final int PKTABLE_SCHEM = 1;	/** The table type for generic tables that support foreign keys. */	private static final String SUPPORTS_FK = "SUPPORTS_FK";	private static final byte[] TABLE_AS_BYTES = "TABLE".getBytes();	private static final int UPDATE_RULE = 9;	private static final byte[] VIEW_AS_BYTES = "VIEW".getBytes();	static {		// Current as-of MySQL-5.1.16		String[] allMySQLKeywords = new String[] { "ACCESSIBLE", "ADD", "ALL",				"ALTER", "ANALYZE", "AND", "AS", "ASC", "ASENSITIVE", "BEFORE",				"BETWEEN", "BIGINT", "BINARY", "BLOB", "BOTH", "BY", "CALL",				"CASCADE", "CASE", "CHANGE", "CHAR", "CHARACTER", "CHECK",				"COLLATE", "COLUMN", "CONDITION", "CONNECTION", "CONSTRAINT",				"CONTINUE", "CONVERT", "CREATE", "CROSS", "CURRENT_DATE",				"CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR",				"DATABASE", "DATABASES", "DAY_HOUR", "DAY_MICROSECOND",				"DAY_MINUTE", "DAY_SECOND", "DEC", "DECIMAL", "DECLARE",				"DEFAULT", "DELAYED", "DELETE", "DESC", "DESCRIBE",				"DETERMINISTIC", "DISTINCT", "DISTINCTROW", "DIV", "DOUBLE",				"DROP", "DUAL", "EACH", "ELSE", "ELSEIF", "ENCLOSED",				"ESCAPED", "EXISTS", "EXIT", "EXPLAIN", "FALSE", "FETCH",				"FLOAT", "FLOAT4", "FLOAT8", "FOR", "FORCE", "FOREIGN", "FROM",				"FULLTEXT", "GRANT", "GROUP", "HAVING", "HIGH_PRIORITY",				"HOUR_MICROSECOND", "HOUR_MINUTE", "HOUR_SECOND", "IF",				"IGNORE", "IN", "INDEX", "INFILE", "INNER", "INOUT",				"INSENSITIVE", "INSERT", "INT", "INT1", "INT2", "INT3", "INT4",				"INT8", "INTEGER", "INTERVAL", "INTO", "IS", "ITERATE", "JOIN",				"KEY", "KEYS", "KILL", "LEADING", "LEAVE", "LEFT", "LIKE",				"LIMIT", "LINEAR", "LINES", "LOAD", "LOCALTIME",				"LOCALTIMESTAMP", "LOCK", "LONG", "LONGBLOB", "LONGTEXT",				"LOOP", "LOW_PRIORITY", "MATCH", "MEDIUMBLOB", "MEDIUMINT",				"MEDIUMTEXT", "MIDDLEINT", "MINUTE_MICROSECOND",				"MINUTE_SECOND", "MOD", "MODIFIES", "NATURAL", "NOT",				"NO_WRITE_TO_BINLOG", "NULL", "NUMERIC", "ON", "OPTIMIZE",				"OPTION", "OPTIONALLY", "OR", "ORDER", "OUT", "OUTER",				"OUTFILE", "PRECISION", "PRIMARY", "PROCEDURE", "PURGE",				"RANGE", "READ", "READS", "READ_ONLY", "READ_WRITE", "REAL",				"REFERENCES", "REGEXP", "RELEASE", "RENAME", "REPEAT",				"REPLACE", "REQUIRE", "RESTRICT", "RETURN", "REVOKE", "RIGHT",				"RLIKE", "SCHEMA", "SCHEMAS", "SECOND_MICROSECOND", "SELECT",				"SENSITIVE", "SEPARATOR", "SET", "SHOW", "SMALLINT", "SPATIAL",				"SPECIFIC", "SQL", "SQLEXCEPTION", "SQLSTATE", "SQLWARNING",				"SQL_BIG_RESULT", "SQL_CALC_FOUND_ROWS", "SQL_SMALL_RESULT",				"SSL", "STARTING", "STRAIGHT_JOIN", "TABLE", "TERMINATED",				"THEN", "TINYBLOB", "TINYINT", "TINYTEXT", "TO", "TRAILING",				"TRIGGER", "TRUE", "UNDO", "UNION", "UNIQUE", "UNLOCK",				"UNSIGNED", "UPDATE", "USAGE", "USE", "USING", "UTC_DATE",				"UTC_TIME", "UTC_TIMESTAMP", "VALUES", "VARBINARY", "VARCHAR",				"VARCHARACTER", "VARYING", "WHEN", "WHERE", "WHILE", "WITH",				"WRITE", "X509", "XOR", "YEAR_MONTH", "ZEROFILL" };		String[] sql92Keywords = new String[] { "ABSOLUTE", "EXEC", "OVERLAPS",				"ACTION", "EXECUTE", "PAD", "ADA", "EXISTS", "PARTIAL", "ADD",				"EXTERNAL", "PASCAL", "ALL", "EXTRACT", "POSITION", "ALLOCATE",				"FALSE", "PRECISION", "ALTER", "FETCH", "PREPARE", "AND",				"FIRST", "PRESERVE", "ANY", "FLOAT", "PRIMARY", "ARE", "FOR",				"PRIOR", "AS", "FOREIGN", "PRIVILEGES", "ASC", "FORTRAN",				"PROCEDURE", "ASSERTION", "FOUND", "PUBLIC", "AT", "FROM",				"READ", "AUTHORIZATION", "FULL", "REAL", "AVG", "GET",				"REFERENCES", "BEGIN", "GLOBAL", "RELATIVE", "BETWEEN", "GO",				"RESTRICT", "BIT", "GOTO", "REVOKE", "BIT_LENGTH", "GRANT",				"RIGHT", "BOTH", "GROUP", "ROLLBACK", "BY", "HAVING", "ROWS",				"CASCADE", "HOUR", "SCHEMA", "CASCADED", "IDENTITY", "SCROLL",				"CASE", "IMMEDIATE", "SECOND", "CAST", "IN", "SECTION",				"CATALOG", "INCLUDE", "SELECT", "CHAR", "INDEX", "SESSION",				"CHAR_LENGTH", "INDICATOR", "SESSION_USER", "CHARACTER",				"INITIALLY", "SET", "CHARACTER_LENGTH", "INNER", "SIZE",				"CHECK", "INPUT", "SMALLINT", "CLOSE", "INSENSITIVE", "SOME",				"COALESCE", "INSERT", "SPACE", "COLLATE", "INT", "SQL",				"COLLATION", "INTEGER", "SQLCA", "COLUMN", "INTERSECT",				"SQLCODE", "COMMIT", "INTERVAL", "SQLERROR", "CONNECT", "INTO",				"SQLSTATE", "CONNECTION", "IS", "SQLWARNING", "CONSTRAINT",				"ISOLATION", "SUBSTRING", "CONSTRAINTS", "JOIN", "SUM",				"CONTINUE", "KEY", "SYSTEM_USER", "CONVERT", "LANGUAGE",				"TABLE", "CORRESPONDING", "LAST", "TEMPORARY", "COUNT",				"LEADING", "THEN", "CREATE", "LEFT", "TIME", "CROSS", "LEVEL",				"TIMESTAMP", "CURRENT", "LIKE", "TIMEZONE_HOUR",				"CURRENT_DATE", "LOCAL", "TIMEZONE_MINUTE", "CURRENT_TIME",				"LOWER", "TO", "CURRENT_TIMESTAMP", "MATCH", "TRAILING",				"CURRENT_USER", "MAX", "TRANSACTION", "CURSOR", "MIN",				"TRANSLATE", "DATE", "MINUTE", "TRANSLATION", "DAY", "MODULE",				"TRIM", "DEALLOCATE", "MONTH", "TRUE", "DEC", "NAMES", "UNION",				"DECIMAL", "NATIONAL", "UNIQUE", "DECLARE", "NATURAL",				"UNKNOWN", "DEFAULT", "NCHAR", "UPDATE", "DEFERRABLE", "NEXT",				"UPPER", "DEFERRED", "NO", "USAGE", "DELETE", "NONE", "USER",				"DESC", "NOT", "USING", "DESCRIBE", "NULL", "VALUE",				"DESCRIPTOR", "NULLIF", "VALUES", "DIAGNOSTICS", "NUMERIC",				"VARCHAR", "DISCONNECT", "OCTET_LENGTH", "VARYING", "DISTINCT",				"OF", "VIEW", "DOMAIN", "ON", "WHEN", "DOUBLE", "ONLY",				"WHENEVER", "DROP", "OPEN", "WHERE", "ELSE", "OPTION", "WITH",				"END", "OR", "WORK", "END-EXEC", "ORDER", "WRITE", "ESCAPE",				"OUTER", "YEAR", "EXCEPT", "OUTPUT", "ZONE", "EXCEPTION" };				TreeMap mySQLKeywordMap = new TreeMap();				for (int i = 0; i < allMySQLKeywords.length; i++) {			mySQLKeywordMap.put(allMySQLKeywords[i], null);		}				HashMap sql92KeywordMap = new HashMap(sql92Keywords.length);				for (int i = 0; i < sql92Keywords.length; i++) {			sql92KeywordMap.put(sql92Keywords[i], null);		}				Iterator it = sql92KeywordMap.keySet().iterator();				while (it.hasNext()) {			mySQLKeywordMap.remove(it.next());		}				StringBuffer keywordBuf = new StringBuffer();				it = mySQLKeywordMap.keySet().iterator();				if (it.hasNext()) {			keywordBuf.append(it.next().toString());		}				while (it.hasNext()) {			keywordBuf.append(",");			keywordBuf.append(it.next().toString());		}			mysqlKeywordsThatArentSQL92 = keywordBuf.toString();	}	static java.sql.ResultSet buildResultSet(com.mysql.jdbc.Field[] fields,			java.util.ArrayList rows, Connection c) throws SQLException {		int fieldsLength = fields.length;		for (int i = 0; i < fieldsLength; i++) {			fields[i].setConnection(c);			fields[i].setUseOldNameMetadata(true);		}		return new com.mysql.jdbc.ResultSet(c.getCatalog(), fields,				new RowDataStatic(rows), c, null);	}	/** The connection to the database */	protected Connection conn;	/** The 'current' database name being used */	protected String database = null;	/** What character to use when quoting identifiers */	protected String quotedId = null;	/**	 * Creates a new DatabaseMetaData object.	 * 	 * @param connToSet	 *            DOCUMENT ME!	 * @param databaseToSet	 *            DOCUMENT ME!	 */	public DatabaseMetaData(Connection connToSet, String databaseToSet) {		this.conn = connToSet;		this.database = databaseToSet;		try {			this.quotedId = this.conn.supportsQuotedIdentifiers() ? getIdentifierQuoteString()					: "";		} catch (SQLException sqlEx) {			// Forced by API, never thrown from getIdentifierQuoteString() in			// this			// implementation.			AssertionFailedException.shouldNotHappen(sqlEx);		}	}	/**	 * Can all the procedures returned by getProcedures be called by the current	 * user?	 * 	 * @return true if so	 * @throws SQLException	 *             DOCUMENT ME!	 */	public boolean allProceduresAreCallable() throws SQLException {		return false;	}	/**	 * Can all the tables returned by getTable be SELECTed by the current user?	 * 	 * @return true if so	 * @throws SQLException	 *             DOCUMENT ME!	 */	public boolean allTablesAreSelectable() throws SQLException {		return false;	}	private java.sql.ResultSet buildResultSet(com.mysql.jdbc.Field[] fields,			java.util.ArrayList rows) throws SQLException {		return buildResultSet(fields, rows, this.conn);	}	private void convertToJdbcFunctionList(String catalog,			ResultSet proceduresRs, boolean needsClientFiltering, String db,			Map procedureRowsOrderedByName, int nameIndex) throws SQLException {		while (proceduresRs.next()) {			boolean shouldAdd = true;			if (needsClientFiltering) {				shouldAdd = false;				String procDb = proceduresRs.getString(1);				if (db == null && procDb == null) {					shouldAdd = true;				} else if (db != null && db.equals(procDb)) {					shouldAdd = true;				}			}			if (shouldAdd) {				String functionName = proceduresRs.getString(nameIndex);				byte[][] rowData = new byte[8][];				rowData[0] = catalog == null ? null : s2b(catalog);				rowData[1] = null;				rowData[2] = s2b(functionName);				rowData[3] = null;				rowData[4] = null;				rowData[5] = null;				rowData[6] = null;				rowData[7] = s2b(Integer.toString(procedureReturnsResult));				procedureRowsOrderedByName.put(functionName, rowData);			}		}	}	private void convertToJdbcProcedureList(boolean fromSelect, String catalog,			ResultSet proceduresRs, boolean needsClientFiltering, String db,			Map procedureRowsOrderedByName, int nameIndex) throws SQLException {		while (proceduresRs.next()) {			boolean shouldAdd = true;			if (needsClientFiltering) {				shouldAdd = false;				String procDb = proceduresRs.getString(1);				if (db == null && procDb == null) {					shouldAdd = true;				} else if (db != null && db.equals(procDb)) {					shouldAdd = true;				}			}			if (shouldAdd) {				String procedureName = proceduresRs.getString(nameIndex);				byte[][] rowData = new byte[8][];				rowData[0] = catalog == null ? null : s2b(catalog);				rowData[1] = null;				rowData[2] = s2b(procedureName);				rowData[3] = null;				rowData[4] = null;				rowData[5] = null;				rowData[6] = null;				boolean isFunction = fromSelect ? "FUNCTION"						.equalsIgnoreCase(proceduresRs.getString("type"))						: false;				rowData[7] = s2b(isFunction ? Integer						.toString(procedureReturnsResult) : Integer						.toString(procedureResultUnknown));				procedureRowsOrderedByName.put(procedureName, rowData);			}		}	}	private byte[][] convertTypeDescriptorToProcedureRow(			byte[] procNameAsBytes, String paramName, boolean isOutParam,			boolean isInParam, boolean isReturnParam, TypeDescriptor typeDesc)			throws SQLException {		byte[][] row = new byte[14][];		row[0] = null; // PROCEDURE_CAT		row[1] = null; // PROCEDURE_SCHEM		row[2] = procNameAsBytes; // PROCEDURE/NAME		row[3] = s2b(paramName); // COLUMN_NAME		// COLUMN_TYPE		if (isInParam && isOutParam) {			row[4] = s2b(String.valueOf(procedureColumnInOut));		} else if (isInParam) {			row[4] = s2b(String.valueOf(procedureColumnIn));		} else if (isOutParam) {			row[4] = s2b(String.valueOf(procedureColumnOut));		} else if (isReturnParam) {			row[4] = s2b(String.valueOf(procedureColumnReturn));		} else {			row[4] = s2b(String.valueOf(procedureColumnUnknown));		}		row[5] = s2b(Short.toString(typeDesc.dataType)); // DATA_TYPE		row[6] = s2b(typeDesc.typeName); // TYPE_NAME		row[7] = typeDesc.columnSize == null ? null : s2b(typeDesc.columnSize				.toString()); // PRECISION		row[8] = s2b(Integer.toString(typeDesc.bufferLength)); // LENGTH		row[9] = typeDesc.decimalDigits == null ? null				: s2b(typeDesc.decimalDigits.toString()); // SCALE		row[10] = s2b(Integer.toString(typeDesc.numPrecRadix)); // RADIX		// Map 'column****' to 'procedure****'		switch (typeDesc.nullability) {		case columnNoNulls:			row[11] = s2b(Integer.toString(procedureNoNulls)); // NULLABLE			break;		case columnNullable:			row[11] = s2b(Integer.toString(procedureNullable)); // NULLABLE			break;		case columnNullableUnknown:			row[11] = s2b(Integer.toString(procedureNullableUnknown)); // nullable			break;		default:			throw SQLError					.createSQLException(							"Internal error while parsing callable statement metadata (unknown nullability value fount)",							SQLError.SQL_STATE_GENERAL_ERROR);		}		row[12] = null;		return row;	}	/**	 * Does a data definition statement within a transaction force the	 * transaction to commit?	 * 	 * @return true if so	 * @throws SQLException	 *             DOCUMENT ME!	 */	public boolean dataDefinitionCausesTransactionCommit() throws SQLException {		return true;	}	/**	 * Is a data definition statement within a transaction ignored?	 * 	 * @return true if so	 * @throws SQLException	 *             DOCUMENT ME!	 */	public boolean dataDefinitionIgnoredInTransactions() throws SQLException {		return false;	}	/**	 * JDBC 2.0 Determine whether or not a visible row delete can be detected by	 * calling ResultSet.rowDeleted(). If deletesAreDetected() returns false,	 * then deleted rows are removed from the result set.	 * 	 * @param type	 *            set type, i.e. ResultSet.TYPE_XXX