oracledatabasemetadata.java

数据库连接包括连接池。很有用的资料

   * A JDBC compliant driver always returns true.
   *
   * @return true if so 
   */
  public boolean supportsColumnAliasing() 
    throws SQLException
  {
    connection.trace ("supportsColumnAliasing");
    return true;
  }

  /**
   * Are concatenations between NULL and non-NULL values NULL?
   *
   * A JDBC compliant driver always returns true.
   *
   * @return true if so
   */
  public boolean nullPlusNonNullIsNull() 
    throws SQLException
  {
    connection.trace ("nullPlusNonNullIsNull");
    return true;
  }

  /**
   * Is the CONVERT function between SQL types supported?
   *
   * @return true if so
   */
  public boolean supportsConvert() 
    throws SQLException
  {
    connection.trace ("supportsConvert");
    return true;
  }

  /**
   * Is CONVERT between the given SQL types supported?
   *
   * @param fromType the type to convert from
   * @param toType the type to convert to     
   * @return true if so
   * @see Types
   */
  public boolean supportsConvert (int fromType, int toType) 
    throws SQLException
  {
    connection.trace ("supportsConvert");
    // Prune the case tree a bit
    if (fromType == toType
	|| fromType == OracleTypes.CHAR || fromType == OracleTypes.VARCHAR
	|| fromType == OracleTypes.LONGVARCHAR
	|| toType == OracleTypes.CHAR || toType == OracleTypes.VARCHAR
	|| toType == OracleTypes.LONGVARCHAR)
      return true;
    
    // Try the other types
    switch (fromType)
    {
    case OracleTypes.NUMERIC:
    case OracleTypes.DECIMAL:
      return (toType == OracleTypes.TIME || toType == OracleTypes.TIMESTAMP
	      ||toType == OracleTypes.DATE);

    case OracleTypes.TIME:
    case OracleTypes.TIMESTAMP:
    case OracleTypes.DATE:
      return (toType == OracleTypes.NUMERIC || toType == OracleTypes.DECIMAL);

    default:
      return false;
    }
  }

  /**
   * Are table correlation names supported?
   *
   * A JDBC compliant driver always returns true.
   *
   * @return true if so
   */
  public boolean supportsTableCorrelationNames() 
    throws SQLException
  {
    connection.trace ("supportsTableCorrelationNames");
    return true;
  }

  /**
   * If table correlation names are supported, are they restricted
   * to be different from the names of the tables?
   *
   * @return true if so 
   */
  public boolean supportsDifferentTableCorrelationNames() 
    throws SQLException
  {
    connection.trace ("supportsDifferentTableCorrelationNames");
    return true;
  }

  /**
   * Are expressions in "ORDER BY" lists supported?
   *
   * @return true if so
   */
  public boolean supportsExpressionsInOrderBy() 
    throws SQLException
  {
    connection.trace ("supportsExpressionsInOrderBy");
    return true;
  }

  /**
   * Can an "ORDER BY" clause use columns not in the SELECT?
   *
   * @return true if so
   */
  public boolean supportsOrderByUnrelated() 
    throws SQLException
  {
    connection.trace ("supportsOrderByUnrelated");
    return true;
  }

  /**
   * Is some form of "GROUP BY" clause supported?
   *
   * @return true if so
   */
  public boolean supportsGroupBy() 
    throws SQLException
  {
    connection.trace ("supportsGroupBy");
    return true;
  }

  /**
   * Can a "GROUP BY" clause use columns not in the SELECT?
   *
   * @return true if so
   */
  public boolean supportsGroupByUnrelated() 
    throws SQLException
  {
    connection.trace ("supportsGroupByUnrelated");
    return true;
  }

  /**
   * Can a "GROUP BY" clause add columns not in the SELECT
   * provided it specifies all the columns in the SELECT?
   *
   * @return true if so
   */
  public boolean supportsGroupByBeyondSelect() 
    throws SQLException
  {
    connection.trace ("supportsGroupByBeyondSelect");
    return true;
  }

  /**
   * Is the escape character in "LIKE" clauses supported?
   *
   * A JDBC compliant driver always returns true.
   *
   * @return true if so
   */
  public boolean supportsLikeEscapeClause() 
    throws SQLException
  {
    connection.trace ("supportsLikeEscapeClause");
    return true;
  }

  /**
   * Are multiple ResultSets from a single execute supported?
   *
   * @return true if so
   */
  public boolean supportsMultipleResultSets() 
    throws SQLException
  {
    connection.trace ("supportsMultipleResultSets");
    return false;
  }

  /**
   * Can we have multiple transactions open at once (on different
   * connections)?
   *
   * @return true if so
   */
  public boolean supportsMultipleTransactions() 
    throws SQLException
  {
    connection.trace ("supportsMultipleTransactions");
    return true;
  }

  /**
   * Can columns be defined as non-nullable?
   *
   * A JDBC compliant driver always returns true.
   *
   * @return true if so
   */
  public boolean supportsNonNullableColumns() 
    throws SQLException
  {
    connection.trace ("supportsNonNullableColumns");
    return true;
  }

  /**
   * Is the ODBC Minimum SQL grammar supported?
   *
   * All JDBC compliant drivers must return true.
   *
   * @return true if so
   */
  public boolean supportsMinimumSQLGrammar() 
    throws SQLException
  {
    connection.trace ("supportsMinimumSQLGrammar");
    return true;
  }

  /**
   * Is the ODBC Core SQL grammar supported?
   *
   * @return true if so
   */
  public boolean supportsCoreSQLGrammar() 
    throws SQLException
  {
    connection.trace ("supportsCoreSQLGrammar");
    return true;
  }

  /**
   * Is the ODBC Extended SQL grammar supported?
   *
   * @return true if so
   */
  public boolean supportsExtendedSQLGrammar() 
    throws SQLException
  {
    connection.trace ("supportsExtendedSQLGrammar");
    return true;
  }

  /**
   * Is the ANSI92 entry level SQL grammar supported?
   *
   * All JDBC compliant drivers must return true.
   *
   * @return true if so
   */
  public boolean supportsANSI92EntryLevelSQL() 
    throws SQLException
  {
    connection.trace ("supportsANSI92EntryLevelSQL");
    return true;
  }

  /**
   * Is the ANSI92 intermediate SQL grammar supported?
   *
   * @return true if so
   */
  public boolean supportsANSI92IntermediateSQL() 
    throws SQLException
  {
    connection.trace ("supportsANSI92IntermediateSQL");
    return false;
  }

  /**
   * Is the ANSI92 full SQL grammar supported?
   *
   * @return true if so
   */
  public boolean supportsANSI92FullSQL() 
    throws SQLException
  {
    connection.trace ("supportsANSI92FullSQL");
    return false;
  }

  /**
   * Is the SQL Integrity Enhancement Facility supported?
   *
   * @return true if so
   */
  public boolean supportsIntegrityEnhancementFacility() 
    throws SQLException
  {
    connection.trace ("supportsIntegrityEnhancementFacility");
    return true;
  }

  /**
   * Is some form of outer join supported?
   *
   * @return true if so
   */
  public boolean supportsOuterJoins() 
    throws SQLException
  {
    connection.trace ("supportsOuterJoins");
    return true;
  }

  /**
   * Are full nested outer joins supported?
   *
   * @return true if so
   */
  public boolean supportsFullOuterJoins() 
    throws SQLException
  {
    connection.trace ("supportsFullOuterJoins");
    return true;
  }

  /**
   * Is there limited support for outer joins?  (This will be true
   * if supportFullOuterJoins is true.)
   *
   * @return true if so
   */
  public boolean supportsLimitedOuterJoins() 
    throws SQLException
  {
    connection.trace ("supportsLimitedOuterJoins");
    return true;
  }

  /**
   * What's the database vendor's preferred term for "schema"?
   *
   * @return the vendor term
   */
  public String getSchemaTerm() 
    throws SQLException
  {
    connection.trace ("getSchemaTerm");
    return "schema";
  }

  /**
   * What's the database vendor's preferred term for "procedure"?
   *
   * @return the vendor term
   */
  public String getProcedureTerm() 
    throws SQLException
  {
    connection.trace ("getProcedureTerm");
    return "procedure";
  }

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

  /**
   * Does a catalog appear at the start of a qualified table name?
   * (Otherwise it appears at the end)
   *
   * @return true if it appears at the start 
   */
  public boolean isCatalogAtStart() 
    throws SQLException
  {
    connection.trace ("isCatalogAtStart");
    return false;
  }

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

  /**
   * Can a schema name be used in a data manipulation statement?
   *
   * @return true if so
   */
  public boolean supportsSchemasInDataManipulation() 
    throws SQLException
  {
    connection.trace ("supportsSchemasInDataManipulation");
    return true;
  }

  /**
   * Can a schema name be used in a procedure call statement?
   *
   * @return true if so
   */
  public boolean supportsSchemasInProcedureCalls() 
    throws SQLException
  {
    connection.trace ("supportsSchemasInProcedureCalls");
    return true;
  }

  /**
   * Can a schema name be used in a table definition statement?
   *
   * @return true if so
   */
  public boolean supportsSchemasInTableDefinitions() 
    throws SQLException
  {
    connection.trace ("supportsSchemasInTableDefinitions");
    return true;
  }

  /**
   * Can a schema name be used in an index definition statement?
   *
   * @return true if so
   */
  public boolean supportsSchemasInIndexDefinitions() 
    throws SQLException
  {
    connection.trace ("supportsSchemasInIndexDefinitions");
    return true;
  }

  /**
   * Can a schema name be used in a privilege definition statement?
   *
   * @return true if so
   */
  public boolean supportsSchemasInPrivilegeDefinitions() 
    throws SQLException
  {
    connection.trace ("supportsSchemasInPrivilegeDefinitions");
    return true;
  }

  /**
   * Can a catalog name be used in a data manipulation statement?
   *
   * @return true if so
   */
  public boolean supportsCatalogsInDataManipulation() 
    throws SQLException
  {
    connection.trace ("supportsCatalogsInDataManipulation");
    return false;
  }

  /**
   * Can a catalog name be used in a procedure call statement?
   *
   * @return true if so
   */
  public boolean supportsCatalogsInProcedureCalls() 
    throws SQLException
  {
    connection.trace ("supportsCatalogsInProcedureCalls");
    return false;
  }

  /**