databasemetadata.java

mysql5.0 JDBC 驱动 放在glassfish或者tomcat的lib文件夹下就可以了

			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;
	
	protected static final int MAX_IDENTIFIER_LENGTH = 64;
	
	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 byte[] SYSTEM_TABLE_AS_BYTES = "SYSTEM TABLE".getBytes();
	
	private static final int UPDATE_RULE = 9;

	private static final byte[] VIEW_AS_BYTES = "VIEW".getBytes();
	
	private static final Constructor JDBC_4_DBMD_SHOW_CTOR;
	
	private static final Constructor JDBC_4_DBMD_IS_CTOR;
	
	static {
		if (Util.isJdbc4()) {
			try {
				JDBC_4_DBMD_SHOW_CTOR = Class.forName(
						"com.mysql.jdbc.JDBC4DatabaseMetaData").getConstructor(
						new Class[] { com.mysql.jdbc.ConnectionImpl.class,
								String.class });
				JDBC_4_DBMD_IS_CTOR = Class.forName(
						"com.mysql.jdbc.JDBC4DatabaseMetaDataUsingInfoSchema")
						.getConstructor(
								new Class[] { com.mysql.jdbc.ConnectionImpl.class,
										String.class });
			} catch (SecurityException e) {
				throw new RuntimeException(e);
			} catch (NoSuchMethodException e) {
				throw new RuntimeException(e);
			} catch (ClassNotFoundException e) {
				throw new RuntimeException(e);
			}
		} else {
			JDBC_4_DBMD_IS_CTOR = null;
			JDBC_4_DBMD_SHOW_CTOR = null;
		}
		
		// 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();
	}
	
	/** The connection to the database */
	protected ConnectionImpl conn;

	/** The 'current' database name being used */
	protected String database = null;

	/** What character to use when quoting identifiers */
	protected String quotedId = null;

	// We need to provide factory-style methods so we can support both JDBC3 (and older)
	// and JDBC4 runtimes, otherwise the class verifier complains...
	
	protected static DatabaseMetaData getInstance(
			ConnectionImpl connToSet, String databaseToSet, boolean checkForInfoSchema)
			throws SQLException {
		if (!Util.isJdbc4()) {
			if (checkForInfoSchema && connToSet != null 
					&& connToSet.getUseInformationSchema()
					&& connToSet.versionMeetsMinimum(5, 0, 7)) {
				return new DatabaseMetaDataUsingInfoSchema(connToSet,
						databaseToSet);
			}

			return new DatabaseMetaData(connToSet, databaseToSet);
		}

		if (checkForInfoSchema && connToSet != null 
				&& connToSet.getUseInformationSchema()
				&& connToSet.versionMeetsMinimum(5, 0, 7)) {

			return (DatabaseMetaData) Util.handleNewInstance(
					JDBC_4_DBMD_IS_CTOR, new Object[] { connToSet,
							databaseToSet });
		}

		return (DatabaseMetaData) Util.handleNewInstance(JDBC_4_DBMD_SHOW_CTOR,
				new Object[] { connToSet, databaseToSet });
	}
	
	/**
	 * Creates a new DatabaseMetaData object.
	 * 
	 * @param connToSet
	 *            DOCUMENT ME!
	 * @param databaseToSet
	 *            DOCUMENT ME!
	 */
	protected DatabaseMetaData(ConnectionImpl 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);
	}
	
	static java.sql.ResultSet buildResultSet(com.mysql.jdbc.Field[] fields,
			java.util.ArrayList rows, ConnectionImpl c) throws SQLException {
		int fieldsLength = fields.length;

		for (int i = 0; i < fieldsLength; i++) {
			int jdbcType = fields[i].getSQLType();
			
			switch (jdbcType) {
			case Types.CHAR:
			case Types.VARCHAR:
			case Types.LONGVARCHAR:
				fields[i].setCharacterSet(c.getCharacterSetMetadata());
				break;
			default:
				// do nothing
			}
			
			fields[i].setConnection(c);
			fields[i].setUseOldNameMetadata(true);
		}

		return com.mysql.jdbc.ResultSetImpl.getInstance(c.getCatalog(), fields,
				new RowDataStatic(rows), c, null, false);
	}

	private void convertToJdbcFunctionList(String catalog,
			ResultSet proceduresRs, boolean needsClientFiltering, String db,
			Map procedureRowsOrderedByName, int nameIndex,
			Field[] fields) 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 = null;
				
				if (fields != null && fields.length == 9) {
					
					rowData = new byte[9][];
					rowData[0] = catalog == null ? null : s2b(catalog);         // PROCEDURE_CAT
					rowData[1] = null;                                          // PROCEDURE_SCHEM
					rowData[2] = s2b(functionName);                             // PROCEDURE_NAME
					rowData[3] = null;                                          // reserved1
					rowData[4] = null;                                          // reserved2
					rowData[5] = null;                                          // reserved3
					rowData[6] = s2b(proceduresRs.getString("comment"));        // REMARKS
					rowData[7] = s2b(Integer.toString(procedureReturnsResult)); // PROCEDURE_TYPE
					rowData[8] = s2b(functionName);
				} else {
					
					rowData = new byte[6][];
					
					rowData[0] = catalog == null ? null : s2b(catalog);  // FUNCTION_CAT
					rowData[1] = null;                                   // FUNCTION_SCHEM
					rowData[2] = s2b(functionName);                      // FUNCTION_NAME
					rowData[3] = s2b(proceduresRs.getString("comment")); // REMARKS
					rowData[4] = s2b(Integer.toString(getJDBC4FunctionNoTableConstant())); // FUNCTION_TYPE
					rowData[5] = s2b(functionName);                      // SPECFIC NAME
				}

				procedureRowsOrderedByName.put(functionName, new ByteArrayRow(rowData));
			}
		}
	}
	
	protected int getJDBC4FunctionNoTableConstant() {
		return 0;
	}
	
	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[9][];
				rowData[0] = catalog == null ? null : s2b(catalog);