databasemetadata.java

开发MySql数据库的最新JDBC驱动。

					int endReturnsDef = findEndOfReturnsClause(procedureDef,
							quoteChar, returnsIndex);

					// Trim off whitespace after "RETURNS"
					
					int declarationStart = returnsIndex + "RETURNS ".length();
					
					while (declarationStart < procedureDef.length()) {
						if (Character.isWhitespace(procedureDef.charAt(declarationStart))) {
							declarationStart++;
						} else {
							break;
						}
					}
					
					String returnsDefn = procedureDef.substring(declarationStart, endReturnsDef).trim();
					TypeDescriptor returnDescriptor = new TypeDescriptor(
							returnsDefn, null);

					resultRows.add(convertTypeDescriptorToProcedureRow(
							procNameAsBytes, "", false, false, true,
							returnDescriptor));
				}

				if ((openParenIndex == -1)
						|| (endOfParamDeclarationIndex == -1)) {
					// parse error?
					throw SQLError
							.createSQLException(
									"Internal error when parsing callable statement metadata",
									SQLError.SQL_STATE_GENERAL_ERROR);
				}

				parameterDef = procedureDef.substring(openParenIndex + 1,
						endOfParamDeclarationIndex);
			}
		} finally {
			SQLException sqlExRethrow = null;

			if (paramRetrievalRs != null) {
				try {
					paramRetrievalRs.close();
				} catch (SQLException sqlEx) {
					sqlExRethrow = sqlEx;
				}

				paramRetrievalRs = null;
			}

			if (paramRetrievalStmt != null) {
				try {
					paramRetrievalStmt.close();
				} catch (SQLException sqlEx) {
					sqlExRethrow = sqlEx;
				}

				paramRetrievalStmt = null;
			}

			if (sqlExRethrow != null) {
				throw sqlExRethrow;
			}
		}

		if (parameterDef != null) {

			List parseList = StringUtils.split(parameterDef, ",",
					storageDefnDelims, storageDefnClosures, true);

			int parseListLen = parseList.size();

			for (int i = 0; i < parseListLen; i++) {
				String declaration = (String) parseList.get(i);

				if (declaration.trim().length() == 0) {
					break; // no parameters actually declared, but whitespace
							// spans lines
				}

				StringTokenizer declarationTok = new StringTokenizer(
						declaration, " \t");

				String paramName = null;
				boolean isOutParam = false;
				boolean isInParam = false;

				if (declarationTok.hasMoreTokens()) {
					String possibleParamName = declarationTok.nextToken();

					if (possibleParamName.equalsIgnoreCase("OUT")) {
						isOutParam = true;

						if (declarationTok.hasMoreTokens()) {
							paramName = declarationTok.nextToken();
						} else {
							throw SQLError
									.createSQLException(
											"Internal error when parsing callable statement metadata (missing parameter name)",
											SQLError.SQL_STATE_GENERAL_ERROR);
						}
					} else if (possibleParamName.equalsIgnoreCase("INOUT")) {
						isOutParam = true;
						isInParam = true;

						if (declarationTok.hasMoreTokens()) {
							paramName = declarationTok.nextToken();
						} else {
							throw SQLError
									.createSQLException(
											"Internal error when parsing callable statement metadata (missing parameter name)",
											SQLError.SQL_STATE_GENERAL_ERROR);
						}
					} else if (possibleParamName.equalsIgnoreCase("IN")) {
						isOutParam = false;
						isInParam = true;

						if (declarationTok.hasMoreTokens()) {
							paramName = declarationTok.nextToken();
						} else {
							throw SQLError
									.createSQLException(
											"Internal error when parsing callable statement metadata (missing parameter name)",
											SQLError.SQL_STATE_GENERAL_ERROR);
						}
					} else {
						isOutParam = false;
						isInParam = true;

						paramName = possibleParamName;
					}

					TypeDescriptor typeDesc = null;

					if (declarationTok.hasMoreTokens()) {
						StringBuffer typeInfoBuf = new StringBuffer(
								declarationTok.nextToken());

						while (declarationTok.hasMoreTokens()) {
							typeInfoBuf.append(" ");
							typeInfoBuf.append(declarationTok.nextToken());
						}

						String typeInfo = typeInfoBuf.toString();

						typeDesc = new TypeDescriptor(typeInfo, null);
					} else {
						throw SQLError
								.createSQLException(
										"Internal error when parsing callable statement metadata (missing parameter type)",
										SQLError.SQL_STATE_GENERAL_ERROR);
					}

					if ((paramName.startsWith("`") && paramName.endsWith("`")) || 
							(isProcedureInAnsiMode && paramName.startsWith("\"") && paramName.endsWith("\""))) {
						paramName = paramName.substring(1, paramName.length() - 1);
					}
					
					int wildCompareRes = StringUtils.wildCompare(paramName,
							parameterNamePattern);

					if (wildCompareRes != StringUtils.WILD_COMPARE_NO_MATCH) {
						byte[][] row = convertTypeDescriptorToProcedureRow(
								procNameAsBytes, paramName, isOutParam,
								isInParam, false, typeDesc);

						resultRows.add(row);
					}
				} else {
					throw SQLError
							.createSQLException(
									"Internal error when parsing callable statement metadata (unknown output from 'SHOW CREATE PROCEDURE')",
									SQLError.SQL_STATE_GENERAL_ERROR);
				}
			}
		} else {
			// Is this an error? JDBC spec doesn't make it clear if stored
			// procedure doesn't
			// exist, is it an error....
		}
	}

	/**
	 * Parses the cascade option string and returns the DBMD constant that
	 * represents it (for deletes)
	 * 
	 * @param cascadeOptions
	 *            the comment from 'SHOW TABLE STATUS'
	 * @return the DBMD constant that represents the cascade option
	 */
	private int getCascadeDeleteOption(String cascadeOptions) {
		int onDeletePos = cascadeOptions.indexOf("ON DELETE");

		if (onDeletePos != -1) {
			String deleteOptions = cascadeOptions.substring(onDeletePos,
					cascadeOptions.length());

			if (deleteOptions.startsWith("ON DELETE CASCADE")) {
				return java.sql.DatabaseMetaData.importedKeyCascade;
			} else if (deleteOptions.startsWith("ON DELETE SET NULL")) {
				return java.sql.DatabaseMetaData.importedKeySetNull;
			} else if (deleteOptions.startsWith("ON DELETE RESTRICT")) {
				return java.sql.DatabaseMetaData.importedKeyRestrict;
			} else if (deleteOptions.startsWith("ON DELETE NO ACTION")) {
				return java.sql.DatabaseMetaData.importedKeyNoAction;
			}
		}

		return java.sql.DatabaseMetaData.importedKeyNoAction;
	}

	/**
	 * Parses the cascade option string and returns the DBMD constant that
	 * represents it (for Updates)
	 * 
	 * @param cascadeOptions
	 *            the comment from 'SHOW TABLE STATUS'
	 * @return the DBMD constant that represents the cascade option
	 */
	private int getCascadeUpdateOption(String cascadeOptions) {
		int onUpdatePos = cascadeOptions.indexOf("ON UPDATE");

		if (onUpdatePos != -1) {
			String updateOptions = cascadeOptions.substring(onUpdatePos,
					cascadeOptions.length());

			if (updateOptions.startsWith("ON UPDATE CASCADE")) {
				return java.sql.DatabaseMetaData.importedKeyCascade;
			} else if (updateOptions.startsWith("ON UPDATE SET NULL")) {
				return java.sql.DatabaseMetaData.importedKeySetNull;
			} else if (updateOptions.startsWith("ON UPDATE RESTRICT")) {
				return java.sql.DatabaseMetaData.importedKeyRestrict;
			} else if (updateOptions.startsWith("ON UPDATE NO ACTION")) {
				return java.sql.DatabaseMetaData.importedKeyNoAction;
			}
		}

		return java.sql.DatabaseMetaData.importedKeyNoAction;
	}

	protected IteratorWithCleanup getCatalogIterator(String catalogSpec)
			throws SQLException {
		IteratorWithCleanup allCatalogsIter;
		if (catalogSpec != null) {
			if (!catalogSpec.equals("")) {
				allCatalogsIter = new SingleStringIterator(catalogSpec);
			} else {
				// legacy mode of operation
				allCatalogsIter = new SingleStringIterator(this.database);
			}
		} else if (this.conn.getNullCatalogMeansCurrent()) {
			allCatalogsIter = new SingleStringIterator(this.database);
		} else {
			allCatalogsIter = new ResultSetIterator(getCatalogs(), 1);
		}

		return allCatalogsIter;
	}

	/**
	 * Get the catalog names available in this database. The results are ordered
	 * by catalog name.
	 * <P>
	 * The catalog column is:
	 * <OL>
	 * <li> <B>TABLE_CAT</B> String => catalog name </li>
	 * </ol>
	 * </p>
	 * 
	 * @return ResultSet each row has a single String column that is a catalog
	 *         name
	 * @throws SQLException
	 *             DOCUMENT ME!
	 */
	public java.sql.ResultSet getCatalogs() throws SQLException {
		java.sql.ResultSet results = null;
		java.sql.Statement stmt = null;

		try {
			stmt = this.conn.createStatement();
			stmt.setEscapeProcessing(false);
			results = stmt.executeQuery("SHOW DATABASES");

			java.sql.ResultSetMetaData resultsMD = results.getMetaData();
			Field[] fields = new Field[1];
			fields[0] = new Field("", "TABLE_CAT", Types.VARCHAR, resultsMD
					.getColumnDisplaySize(1));

			ArrayList tuples = new ArrayList();

			while (results.next()) {
				byte[][] rowVal = new byte[1][];
				rowVal[0] = results.getBytes(1);
				tuples.add(rowVal);
			}

			return buildResultSet(fields, tuples);
		} finally {
			if (results != null) {
				try {
					results.close();
				} catch (SQLException sqlEx) {
					AssertionFailedException.shouldNotHappen(sqlEx);
				}

				results = null;
			}

			if (stmt != null) {
				try {
					stmt.close();
				} catch (SQLException sqlEx) {
					AssertionFailedException.shouldNotHappen(sqlEx);
				}

				stmt = null;
			}
		}
	}

	/**
	 * What's the separator between catalog and table name?
	 * 
	 * @return the separator string
	 * @throws SQLException
	 *             DOCUMENT ME!
	 */
	public String getCatalogSeparator() throws SQLException {
		return ".";
	}

	// ----------------------------------------------------------------------
	// The following group of methods exposes various limitations
	// based on the target database with the current driver.
	// Unless otherwise specified, a result of zero means there is no
	// limit, or the limit is not known.

	/**
	 * What's the database vendor's preferred term for "catalog"?
	 * 
	 * @return the vendor term
	 * @throws SQLException
	 *             DOCUMENT ME!
	 */
	public String getCatalogTerm() throws SQLException {
		return "database";
	}

	/**
	 * Get a description of the access rights for a table's columns.
	 * <P>
	 * Only privileges matching the column name criteria are returned. They are
	 * ordered by COLUMN_NAME and PRIVILEGE.
	 * </p>
	 * <P>
	 * Each privilige description has the following columns:
	 * <OL>
	 * <li> <B>TABLE_CAT</B> String => table catalog (may be null) </li>
	 * <li> <B>TABLE_SCHEM</B> String => table schema (may be null) </li>
	 * <li> <B>TABLE_NAME</B> String => table name </li>
	 * <li> <B>COLUMN_NAME</B> String => column name </li>
	 * <li> <B>GRANTOR</B> => grantor of access (may be null) </li>
	 * <li> <B>GRANTEE</B> String => grantee of access </li>
	 * <li> <B>PRIVILEGE</B> String => name of access (SELECT, INSERT, UPDATE,
	 * REFRENCES, ...) </li>
	 * <li> <B>IS_GRANTABLE</B> String => "YES" if grantee is permitted to
	 * grant to others; "NO" if not; null if unknown </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 columnNamePattern
	 *            a column name pattern
	 * @return ResultSet each row is a column privilege description
	 * @throws SQLException
	 *             if a database access error occurs
	 * @see #getSearchStringEscape
	 */
	public java.sql.ResultSet getColumnPrivileges(String catalog,
			String schema, String table, String columnNamePattern)
			throws SQLException {
		Field[] fields = new Field[8];
		fields[0] = new Field("", "TABLE_CAT", Types.CHAR, 64);
		fields[1] = new Field("", "TABLE_SCHEM", Types.CHAR, 1);
		fields[2] = new Field("", "TABLE_NAME", Types.CHAR, 64);
		fields[3] = new Field("", "COLUMN_NAME", Types.CHAR, 64);
		fields[4] = new Field("", "GRANTOR", Types.CHAR, 77);
		fields[5] = new Field("", "GRANTEE", Types.CHAR, 77);
		fields[6] = new Field("", "PRIVILEGE", Types.CHAR, 64);
		fields[7] = new Field("", "IS_GRANTABLE", Types.CHAR, 3);

		StringBuffer grantQuery = new StringBuffer(
				"SELECT c.host, c.db, t.grantor, c.user, "
						+ "c.table_name, c.column_name, c.column_priv "
						+ "from mysql.columns_priv c, mysql.tables_priv t "
						+ "where c.host = t.host and c.db = t.db and "
						+ "c.table_name = t.table_name ");

		if ((catalog != null) && (catalog.length() != 0)) {
			grantQuery.append(" AND c.db='");
			grantQuery.append(catalog);
			grantQuery.append("' ");
			;
		}

		grantQuery.append(" AND c.table_name ='");
		grantQuery.append(table);
		grantQuery.append("' AND c.column_name