fields[3] = new Field("", "ATTR_NAME", Types.CHAR, 32);		fields[4] = new Field("", "DATA_TYPE", Types.SMALLINT, 32);		fields[5] = new Field("", "ATTR_TYPE_NAME", Types.CHAR, 32);		fields[6] = new Field("", "ATTR_SIZE", Types.INTEGER, 32);		fields[7] = new Field("", "DECIMAL_DIGITS", Types.INTEGER, 32);		fields[8] = new Field("", "NUM_PREC_RADIX", Types.INTEGER, 32);		fields[9] = new Field("", "NULLABLE ", Types.INTEGER, 32);		fields[10] = new Field("", "REMARKS", Types.CHAR, 32);		fields[11] = new Field("", "ATTR_DEF", Types.CHAR, 32);		fields[12] = new Field("", "SQL_DATA_TYPE", Types.INTEGER, 32);		fields[13] = new Field("", "SQL_DATETIME_SUB", Types.INTEGER, 32);		fields[14] = new Field("", "CHAR_OCTET_LENGTH", Types.INTEGER, 32);		fields[15] = new Field("", "ORDINAL_POSITION", Types.INTEGER, 32);		fields[16] = new Field("", "IS_NULLABLE", Types.CHAR, 32);		fields[17] = new Field("", "SCOPE_CATALOG", Types.CHAR, 32);		fields[18] = new Field("", "SCOPE_SCHEMA", Types.CHAR, 32);		fields[19] = new Field("", "SCOPE_TABLE", Types.CHAR, 32);		fields[20] = new Field("", "SOURCE_DATA_TYPE", Types.SMALLINT, 32);		return buildResultSet(fields, new ArrayList());	}	/**	 * Get a description of a table's optimal set of columns that uniquely	 * identifies a row. They are ordered by SCOPE.	 * <P>	 * Each column description has the following columns:	 * <OL>	 * <li> <B>SCOPE</B> short => actual scope of result	 * <UL>	 * <li> bestRowTemporary - very temporary, while using row </li>	 * <li> bestRowTransaction - valid for remainder of current transaction	 * </li>	 * <li> bestRowSession - valid for remainder of current session </li>	 * </ul>	 * </li>	 * <li> <B>COLUMN_NAME</B> String => column name </li>	 * <li> <B>DATA_TYPE</B> short => SQL data type from java.sql.Types </li>	 * <li> <B>TYPE_NAME</B> String => Data source dependent type name </li>	 * <li> <B>COLUMN_SIZE</B> int => precision </li>	 * <li> <B>BUFFER_LENGTH</B> int => not used </li>	 * <li> <B>DECIMAL_DIGITS</B> short => scale </li>	 * <li> <B>PSEUDO_COLUMN</B> short => is this a pseudo column like an	 * Oracle ROWID	 * <UL>	 * <li> bestRowUnknown - may or may not be pseudo column </li>	 * <li> bestRowNotPseudo - is NOT a pseudo column </li>	 * <li> bestRowPseudo - is a pseudo column </li>	 * </ul>	 * </li>	 * </ol>	 * </p>	 * 	 * @param catalog	 *            a catalog name; "" retrieves those without a catalog	 * @param schema	 *            a schema name; "" retrieves those without a schema	 * @param table	 *            a table name	 * @param scope	 *            the scope of interest; use same values as SCOPE	 * @param nullable	 *            include columns that are nullable?	 * @return ResultSet each row is a column description	 * @throws SQLException	 *             DOCUMENT ME!	 */	public java.sql.ResultSet getBestRowIdentifier(String catalog,			String schema, final String table, int scope, boolean nullable)			throws SQLException {		if (table == null) {			throw SQLError.createSQLException("Table not specified.",					SQLError.SQL_STATE_ILLEGAL_ARGUMENT);		}		Field[] fields = new Field[8];		fields[0] = new Field("", "SCOPE", Types.SMALLINT, 5);		fields[1] = new Field("", "COLUMN_NAME", Types.CHAR, 32);		fields[2] = new Field("", "DATA_TYPE", Types.SMALLINT, 32);		fields[3] = new Field("", "TYPE_NAME", Types.CHAR, 32);		fields[4] = new Field("", "COLUMN_SIZE", Types.INTEGER, 10);		fields[5] = new Field("", "BUFFER_LENGTH", Types.INTEGER, 10);		fields[6] = new Field("", "DECIMAL_DIGITS", Types.INTEGER, 10);		fields[7] = new Field("", "PSEUDO_COLUMN", Types.SMALLINT, 5);		final ArrayList rows = new ArrayList();		final Statement stmt = this.conn.getMetadataSafeStatement();		try {			new IterateBlock(getCatalogIterator(catalog)) {				void forEach(Object catalogStr) throws SQLException {					ResultSet results = null;					try {						StringBuffer queryBuf = new StringBuffer(								"SHOW COLUMNS FROM ");						queryBuf.append(quotedId);						queryBuf.append(table);						queryBuf.append(quotedId);						queryBuf.append(" FROM ");						queryBuf.append(quotedId);						queryBuf.append(catalogStr.toString());						queryBuf.append(quotedId);						results = stmt.executeQuery(queryBuf.toString());						while (results.next()) {							String keyType = results.getString("Key");							if (keyType != null) {								if (StringUtils.startsWithIgnoreCase(keyType,										"PRI")) {									byte[][] rowVal = new byte[8][];									rowVal[0] = Integer											.toString(													java.sql.DatabaseMetaData.bestRowSession)											.getBytes();									rowVal[1] = results.getBytes("Field");									String type = results.getString("Type");									int size = MysqlIO.getMaxBuf();									int decimals = 0;									/*									 * Parse the Type column from MySQL									 */									if (type.indexOf("enum") != -1) {										String temp = type.substring(type												.indexOf("("), type												.indexOf(")"));										java.util.StringTokenizer tokenizer = new java.util.StringTokenizer(												temp, ",");										int maxLength = 0;										while (tokenizer.hasMoreTokens()) {											maxLength = Math.max(maxLength,													(tokenizer.nextToken()															.length() - 2));										}										size = maxLength;										decimals = 0;										type = "enum";									} else if (type.indexOf("(") != -1) {										if (type.indexOf(",") != -1) {											size = Integer.parseInt(type													.substring(type															.indexOf("(") + 1,															type.indexOf(",")));											decimals = Integer.parseInt(type													.substring(type															.indexOf(",") + 1,															type.indexOf(")")));										} else {											size = Integer.parseInt(type													.substring(type															.indexOf("(") + 1,															type.indexOf(")")));										}										type = type.substring(0, type												.indexOf("("));									}									rowVal[2] = s2b(String.valueOf(MysqlDefs											.mysqlToJavaType(type)));									rowVal[3] = s2b(type);									rowVal[4] = Integer.toString(											size + decimals).getBytes();									rowVal[5] = Integer.toString(											size + decimals).getBytes();									rowVal[6] = Integer.toString(decimals)											.getBytes();									rowVal[7] = Integer											.toString(													java.sql.DatabaseMetaData.bestRowNotPseudo)											.getBytes();									rows.add(rowVal);								}							}						}					} finally {						if (results != null) {							try {								results.close();							} catch (Exception ex) {								;							}							results = null;						}					}				}			}.doForAll();		} finally {			if (stmt != null) {				stmt.close();			}		}		java.sql.ResultSet results = buildResultSet(fields, rows);		return results;	}	/*	 * * Each row in the ResultSet is a parameter desription or column	 * description with the following fields: <OL> <li> <B>PROCEDURE_CAT</B>	 * String => procedure catalog (may be null) </li> <li> <B>PROCEDURE_SCHEM</B>	 * String => procedure schema (may be null) </li> <li> <B>PROCEDURE_NAME</B>	 * String => procedure name </li> <li> <B>COLUMN_NAME</B> String =>	 * column/parameter name </li> <li> <B>COLUMN_TYPE</B> Short => kind of	 * column/parameter: <UL> <li> procedureColumnUnknown - nobody knows </li>	 * <li> procedureColumnIn - IN parameter </li> <li> procedureColumnInOut -	 * INOUT parameter </li> <li> procedureColumnOut - OUT parameter </li> <li>	 * procedureColumnReturn - procedure return value </li> <li>	 * procedureColumnResult - result column in ResultSet </li> </ul> </li> <li>	 * <B>DATA_TYPE</B> short => SQL type from java.sql.Types </li> <li>	 * <B>TYPE_NAME</B> String => SQL type name </li> <li> <B>PRECISION</B>	 * int => precision </li> <li> <B>LENGTH</B> int => length in bytes of data	 * </li> <li> <B>SCALE</B> short => scale </li> <li> <B>RADIX</B> short =>	 * radix </li> <li> <B>NULLABLE</B> short => can it contain NULL? <UL> <li>	 * procedureNoNulls - does not allow NULL values </li> <li>	 * procedureNullable - allows NULL values </li> <li>	 * procedureNullableUnknown - nullability unknown </li> </ul> </li> <li>	 * <B>REMARKS</B> String => comment describing parameter/column </li> </ol>	 * </p> <P> <B>Note:</B> Some databases may not return the column	 * descriptions for a procedure. Additional columns beyond REMARKS can be	 * defined by the database. </p> @param catalog a catalog name; "" retrieves	 * those without a catalog @param schemaPattern a schema name pattern; ""	 * retrieves those without a schema @param procedureNamePattern a procedure	 * name pattern @param columnNamePattern a column name pattern @return	 * ResultSet each row is a stored procedure parameter or column description	 * @throws SQLException if a database access error occurs	 * 	 * @see #getSearchStringEscape	 */	private void getCallStmtParameterTypes(String catalog, String procName,			String parameterNamePattern, List resultRows) throws SQLException {		java.sql.Statement paramRetrievalStmt = null;		java.sql.ResultSet paramRetrievalRs = null;		if (parameterNamePattern == null) {			if (this.conn.getNullNamePatternMatchesAll()) {				parameterNamePattern = "%";			} else {				throw SQLError						.createSQLException(								"Parameter/Column name pattern can not be NULL or empty.",								SQLError.SQL_STATE_ILLEGAL_ARGUMENT);			}		}		byte[] procNameAsBytes = null;		try {			procNameAsBytes = procName.getBytes("UTF-8");		} catch (UnsupportedEncodingException ueEx) {			procNameAsBytes = s2b(procName);		}		String quoteChar = getIdentifierQuoteString();		String parameterDef = null;		boolean isProcedureInAnsiMode = false;		String storageDefnDelims = null;		String storageDefnClosures = null;				try {			paramRetrievalStmt = this.conn.getMetadataSafeStatement();			if (this.conn.lowerCaseTableNames() && catalog != null					&& catalog.length() != 0) {				// Workaround for bug in server wrt. to				// SHOW CREATE PROCEDURE not respecting				// lower-case table names				String oldCatalog = this.conn.getCatalog();				ResultSet rs = null;				try {					this.conn.setCatalog(catalog);					rs = paramRetrievalStmt.executeQuery("SELECT DATABASE()");					rs.next();					catalog = rs.getString(1);				} finally {					this.conn.setCatalog(oldCatalog);					if (rs != null) {						rs.close();					}				}			}			if (paramRetrievalStmt.getMaxRows() != 0) {				paramRetrievalStmt.setMaxRows(0);			}			int dotIndex = -1;			if (!" ".equals(quoteChar)) {				dotIndex = StringUtils.indexOfIgnoreCaseRespectQuotes(0,						procName, ".", quoteChar.charAt(0), !this.conn								.isNoBackslashEscapesSet());			} else {				dotIndex = procName.indexOf(".");			}			String dbName = null;			if (dotIndex != -1 && (dotIndex + 1) < procName.length()) {				dbName = procName.substring(0, dotIndex);				procName = procName.substring(dotIndex + 1);			} else {				dbName = catalog;			}			StringBuffer procNameBuf = new StringBuffer();			if (dbName != null) {				if (!" ".equals(quoteChar) && !dbName.startsWith(quoteChar)) {					procNameBuf.append(quoteChar);				}				procNameBuf.append(dbName);				if (!" ".equals(quoteChar) && !dbName.startsWith(quoteChar)) {					procNameBuf.append(quoteChar);				}				procNameBuf.append(".");			}			boolean procNameIsNotQuoted = !procName.startsWith(quoteChar);			if (!" ".equals(quoteChar) && procNameIsNotQuoted) {				procNameBuf.append(quoteChar);			}			procNameBuf.append(procName);			if (!" ".equals(quoteChar) && procNameIsNotQuoted) {				procNameBuf.append(quoteChar);			}			boolean parsingFunction = false;			try {				paramRetrievalRs = paramRetrievalStmt						.executeQuery("SHOW CREATE PROCEDURE "								+ procNameBuf.toString());				parsingFunction = false;			} catch (SQLException sqlEx) {				paramRetrievalRs = paramRetrievalStmt						.executeQuery("SHOW CREATE FUNCTION "								+ procNameBuf.toString());				parsingFunction = true;			}			if (paramRetrievalRs.next()) {				String procedureDef = parsingFunction ? paramRetrievalRs						.getString("Create Function") : paramRetrievalRs						.getString("Create Procedure");				if (procedureDef == null || procedureDef.length() == 0) {					throw SQLError							.createSQLException(									"User does not have access to metadata required to determine "											+ "stored procedure parameter types. If rights can not be granted, configure connection with \"noAccessToProcedureBodies=true\" "											+ "to have driver generate parameters that represent INOUT strings irregardless of actual parameter types.",									SQLError.SQL_STATE_GENERAL_ERROR);				}				try {					String sqlMode = paramRetrievalRs.getString("sql_mode");										if (StringUtils.indexOfIgnoreCase(sqlMode, "ANSI") != -1) {						isProcedureInAnsiMode = true;					}				} catch (SQLException sqlEx) {					// doesn't exist				}				String identifierMarkers = isProcedureInAnsiMode ? "`\"" : "`";				String identifierAndStringMarkers = "'" + identifierMarkers;				storageDefnDelims = "(" + identifierMarkers;				storageDefnClosures = ")" + identifierMarkers;								// sanitize/normalize by stripping out comments				procedureDef = StringUtils.stripComments(procedureDef, 						identifierAndStringMarkers, identifierAndStringMarkers, true, false, true, true);								int openParenIndex = StringUtils						.indexOfIgnoreCaseRespectQuotes(0, procedureDef, "(",								quoteChar.charAt(0), !this.conn										.isNoBackslashEscapesSet());				int endOfParamDeclarationIndex = 0;				endOfParamDeclarationIndex = endPositionOfParameterDeclaration(						openParenIndex, procedureDef, quoteChar);				if (parsingFunction) {					// Grab the return column since it needs					// to go first in the output result set					int returnsIndex = StringUtils							.indexOfIgnoreCaseRespectQuotes(0, procedureDef,