oracledatabasemetadata.java

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

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

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

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


  /**
   * Is positioned DELETE supported?
   *
   * @return true if so
   */
  public boolean supportsPositionedDelete() 
    throws SQLException
  {
    connection.trace ("supportsPositionedDelete");
    return true; // where current of
  }

  /**
   * Is positioned UPDATE supported?
   *
   * @return true if so
   */
  public boolean supportsPositionedUpdate() 
    throws SQLException
  {
    connection.trace ("supportsPositionedUpdate");
    return true; // where current of
  }

  /**
   * Is SELECT for UPDATE supported?
   *
   * @return true if so
   */
  public boolean supportsSelectForUpdate() 
    throws SQLException
  {
    connection.trace ("supportsSelectForUpdate");
    return true;
  }

  /**
   * Are stored procedure calls using the stored procedure escape
   * syntax supported?
   *
   * @return true if so 
   */
  public boolean supportsStoredProcedures() 
    throws SQLException
  {
    connection.trace ("supportsStoredProcedures");
    return true;    
  }

  /**
   * Are subqueries in comparison expressions supported?
   *
   * A JDBC compliant driver always returns true.
   *
   * @return true if so
   */
  public boolean supportsSubqueriesInComparisons() 
    throws SQLException
  {
    connection.trace ("supportsSubqueriesInComparisons");
    return true;
  }

  /**
   * Are subqueries in exists expressions supported?
   *
   * A JDBC compliant driver always returns true.
   *
   * @return true if so
   */
  public boolean supportsSubqueriesInExists() 
    throws SQLException
  {
    connection.trace ("supportsSubqueriesInExists");
    return true;
  }

  /**
   * Are subqueries in "in" statements supported?
   *
   * A JDBC compliant driver always returns true.
   *
   * @return true if so
   */
  public boolean supportsSubqueriesInIns() 
    throws SQLException
  {
    connection.trace ("supportsSubqueriesInIns");
    return true;
  }

  /**
   * Are subqueries in quantified expressions supported?
   *
   * A JDBC compliant driver always returns true.
   *
   * @return true if so
   */
  public boolean supportsSubqueriesInQuantifieds() 
    throws SQLException
  {
    connection.trace ("supportsSubqueriesInQuantifieds");
    return true;
  }

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

  /**
   * Is SQL UNION supported?
   *
   * @return true if so
   */
  public boolean supportsUnion() 
    throws SQLException
  {
    connection.trace ("supportsUnion");
    return true;
  }

  /**
   * Is SQL UNION ALL supported?
   *
   * @return true if so
   */
  public boolean supportsUnionAll() 
    throws SQLException
  {
    connection.trace ("supportsUnionAll");
    return true;
  }

  /**
   * Can cursors remain open across commits?
   * 
   * @return true if so 
   * @see Connection#disableAutoClose
   */
  public boolean supportsOpenCursorsAcrossCommit() 
    throws SQLException
  {
    connection.trace ("supportsOpenCursorsAcrossCommit");
    return false;
  }

  /**
   * Can cursors remain open across rollbacks?
   * 
   * @return true if so 
   * @see Connection#disableAutoClose
   */
  public boolean supportsOpenCursorsAcrossRollback() 
    throws SQLException
  {
    connection.trace ("supportsOpenCursorsAcrossRollback");
    return false;
  }

  /**
   * Can statements remain open across commits?
   * 
   * @return true if so 
   * @see Connection#disableAutoClose
   */
  public boolean supportsOpenStatementsAcrossCommit() 
    throws SQLException
  {
    connection.trace ("supportsOpenStatementsAcrossCommit");
    return false;
  }

  /**
   * Can statements remain open across rollbacks?
   * 
   * @return true if so 
   * @see Connection#disableAutoClose
   */
  public boolean supportsOpenStatementsAcrossRollback() 
    throws SQLException
  {
    connection.trace ("supportsOpenStatementsAcrossRollback");
    return false;
  }

	

  //----------------------------------------------------------------------
  // 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.
	
  /**
   * How many hex characters can you have in an inline binary literal?
   *
   * @return max literal length
   */
  public int getMaxBinaryLiteralLength() 
    throws SQLException
  {
    connection.trace ("getMaxBinaryLiteralLength");
    return 1000;
  }

  /**
   * What's the max length for a character literal?
   *
   * @return max literal length
   */
  public int getMaxCharLiteralLength() 
    throws SQLException
  {
    connection.trace ("getMaxCharLiteralLength");
    return 2000;
  }

  /**
   * What's the limit on column name length?
   *
   * @return max literal length
   */
  public int getMaxColumnNameLength() 
    throws SQLException
  {
    connection.trace ("getMaxColumnNameLength");
    return 30;
  }

  /**
   * What's the maximum number of columns in a "GROUP BY" clause?
   *
   * @return max number of columns
   */
  public int getMaxColumnsInGroupBy() 
    throws SQLException
  {
    connection.trace ("getMaxColumnsInGroupBy");
    return 0;
  }

  /**
   * What's the maximum number of columns allowed in an index?
   *
   * @return max columns
   */
  public int getMaxColumnsInIndex() 
    throws SQLException
  {
    connection.trace ("getMaxColumnsInIndex");
    return 32;
  }

  /**
   * What's the maximum number of columns in an "ORDER BY" clause?
   *
   * @return max columns
   */
  public int getMaxColumnsInOrderBy() 
    throws SQLException
  {
    connection.trace ("getMaxColumnsInOrderBy");
    return 0;
  }

  /**
   * What's the maximum number of columns in a "SELECT" list?
   *
   * @return max columns
   */
  public int getMaxColumnsInSelect() 
    throws SQLException
  {
    connection.trace ("getMaxColumnsInSelect");
    return 0;
  }

  /**
   * What's maximum number of columns in a table?
   *
   * @return max columns
   */
  public int getMaxColumnsInTable() 
    throws SQLException
  {
    connection.trace ("getMaxColumnsInTable");
    return 1000;
  }

  /**
   * How many active connections can we have at a time to this database?
   *
   * @return max connections
   */
  public int getMaxConnections() 
    throws SQLException
  {
    connection.trace ("getMaxConnections");
    return 0;
  }

  /**
   * What's the maximum cursor name length?
   *
   * @return max cursor name length in bytes
   */
  public int getMaxCursorNameLength() 
    throws SQLException
  {
    connection.trace ("getMaxCursorNameLength");
    return 0;
  }

  /**
   * What's the maximum length of an index (in bytes)?	
   *
   * @return max index length in bytes
   */
  public int getMaxIndexLength() 
    throws SQLException
  {
    connection.trace ("getMaxIndexLength");
    return 0;
  }

  /**
   * What's the maximum length allowed for a schema name?
   *
   * @return max name length in bytes
   */
  public int getMaxSchemaNameLength() 
    throws SQLException
  {
    connection.trace ("getMaxSchemaNameLength");
    return 30;
  }

  /**
   * What's the maximum length of a procedure name?
   *
   * @return max name length in bytes
   */
  public int getMaxProcedureNameLength() 
    throws SQLException
  {
    connection.trace ("getMaxProcedureNameLength");
    return 30;
  }

  /**
   * What's the maximum length of a catalog name?
   *
   * @return max name length in bytes
   */
  public int getMaxCatalogNameLength() 
    throws SQLException
  {
    connection.trace ("getMaxCatalogNameLength");
    return 0;
  }

  /**
   * What's the maximum length of a single row?
   *
   * @return max row size in bytes
   */
  public int getMaxRowSize() 
    throws SQLException
  {
    connection.trace ("getMaxRowSize");
    return 2000;
  }

  /**
   * Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY
   * blobs?
   *
   * @return true if so 
   */
  public boolean doesMaxRowSizeIncludeBlobs() 
    throws SQLException
  {
    connection.trace ("doesMaxRowSizeIncludeBlobs");
    return true;
  }

  /**
   * What's the maximum length of a SQL statement?
   *
   * @return max length in bytes
   */
  public int getMaxStatementLength() 
    throws SQLException
  {
    connection.trace ("getMaxStatementLength");
    return 65535;
  }

  /**
   * How many active statements can we have open at one time to this
   * database?
   *
   * @return the maximum 
   */
  public int getMaxStatements() 
    throws SQLException
  {
    connection.trace ("getMaxStatements");
    return 0;
  }

  /**
   * What's the maximum length of a table name?
   *
   * @return max name length in bytes
   */
  public int getMaxTableNameLength() 
    throws SQLException
  {
    connection.trace ("getMaxTableNameLength");
    return 30;
  }

  /**
   * What's the maximum number of tables in a SELECT?
   *
   * @return the maximum
   */
  public int getMaxTablesInSelect() 
    throws SQLException
  {
    connection.trace ("getMaxTablesInSelect");
    return 0;
  }

  /**
   * What's the maximum length of a user name?
   *
   * @return max name length  in bytes
   */
  public int getMaxUserNameLength()