/*
    * Copyright (c) 1998, 2005 Gargoyle Software Inc. All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain the above copyright notice,
    *    this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   * 3. The end-user documentation included with the redistribution, if any, must
   *    include the following acknowledgment:
   *
   *       "This product includes software developed by Gargoyle Software Inc.
   *        (http://www.GargoyleSoftware.com/)."
   *
   *    Alternately, this acknowledgment may appear in the software itself, if
   *    and wherever such third-party acknowledgments normally appear.
   * 4. The name "Gargoyle Software" must not be used to endorse or promote
   *    products derived from this software without prior written permission.
   *    For written permission, please contact info@GargoyleSoftware.com.
   * 5. Products derived from this software may not be called "GSBase", nor may
   *    "GSBase" appear in their name, without prior written permission of
   *    Gargoyle Software Inc.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARGOYLE
   * SOFTWARE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
   * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package com.gargoylesoftware.base.resource.jdbc;
  
  import java.sql.Connection;
  import java.sql.DatabaseMetaData;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  /***
   *  Wrapper for DatabaseMetaData
   *
   * @version  $Revision: 1.5 $
   * @author <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
   */
  public final class DatabaseMetaDataWrapper implements DatabaseMetaData {
  
      private final DatabaseMetaData delegate_;
      private boolean isOpen_ = true;
      private ConnectionWrapper connection_;
      private final List openResultSets_ = new ArrayList();
  
  
      /***
       *  Create a wrapper
       *
       * @param  metaData The object to be wrapped
       */
      public DatabaseMetaDataWrapper( final DatabaseMetaData metaData ) {
          if( metaData == null ) {
              throw new NullPointerException( "metaData" );
          }
          delegate_ = metaData;
      }
  
  
      /***
       *  Set the connection that will be returned by getConnection()
       *
       * @param  connection the connection
       */
      public final void setConnection( final ConnectionWrapper connection ) {
          connection_ = connection;
      }
  
  
      /***
       *  Return the wrapped object
       *
       * @return  The wrapped object
       */
      public final DatabaseMetaData getDelegate() {
          return delegate_;
      }
  
  
      /***
       *  What's the url for this database?
       *
       * @return  the url or null if it cannot be generated
       * @exception  SQLException if a database access error occurs
      */
     public final String getURL()
         throws SQLException {
         checkIsOpen();
         return delegate_.getURL();
     }
 
 
     /***
      *  What's our user name as known to the database?
      *
      * @return  our database user name
      * @exception  SQLException if a database access error occurs
      */
     public final String getUserName()
         throws SQLException {
         checkIsOpen();
         return delegate_.getUserName();
     }
 
 
     /***
      *  Is the database in read-only mode?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean isReadOnly()
         throws SQLException {
         checkIsOpen();
         return delegate_.isReadOnly();
     }
 
 
     /***
      *  What's the name of this database product?
      *
      * @return  database product name
      * @exception  SQLException if a database access error occurs
      */
     public final String getDatabaseProductName()
         throws SQLException {
         checkIsOpen();
         return delegate_.getDatabaseProductName();
     }
 
 
     /***
      *  What's the version of this database product?
      *
      * @return  database version
      * @exception  SQLException if a database access error occurs
      */
     public final String getDatabaseProductVersion()
         throws SQLException {
         checkIsOpen();
         return delegate_.getDatabaseProductVersion();
     }
 
 
     /***
      *  What's the name of this JDBC driver?
      *
      * @return  JDBC driver name
      * @exception  SQLException if a database access error occurs
      */
     public final String getDriverName()
         throws SQLException {
         checkIsOpen();
         return delegate_.getDriverName();
     }
 
 
     /***
      *  What's the version of this JDBC driver?
      *
      * @return  JDBC driver version
      * @exception  SQLException if a database access error occurs
      */
     public final String getDriverVersion()
         throws SQLException {
         checkIsOpen();
         return delegate_.getDriverVersion();
     }
 
 
     /***
      *  What's this JDBC driver's major version number?
      *
      * @return  JDBC driver major version
      */
     public final int getDriverMajorVersion() {
         try {
             checkIsOpen();
         }
         catch( final SQLException e ) {
             throw new IllegalStateException( e.getMessage() );
         }
         return delegate_.getDriverMajorVersion();
     }
 
 
     /***
      *  What's this JDBC driver's minor version number?
      *
      * @return  JDBC driver minor version number
      */
     public final int getDriverMinorVersion() {
         try {
             checkIsOpen();
         }
         catch( final SQLException e ) {
             throw new IllegalStateException( e.getMessage() );
         }
         return delegate_.getDriverMinorVersion();
     }
 
 
     /***
      *  Return the string used to quote SQL identifiers.  This returns a space "
      *  " if identifier quoting isn't supported. A JDBC Compliant<sup><font
      *  size=-2>TM</font></sup> driver always uses a double quote character.
      *
      * @return  the quoting string
      * @exception  SQLException if a database access error occurs
      */
     public final String getIdentifierQuoteString()
         throws SQLException {
         checkIsOpen();
         return delegate_.getIdentifierQuoteString();
     }
 
 
     /***
      *  Gets a comma-separated list of all a database's SQL keywords that are
      *  NOT also SQL92 keywords.
      *
      * @return  the list
      * @exception  SQLException if a database access error occurs
      */
     public final String getSQLKeywords()
         throws SQLException {
         checkIsOpen();
         return delegate_.getSQLKeywords();
     }
 
 
     /***
      *  Gets a comma-separated list of math functions. These are the X/Open CLI
      *  math function names used in the JDBC function escape clause.
      *
      * @return  the list
      * @exception  SQLException if a database access error occurs
      */
     public final String getNumericFunctions()
         throws SQLException {
         checkIsOpen();
         return delegate_.getNumericFunctions();
     }
 
 
     /***
      *  Gets a comma-separated list of string functions. These are the X/Open
      *  CLI string function names used in the JDBC function escape clause.
      *
      * @return  the list
      * @exception  SQLException if a database access error occurs
      */
     public final String getStringFunctions()
         throws SQLException {
         checkIsOpen();
         return delegate_.getStringFunctions();
     }
 
 
     /***
      *  Gets a comma-separated list of system functions. These are the X/Open
      *  CLI system function names used in the JDBC function escape clause.
      *
      * @return  the list
      * @exception  SQLException if a database access error occurs
      */
     public final String getSystemFunctions()
         throws SQLException {
         checkIsOpen();
         return delegate_.getSystemFunctions();
     }
 
 
     /***
      *  Gets a comma-separated list of time and date functions.
      *
      * @return  the list
      * @exception  SQLException if a database access error occurs
      */
     public final String getTimeDateFunctions()
         throws SQLException {
         checkIsOpen();
         return delegate_.getTimeDateFunctions();
     }
 
 
     /***
      *  Gets the string that can be used to escape wildcard characters. This is
      *  the string that can be used to escape '_' or '%' in the string pattern
      *  style catalog search parameters. <P>
      *
      *  The '_' character represents any single character. <P>
      *
      *  The '%' character represents any sequence of zero or more characters.
      *
      * @return  the string used to escape wildcard characters
      * @exception  SQLException if a database access error occurs
      */
     public final String getSearchStringEscape()
         throws SQLException {
         checkIsOpen();
         return delegate_.getSearchStringEscape();
     }
 
 
     /***
      *  Gets all the "extra" characters that can be used in unquoted identifier
      *  names (those beyond a-z, A-Z, 0-9 and _).
      *
      * @return  the string containing the extra characters
      * @exception  SQLException if a database access error occurs
      */
     public final String getExtraNameCharacters()
         throws SQLException {
         checkIsOpen();
         return delegate_.getExtraNameCharacters();
     }
 
 
     /***
      *  What's the database vendor's preferred term for "schema"?
      *
      * @return  the vendor term
      * @exception  SQLException if a database access error occurs
      */
     public final String getSchemaTerm()
         throws SQLException {
         checkIsOpen();
         return delegate_.getSchemaTerm();
     }
 
 
     /***
      *  What's the database vendor's preferred term for "procedure"?
      *
      * @return  the vendor term
      * @exception  SQLException if a database access error occurs
      */
     public final String getProcedureTerm()
         throws SQLException {
         checkIsOpen();
         return delegate_.getProcedureTerm();
     }
 
 
     /***
      *  What's the database vendor's preferred term for "catalog"?
      *
      * @return  the vendor term
      * @exception  SQLException if a database access error occurs
      */
     public final String getCatalogTerm()
         throws SQLException {
         checkIsOpen();
         return delegate_.getCatalogTerm();
     }
 
 
     /***
      *  Return true if a catalog appears at the start of a qualified table name. (Otherwise
      *  it appears at the end)
      *
      * @return  true if it appears at the start
      * @exception  SQLException if a database access error occurs
      */
     public final boolean isCatalogAtStart()
         throws SQLException {
         checkIsOpen();
         return delegate_.isCatalogAtStart();
     }
 
 
     /***
      *  What's the separator between catalog and table name?
      *
      * @return  the separator string
      * @exception  SQLException if a database access error occurs
      */
     public final String getCatalogSeparator()
         throws SQLException {
         checkIsOpen();
         return delegate_.getCatalogSeparator();
     }
 
 
     //----------------------------------------------------------------------
     // 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 binary literal length in hex characters; a result of zero
      *      means that there is no limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxBinaryLiteralLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxBinaryLiteralLength();
     }
 
 
     /***
      *  What's the max length for a character literal?
      *
      * @return  max literal length; a result of zero means that there is no
      *      limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxCharLiteralLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxCharLiteralLength();
     }
 
 
     /***
      *  What's the limit on column name length?
      *
      * @return  max column name length; a result of zero means that there is no
      *      limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxColumnNameLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxColumnNameLength();
     }
 
 
     /***
      *  What's the maximum number of columns in a "GROUP BY" clause?
      *
      * @return  max number of columns; a result of zero means that there is no
      *      limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxColumnsInGroupBy()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxColumnsInGroupBy();
     }
 
 
     /***
      *  What's the maximum number of columns allowed in an index?
      *
      * @return  max number of columns; a result of zero means that there is no
      *      limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxColumnsInIndex()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxColumnsInIndex();
     }
 
 
     /***
      *  What's the maximum number of columns in an "ORDER BY" clause?
      *
      * @return  max number of columns; a result of zero means that there is no
      *      limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxColumnsInOrderBy()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxColumnsInOrderBy();
     }
 
 
     /***
      *  What's the maximum number of columns in a "SELECT" list?
      *
      * @return  max number of columns; a result of zero means that there is no
      *      limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxColumnsInSelect()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxColumnsInSelect();
     }
 
 
     /***
      *  What's the maximum number of columns in a table?
      *
      * @return  max number of columns; a result of zero means that there is no
      *      limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxColumnsInTable()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxColumnsInTable();
     }
 
 
     /***
      *  How many active connections can we have at a time to this database?
      *
      * @return  max number of active connections; a result of zero means that
      *      there is no limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxConnections()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxConnections();
     }
 
 
     /***
      *  What's the maximum cursor name length?
      *
      * @return  max cursor name length in bytes; a result of zero means that
      *      there is no limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxCursorNameLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxCursorNameLength();
     }
 
 
     /***
      *  Retrieves the maximum number of bytes for an index, including all of the
      *  parts of the index.
      *
      * @return  max index length in bytes, which includes the composite of all
      *      the constituent parts of the index; a result of zero means that
      *      there is no limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxIndexLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxIndexLength();
     }
 
 
     /***
      *  What's the maximum length allowed for a schema name?
      *
      * @return  max name length in bytes; a result of zero means that there is
      *      no limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxSchemaNameLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxSchemaNameLength();
     }
 
 
     /***
      *  What's the maximum length of a procedure name?
      *
      * @return  max name length in bytes; a result of zero means that there is
      *      no limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxProcedureNameLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxProcedureNameLength();
     }
 
 
     /***
      *  What's the maximum length of a catalog name?
      *
      * @return  max name length in bytes; a result of zero means that there is
      *      no limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxCatalogNameLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxCatalogNameLength();
     }
 
 
     /***
      *  What's the maximum length of a single row?
      *
      * @return  max row size in bytes; a result of zero means that there is no
      *      limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxRowSize()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxRowSize();
     }
 
 
     /***
      *  What's the maximum length of an SQL statement?
      *
      * @return  max length in bytes; a result of zero means that there is no
      *      limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxStatementLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxStatementLength();
     }
 
 
     /***
      *  How many active statements can we have open at one time to this
      *  database?
      *
      * @return  the maximum number of statements that can be open at one time; a
      *      result of zero means that there is no limit or the limit is not
      *      known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxStatements()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxStatements();
     }
 
 
     /***
      *  What's the maximum length of a table name?
      *
      * @return  max name length in bytes; a result of zero means that there is
      *      no limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxTableNameLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxTableNameLength();
     }
 
 
     /***
      *  What's the maximum number of tables in a SELECT statement?
      *
      * @return  the maximum number of tables allowed in a SELECT statement; a
      *      result of zero means that there is no limit or the limit is not
      *      known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxTablesInSelect()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxTablesInSelect();
     }
 
 
     /***
      *  What's the maximum length of a user name?
      *
      * @return  max user name length in bytes; a result of zero means that there
      *      is no limit or the limit is not known
      * @exception  SQLException if a database access error occurs
      */
     public final int getMaxUserNameLength()
         throws SQLException {
         checkIsOpen();
         return delegate_.getMaxUserNameLength();
     }
 
     //----------------------------------------------------------------------
 
     /***
      *  Return the database's default transaction isolation level.  The values
      *  are defined in <code>java.sql.Connection</code>.
      *
      * @return  the default isolation level
      * @exception  SQLException if a database access error occurs
      */
     public final int getDefaultTransactionIsolation()
         throws SQLException {
         checkIsOpen();
         return delegate_.getDefaultTransactionIsolation();
     }
 
 
     /***
      *  Gets a description of the stored procedures available in a catalog. <P>
      *
      *  Only procedure descriptions matching the schema and procedure name
      *  criteria are returned. They are ordered by PROCEDURE_SCHEM, and
      *  PROCEDURE_NAME. <P>
      *
      *  Each procedure description has the the following columns:
      *  <OL>
      *    <LI> <B>PROCEDURE_CAT</B> String => procedure catalog (may be null)
      *
      *    <LI> <B>PROCEDURE_SCHEM</B> String => procedure schema (may be null)
      *
      *    <LI> <B>PROCEDURE_NAME</B> String => procedure name
      *    <LI> reserved for future use
      *    <LI> reserved for future use
      *    <LI> reserved for future use
      *    <LI> <B>REMARKS</B> String => explanatory comment on the procedure
      *
      *    <LI> <B>PROCEDURE_TYPE</B> short => kind of procedure:
      *    <UL>
      *      <LI> procedureResultUnknown - May return a result
      *      <LI> procedureNoResult - Does not return a result
      *      <LI> procedureReturnsResult - Returns a result
      *    </UL>
      *
      *  </OL>
      *
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schemaPattern a schema name pattern; "" retrieves those without a
      *      schema
      * @param  procedureNamePattern a procedure name pattern
      * @return  <code>ResultSet</code> - each row is a procedure description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getProcedures( String catalog, String schemaPattern,
             String procedureNamePattern )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getProcedures( catalog, schemaPattern, procedureNamePattern ) );
     }
 
 
     /***
      *  Gets a description of a catalog's stored procedure parameters and result
      *  columns. <P>
      *
      *  Only descriptions matching the schema, procedure and parameter name
      *  criteria are returned. They are ordered by PROCEDURE_SCHEM and
      *  PROCEDURE_NAME. Within this, the return value, if any, is first. Next
      *  are the parameter descriptions in call order. The column descriptions
      *  follow in column number order. <P>
      *
      *  Each row in the <code>ResultSet</code> is a parameter description or
      *  column description with the following fields:
      *  <OL>
      *    <LI> <B>PROCEDURE_CAT</B> String => procedure catalog (may be null)
      *
      *    <LI> <B>PROCEDURE_SCHEM</B> String => procedure schema (may be null)
      *
      *    <LI> <B>PROCEDURE_NAME</B> String => procedure name
      *    <LI> <B>COLUMN_NAME</B> String => column/parameter name
      *    <LI> <B>COLUMN_TYPE</B> Short => kind of column/parameter:
      *    <UL>
      *      <LI> procedureColumnUnknown - nobody knows
      *      <LI> procedureColumnIn - IN parameter
      *      <LI> procedureColumnInOut - INOUT parameter
      *      <LI> procedureColumnOut - OUT parameter
      *      <LI> procedureColumnReturn - procedure return value
      *      <LI> procedureColumnResult - result column in <code>ResultSet</code>
      *
      *    </UL>
      *
      *    <LI> <B>DATA_TYPE</B> short => SQL type from java.sql.Types
      *    <LI> <B>TYPE_NAME</B> String => SQL type name, for a UDT type the type
      *    name is fully qualified
      *    <LI> <B>PRECISION</B> int => precision
      *    <LI> <B>LENGTH</B> int => length in bytes of data
      *    <LI> <B>SCALE</B> short => scale
      *    <LI> <B>RADIX</B> short => radix
      *    <LI> <B>NULLABLE</B> short => can it contain NULL?
      *    <UL>
      *      <LI> procedureNoNulls - does not allow NULL values
      *      <LI> procedureNullable - allows NULL values
      *      <LI> procedureNullableUnknown - nullability unknown
      *    </UL>
      *
      *    <LI> <B>REMARKS</B> String => comment describing parameter/column
      *
      *  </OL>
      *  <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.
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schemaPattern a schema name pattern; "" retrieves those without a
      *      schema
      * @param  procedureNamePattern a procedure name pattern
      * @param  columnNamePattern a column name pattern
      * @return  <code>ResultSet</code> - each row describes a stored procedure
      *      parameter or column
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getProcedureColumns( String catalog,
             String schemaPattern,
             String procedureNamePattern,
             String columnNamePattern )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getProcedureColumns( catalog, schemaPattern, procedureNamePattern, columnNamePattern ) );
     }
 
 
     /***
      *  Gets a description of tables available in a catalog. <P>
      *
      *  Only table descriptions matching the catalog, schema, table name and
      *  type criteria are returned. They are ordered by TABLE_TYPE, TABLE_SCHEM
      *  and TABLE_NAME. <P>
      *
      *  Each table description has the following columns:
      *  <OL>
      *    <LI> <B>TABLE_CAT</B> String => table catalog (may be null)
      *    <LI> <B>TABLE_SCHEM</B> String => table schema (may be null)
      *    <LI> <B>TABLE_NAME</B> String => table name
      *    <LI> <B>TABLE_TYPE</B> String => table type. Typical types are
      *    "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL
      *    TEMPORARY", "ALIAS", "SYNONYM".
      *    <LI> <B>REMARKS</B> String => explanatory comment on the table
      *  </OL>
      *  <P>
      *
      *  <B>Note:</B> Some databases may not return information for all tables.
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schemaPattern a schema name pattern; "" retrieves those without a
      *      schema
      * @param  tableNamePattern a table name pattern
      * @param  types a list of table types to include; null returns all types
      * @return  <code>ResultSet</code> - each row is a table description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getTables( String catalog, String schemaPattern,
             String tableNamePattern, String types[] )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getTables( catalog, schemaPattern, tableNamePattern, types ) );
     }
 
 
     /***
      *  Gets the schema names available in this database. The results are
      *  ordered by schema name. <P>
      *
      *  The schema column is:
      *  <OL>
      *    <LI> <B>TABLE_SCHEM</B> String => schema name
      *  </OL>
      *
      *
      * @return  <code>ResultSet</code> - each row has a single String column
      *      that is a schema name
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getSchemas()
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getSchemas() );
     }
 
 
     /***
      *  Gets 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
      *  </OL>
      *
      *
      * @return  <code>ResultSet</code> - each row has a single String column
      *      that is a catalog name
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getCatalogs()
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getCatalogs() );
     }
 
 
     /***
      *  Gets the table types available in this database. The results are ordered
      *  by table type. <P>
      *
      *  The table type is:
      *  <OL>
      *    <LI> <B>TABLE_TYPE</B> String => table type. Typical types are
      *    "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL
      *    TEMPORARY", "ALIAS", "SYNONYM".
      *  </OL>
      *
      *
      * @return  <code>ResultSet</code> - each row has a single String column
      *      that is a table type
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getTableTypes()
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getTableTypes() );
     }
 
 
     /***
      *  Gets a description of table columns available in the specified catalog.
      *  <P>
      *
      *  Only column descriptions matching the catalog, schema, table and column
      *  name criteria are returned. They are ordered by TABLE_SCHEM, TABLE_NAME
      *  and ORDINAL_POSITION. <P>
      *
      *  Each column description has the following columns:
      *  <OL>
      *    <LI> <B>TABLE_CAT</B> String => table catalog (may be null)
      *    <LI> <B>TABLE_SCHEM</B> String => table schema (may be null)
      *    <LI> <B>TABLE_NAME</B> String => table name
      *    <LI> <B>COLUMN_NAME</B> String => column name
      *    <LI> <B>DATA_TYPE</B> short => SQL type from java.sql.Types
      *    <LI> <B>TYPE_NAME</B> String => Data source dependent type name, for a
      *    UDT the type name is fully qualified
      *    <LI> <B>COLUMN_SIZE</B> int => column size. For char or date types
      *    this is the maximum number of characters, for numeric or decimal types
      *    this is precision.
      *    <LI> <B>BUFFER_LENGTH</B> is not used.
      *    <LI> <B>DECIMAL_DIGITS</B> int => the number of fractional digits
      *    <LI> <B>NUM_PREC_RADIX</B> int => Radix (typically either 10 or 2)
      *
      *    <LI> <B>NULLABLE</B> int => is NULL allowed?
      *    <UL>
      *      <LI> columnNoNulls - might not allow NULL values
      *      <LI> columnNullable - definitely allows NULL values
      *      <LI> columnNullableUnknown - nullability unknown
      *    </UL>
      *
      *    <LI> <B>REMARKS</B> String => comment describing column (may be null)
      *
      *    <LI> <B>COLUMN_DEF</B> String => default value (may be null)
      *    <LI> <B>SQL_DATA_TYPE</B> int => unused
      *    <LI> <B>SQL_DATETIME_SUB</B> int => unused
      *    <LI> <B>CHAR_OCTET_LENGTH</B> int => for char types the maximum number
      *    of bytes in the column
      *    <LI> <B>ORDINAL_POSITION</B> int => index of column in table (starting
      *    at 1)
      *    <LI> <B>IS_NULLABLE</B> String => "NO" means column definitely does
      *    not allow NULL values; "YES" means the column might allow NULL values.
      *    An empty string means nobody knows.
      *  </OL>
      *
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schemaPattern a schema name pattern; "" retrieves those without a
      *      schema
      * @param  tableNamePattern a table name pattern
      * @param  columnNamePattern a column name pattern
      * @return  <code>ResultSet</code> - each row is a column description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getColumns( String catalog, String schemaPattern,
             String tableNamePattern, String columnNamePattern )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getColumns( catalog, schemaPattern, tableNamePattern, columnNamePattern ) );
     }
 
 
     /***
      *  Gets 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>
      *
      *  Each privilige description has the following columns:
      *  <OL>
      *    <LI> <B>TABLE_CAT</B> String => table catalog (may be null)
      *    <LI> <B>TABLE_SCHEM</B> String => table schema (may be null)
      *    <LI> <B>TABLE_NAME</B> String => table name
      *    <LI> <B>COLUMN_NAME</B> String => column name
      *    <LI> <B>GRANTOR</B> => grantor of access (may be null)
      *    <LI> <B>GRANTEE</B> String => grantee of access
      *    <LI> <B>PRIVILEGE</B> String => name of access (SELECT, INSERT,
      *    UPDATE, REFRENCES, ...)
      *    <LI> <B>IS_GRANTABLE</B> String => "YES" if grantee is permitted to
      *    grant to others; "NO" if not; null if unknown
      *  </OL>
      *
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schema a schema name; "" retrieves those without a schema
      * @param  table a table name
      * @param  columnNamePattern a column name pattern
      * @return  <code>ResultSet</code> - each row is a column privilege
      *      description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getColumnPrivileges( String catalog, String schema,
             String table, String columnNamePattern )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getColumnPrivileges( catalog, schema, table, columnNamePattern ) );
     }
 
 
     /***
      *  Gets a description of the access rights for each table available in a
      *  catalog. Note that a table privilege applies to one or more columns in
      *  the table. It would be wrong to assume that this priviledge applies to
      *  all columns (this may be true for some systems but is not true for all.)
      *  <P>
      *
      *  Only privileges matching the schema and table name criteria are
      *  returned. They are ordered by TABLE_SCHEM, TABLE_NAME, and PRIVILEGE.
      *  <P>
      *
      *  Each privilige description has the following columns:
      *  <OL>
      *    <LI> <B>TABLE_CAT</B> String => table catalog (may be null)
      *    <LI> <B>TABLE_SCHEM</B> String => table schema (may be null)
      *    <LI> <B>TABLE_NAME</B> String => table name
      *    <LI> <B>GRANTOR</B> => grantor of access (may be null)
      *    <LI> <B>GRANTEE</B> String => grantee of access
      *    <LI> <B>PRIVILEGE</B> String => name of access (SELECT, INSERT,
      *    UPDATE, REFRENCES, ...)
      *    <LI> <B>IS_GRANTABLE</B> String => "YES" if grantee is permitted to
      *    grant to others; "NO" if not; null if unknown
      *  </OL>
      *
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schemaPattern a schema name pattern; "" retrieves those without a
      *      schema
      * @param  tableNamePattern a table name pattern
      * @return  <code>ResultSet</code> - each row is a table privilege
      *      description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getTablePrivileges( String catalog, String schemaPattern,
             String tableNamePattern )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getTablePrivileges( catalog, schemaPattern, tableNamePattern ) );
     }
 
 
     /***
      *  Gets 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> bestRowTransaction - valid for remainder of current transaction
      *
      *      <LI> bestRowSession - valid for remainder of current session
      *    </UL>
      *
      *    <LI> <B>COLUMN_NAME</B> String => column name
      *    <LI> <B>DATA_TYPE</B> short => SQL data type from java.sql.Types
      *    <LI> <B>TYPE_NAME</B> String => Data source dependent type name, for a
      *    UDT the type name is fully qualified
      *    <LI> <B>COLUMN_SIZE</B> int => precision
      *    <LI> <B>BUFFER_LENGTH</B> int => not used
      *    <LI> <B>DECIMAL_DIGITS</B> short => scale
      *    <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> bestRowNotPseudo - is NOT a pseudo column
      *      <LI> bestRowPseudo - is a pseudo column
      *    </UL>
      *
      *  </OL>
      *
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @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  <code>ResultSet</code> - each row is a column description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getBestRowIdentifier( String catalog, String schema,
             String table, int scope, boolean nullable )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getBestRowIdentifier( catalog, schema, table, scope, nullable ) );
     }
 
 
     /***
      *  Gets a description of a table's columns that are automatically updated
      *  when any value in a row is updated. They are unordered. <P>
      *
      *  Each column description has the following columns:
      *  <OL>
      *    <LI> <B>SCOPE</B> short => is not used
      *    <LI> <B>COLUMN_NAME</B> String => column name
      *    <LI> <B>DATA_TYPE</B> short => SQL data type from java.sql.Types
      *    <LI> <B>TYPE_NAME</B> String => Data source dependent type name
      *    <LI> <B>COLUMN_SIZE</B> int => precision
      *    <LI> <B>BUFFER_LENGTH</B> int => length of column value in bytes
      *    <LI> <B>DECIMAL_DIGITS</B> short => scale
      *    <LI> <B>PSEUDO_COLUMN</B> short => is this a pseudo column like an
      *    Oracle ROWID
      *    <UL>
      *      <LI> versionColumnUnknown - may or may not be pseudo column
      *      <LI> versionColumnNotPseudo - is NOT a pseudo column
      *      <LI> versionColumnPseudo - is a pseudo column
      *    </UL>
      *
      *  </OL>
      *
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schema a schema name; "" retrieves those without a schema
      * @param  table a table name
      * @return  <code>ResultSet</code> - each row is a column description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getVersionColumns( String catalog, String schema,
             String table )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getVersionColumns( catalog, schema, table ) );
     }
 
 
     /***
      *  Gets a description of a table's primary key columns. They are ordered by
      *  COLUMN_NAME. <P>
      *
      *  Each primary key column description has the following columns:
      *  <OL>
      *    <LI> <B>TABLE_CAT</B> String => table catalog (may be null)
      *    <LI> <B>TABLE_SCHEM</B> String => table schema (may be null)
      *    <LI> <B>TABLE_NAME</B> String => table name
      *    <LI> <B>COLUMN_NAME</B> String => column name
      *    <LI> <B>KEY_SEQ</B> short => sequence number within primary key
      *    <LI> <B>PK_NAME</B> String => primary key name (may be null)
      *  </OL>
      *
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schema a schema name; "" retrieves those without a schema
      * @param  table a table name
      * @return  <code>ResultSet</code> - each row is a primary key column
      *      description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getPrimaryKeys( String catalog, String schema,
             String table )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getPrimaryKeys( catalog, schema, table ) );
     }
 
 
     /***
      *  Gets a description of the primary key columns that are referenced by a
      *  table's foreign key columns (the primary keys imported by a table). They
      *  are ordered by PKTABLE_CAT, PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ.
      *  <P>
      *
      *  Each primary key column description has the following columns:
      *  <OL>
      *    <LI> <B>PKTABLE_CAT</B> String => primary key table catalog being
      *    imported (may be null)
      *    <LI> <B>PKTABLE_SCHEM</B> String => primary key table schema being
      *    imported (may be null)
      *    <LI> <B>PKTABLE_NAME</B> String => primary key table name being
      *    imported
      *    <LI> <B>PKCOLUMN_NAME</B> String => primary key column name being
      *    imported
      *    <LI> <B>FKTABLE_CAT</B> String => foreign key table catalog (may be
      *    null)
      *    <LI> <B>FKTABLE_SCHEM</B> String => foreign key table schema (may be
      *    null)
      *    <LI> <B>FKTABLE_NAME</B> String => foreign key table name
      *    <LI> <B>FKCOLUMN_NAME</B> String => foreign key column name
      *    <LI> <B>KEY_SEQ</B> short => sequence number within foreign key
      *    <LI> <B>UPDATE_RULE</B> short => What happens to foreign key when
      *    primary is updated:
      *    <UL>
      *      <LI> importedNoAction - do not allow update of primary key if it has
      *      been imported
      *      <LI> importedKeyCascade - change imported key to agree with primary
      *      key update
      *      <LI> importedKeySetNull - change imported key to NULL if its primary
      *      key has been updated
      *      <LI> importedKeySetDefault - change imported key to default values
      *      if its primary key has been updated
      *      <LI> importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
      *      compatibility)
      *    </UL>
      *
      *    <LI> <B>DELETE_RULE</B> short => What happens to the foreign key when
      *    primary is deleted.
      *    <UL>
      *      <LI> importedKeyNoAction - do not allow delete of primary key if it
      *      has been imported
      *      <LI> importedKeyCascade - delete rows that import a deleted key
      *      <LI> importedKeySetNull - change imported key to NULL if its primary
      *      key has been deleted
      *      <LI> importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
      *      compatibility)
      *      <LI> importedKeySetDefault - change imported key to default if its
      *      primary key has been deleted
      *    </UL>
      *
      *    <LI> <B>FK_NAME</B> String => foreign key name (may be null)
      *    <LI> <B>PK_NAME</B> String => primary key name (may be null)
      *    <LI> <B>DEFERRABILITY</B> short => can the evaluation of foreign key
      *    constraints be deferred until commit
      *    <UL>
      *      <LI> importedKeyInitiallyDeferred - see SQL92 for definition
      *      <LI> importedKeyInitiallyImmediate - see SQL92 for definition
      *      <LI> importedKeyNotDeferrable - see SQL92 for definition
      *    </UL>
      *
      *  </OL>
      *
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schema a schema name; "" retrieves those without a schema
      * @param  table a table name
      * @return  <code>ResultSet</code> - each row is a primary key column
      *      description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getImportedKeys( String catalog, String schema,
             String table )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getImportedKeys( catalog, schema, table ) );
     }
 
 
     /***
      *  Gets a description of the foreign key columns that reference a table's
      *  primary key columns (the foreign keys exported by a table). They are
      *  ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and KEY_SEQ. <P>
      *
      *  Each foreign key column description has the following columns:
      *  <OL>
      *    <LI> <B>PKTABLE_CAT</B> String => primary key table catalog (may be
      *    null)
      *    <LI> <B>PKTABLE_SCHEM</B> String => primary key table schema (may be
      *    null)
      *    <LI> <B>PKTABLE_NAME</B> String => primary key table name
      *    <LI> <B>PKCOLUMN_NAME</B> String => primary key column name
      *    <LI> <B>FKTABLE_CAT</B> String => foreign key table catalog (may be
      *    null) being exported (may be null)
      *    <LI> <B>FKTABLE_SCHEM</B> String => foreign key table schema (may be
      *    null) being exported (may be null)
      *    <LI> <B>FKTABLE_NAME</B> String => foreign key table name being
      *    exported
      *    <LI> <B>FKCOLUMN_NAME</B> String => foreign key column name being
      *    exported
      *    <LI> <B>KEY_SEQ</B> short => sequence number within foreign key
      *    <LI> <B>UPDATE_RULE</B> short => What happens to foreign key when
      *    primary is updated:
      *    <UL>
      *      <LI> importedNoAction - do not allow update of primary key if it has
      *      been imported
      *      <LI> importedKeyCascade - change imported key to agree with primary
      *      key update
      *      <LI> importedKeySetNull - change imported key to NULL if its primary
      *      key has been updated
      *      <LI> importedKeySetDefault - change imported key to default values
      *      if its primary key has been updated
      *      <LI> importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
      *      compatibility)
      *    </UL>
      *
      *    <LI> <B>DELETE_RULE</B> short => What happens to the foreign key when
      *    primary is deleted.
      *    <UL>
      *      <LI> importedKeyNoAction - do not allow delete of primary key if it
      *      has been imported
      *      <LI> importedKeyCascade - delete rows that import a deleted key
      *      <LI> importedKeySetNull - change imported key to NULL if its primary
      *      key has been deleted
      *      <LI> importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
      *      compatibility)
      *      <LI> importedKeySetDefault - change imported key to default if its
      *      primary key has been deleted
      *    </UL>
      *
      *    <LI> <B>FK_NAME</B> String => foreign key name (may be null)
      *    <LI> <B>PK_NAME</B> String => primary key name (may be null)
      *    <LI> <B>DEFERRABILITY</B> short => can the evaluation of foreign key
      *    constraints be deferred until commit
      *    <UL>
      *      <LI> importedKeyInitiallyDeferred - see SQL92 for definition
      *      <LI> importedKeyInitiallyImmediate - see SQL92 for definition
      *      <LI> importedKeyNotDeferrable - see SQL92 for definition
      *    </UL>
      *
      *  </OL>
      *
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schema a schema name; "" retrieves those without a schema
      * @param  table a table name
      * @return  <code>ResultSet</code> - each row is a foreign key column
      *      description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getExportedKeys( String catalog, String schema,
             String table )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getExportedKeys( catalog, schema, table ) );
     }
 
 
     /***
      *  Gets a description of the foreign key columns in the foreign key table
      *  that reference the primary key columns of the primary key table
      *  (describe how one table imports another's key). This should normally
      *  return a single foreign key/primary key pair (most tables only import a
      *  foreign key from a table once.) They are ordered by FKTABLE_CAT,
      *  FKTABLE_SCHEM, FKTABLE_NAME, and KEY_SEQ. <P>
      *
      *  Each foreign key column description has the following columns:
      *  <OL>
      *    <LI> <B>PKTABLE_CAT</B> String => primary key table catalog (may be
      *    null)
      *    <LI> <B>PKTABLE_SCHEM</B> String => primary key table schema (may be
      *    null)
      *    <LI> <B>PKTABLE_NAME</B> String => primary key table name
      *    <LI> <B>PKCOLUMN_NAME</B> String => primary key column name
      *    <LI> <B>FKTABLE_CAT</B> String => foreign key table catalog (may be
      *    null) being exported (may be null)
      *    <LI> <B>FKTABLE_SCHEM</B> String => foreign key table schema (may be
      *    null) being exported (may be null)
      *    <LI> <B>FKTABLE_NAME</B> String => foreign key table name being
      *    exported
      *    <LI> <B>FKCOLUMN_NAME</B> String => foreign key column name being
      *    exported
      *    <LI> <B>KEY_SEQ</B> short => sequence number within foreign key
      *    <LI> <B>UPDATE_RULE</B> short => What happens to foreign key when
      *    primary is updated:
      *    <UL>
      *      <LI> importedNoAction - do not allow update of primary key if it has
      *      been imported
      *      <LI> importedKeyCascade - change imported key to agree with primary
      *      key update
      *      <LI> importedKeySetNull - change imported key to NULL if its primary
      *      key has been updated
      *      <LI> importedKeySetDefault - change imported key to default values
      *      if its primary key has been updated
      *      <LI> importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
      *      compatibility)
      *    </UL>
      *
      *    <LI> <B>DELETE_RULE</B> short => What happens to the foreign key when
      *    primary is deleted.
      *    <UL>
      *      <LI> importedKeyNoAction - do not allow delete of primary key if it
      *      has been imported
      *      <LI> importedKeyCascade - delete rows that import a deleted key
      *      <LI> importedKeySetNull - change imported key to NULL if its primary
      *      key has been deleted
      *      <LI> importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
      *      compatibility)
      *      <LI> importedKeySetDefault - change imported key to default if its
      *      primary key has been deleted
      *    </UL>
      *
      *    <LI> <B>FK_NAME</B> String => foreign key name (may be null)
      *    <LI> <B>PK_NAME</B> String => primary key name (may be null)
      *    <LI> <B>DEFERRABILITY</B> short => can the evaluation of foreign key
      *    constraints be deferred until commit
      *    <UL>
      *      <LI> importedKeyInitiallyDeferred - see SQL92 for definition
      *      <LI> importedKeyInitiallyImmediate - see SQL92 for definition
      *      <LI> importedKeyNotDeferrable - see SQL92 for definition
      *    </UL>
      *
      *  </OL>
      *
      *
      * @param  primaryCatalog a catalog name; "" retrieves those without a
      *      catalog; null means drop catalog name from the selection criteria
      * @param  primarySchema a schema name; "" retrieves those without a schema
      * @param  primaryTable the table name that exports the key
      * @param  foreignCatalog a catalog name; "" retrieves those without a
      *      catalog; null means drop catalog name from the selection criteria
      * @param  foreignSchema a schema name; "" retrieves those without a schema
      * @param  foreignTable the table name that imports the key
      * @return  <code>ResultSet</code> - each row is a foreign key column
      *      description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getCrossReference(
             String primaryCatalog, String primarySchema, String primaryTable,
             String foreignCatalog, String foreignSchema, String foreignTable
              )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getCrossReference( primaryCatalog, primarySchema, primaryTable,
                 foreignCatalog, foreignSchema, foreignTable ) );
     }
 
 
     /***
      *  Gets a description of all the standard SQL types supported by this
      *  database. They are ordered by DATA_TYPE and then by how closely the data
      *  type maps to the corresponding JDBC SQL type. <P>
      *
      *  Each type description has the following columns:
      *  <OL>
      *    <LI> <B>TYPE_NAME</B> String => Type name
      *    <LI> <B>DATA_TYPE</B> short => SQL data type from java.sql.Types
      *    <LI> <B>PRECISION</B> int => maximum precision
      *    <LI> <B>LITERAL_PREFIX</B> String => prefix used to quote a literal
      *    (may be null)
      *    <LI> <B>LITERAL_SUFFIX</B> String => suffix used to quote a literal
      *    (may be null)
      *    <LI> <B>CREATE_PARAMS</B> String => parameters used in creating the
      *    type (may be null)
      *    <LI> <B>NULLABLE</B> short => can you use NULL for this type?
      *    <UL>
      *      <LI> typeNoNulls - does not allow NULL values
      *      <LI> typeNullable - allows NULL values
      *      <LI> typeNullableUnknown - nullability unknown
      *    </UL>
      *
      *    <LI> <B>CASE_SENSITIVE</B> boolean=> is it case sensitive?
      *    <LI> <B>SEARCHABLE</B> short => can you use "WHERE" based on this
      *    type:
      *    <UL>
      *      <LI> typePredNone - No support
      *      <LI> typePredChar - Only supported with WHERE .. LIKE
      *      <LI> typePredBasic - Supported except for WHERE .. LIKE
      *      <LI> typeSearchable - Supported for all WHERE ..
      *    </UL>
      *
      *    <LI> <B>UNSIGNED_ATTRIBUTE</B> boolean => is it unsigned?
      *    <LI> <B>FIXED_PREC_SCALE</B> boolean => can it be a money value?
      *    <LI> <B>AUTO_INCREMENT</B> boolean => can it be used for an
      *    auto-increment value?
      *    <LI> <B>LOCAL_TYPE_NAME</B> String => localized version of type name
      *    (may be null)
      *    <LI> <B>MINIMUM_SCALE</B> short => minimum scale supported
      *    <LI> <B>MAXIMUM_SCALE</B> short => maximum scale supported
      *    <LI> <B>SQL_DATA_TYPE</B> int => unused
      *    <LI> <B>SQL_DATETIME_SUB</B> int => unused
      *    <LI> <B>NUM_PREC_RADIX</B> int => usually 2 or 10
      *  </OL>
      *
      *
      * @return  <code>ResultSet</code> - each row is an SQL type description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getTypeInfo()
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getTypeInfo() );
     }
 
 
     /***
      *  Gets a description of a table's indices and statistics. They are ordered
      *  by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION. <P>
      *
      *  Each index column description has the following columns:
      *  <OL>
      *    <LI> <B>TABLE_CAT</B> String => table catalog (may be null)
      *    <LI> <B>TABLE_SCHEM</B> String => table schema (may be null)
      *    <LI> <B>TABLE_NAME</B> String => table name
      *    <LI> <B>NON_UNIQUE</B> boolean => Can index values be non-unique?
      *    false when TYPE is tableIndexStatistic
      *    <LI> <B>INDEX_QUALIFIER</B> String => index catalog (may be null);
      *    null when TYPE is tableIndexStatistic
      *    <LI> <B>INDEX_NAME</B> String => index name; null when TYPE is
      *    tableIndexStatistic
      *    <LI> <B>TYPE</B> short => index type:
      *    <UL>
      *      <LI> tableIndexStatistic - this identifies table statistics that are
      *      returned in conjuction with a table's index descriptions
      *      <LI> tableIndexClustered - this is a clustered index
      *      <LI> tableIndexHashed - this is a hashed index
      *      <LI> tableIndexOther - this is some other style of index
      *    </UL>
      *
      *    <LI> <B>ORDINAL_POSITION</B> short => column sequence number within
      *    index; zero when TYPE is tableIndexStatistic
      *    <LI> <B>COLUMN_NAME</B> String => column name; null when TYPE is
      *    tableIndexStatistic
      *    <LI> <B>ASC_OR_DESC</B> String => column sort sequence, "A" =>
      *    ascending, "D" => descending, may be null if sort sequence is not
      *    supported; null when TYPE is tableIndexStatistic
      *    <LI> <B>CARDINALITY</B> int => When TYPE is tableIndexStatistic, then
      *    this is the number of rows in the table; otherwise, it is the number
      *    of unique values in the index.
      *    <LI> <B>PAGES</B> int => When TYPE is tableIndexStatisic then this is
      *    the number of pages used for the table, otherwise it is the number of
      *    pages used for the current index.
      *    <LI> <B>FILTER_CONDITION</B> String => Filter condition, if any. (may
      *    be null)
      *  </OL>
      *
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schema a schema name; "" retrieves those without a schema
      * @param  table a table name
      * @param  unique when true, return only indices for unique values; when
      *      false, return indices regardless of whether unique or not
      * @param  approximate when true, result is allowed to reflect approximate
      *      or out of data values; when false, results are requested to be
      *      accurate
      * @return  <code>ResultSet</code> - each row is an index column description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getIndexInfo( String catalog, String schema, String table,
             boolean unique, boolean approximate )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getIndexInfo( catalog, schema, table, unique, approximate ) );
     }
 
 
     /***
      *  Gets a description of the user-defined types defined in a particular
      *  schema. Schema-specific UDTs may have type JAVA_OBJECT, STRUCT, or
      *  DISTINCT. <P>
      *
      *  Only types matching the catalog, schema, type name and type criteria are
      *  returned. They are ordered by DATA_TYPE, TYPE_SCHEM and TYPE_NAME. The
      *  type name parameter may be a fully-qualified name. In this case, the
      *  catalog and schemaPattern parameters are ignored. <P>
      *
      *  Each type description has the following columns:
      *  <OL>
      *    <LI> <B>TYPE_CAT</B> String => the type's catalog (may be null)
      *    <LI> <B>TYPE_SCHEM</B> String => type's schema (may be null)
      *    <LI> <B>TYPE_NAME</B> String => type name
      *    <LI> <B>CLASS_NAME</B> String => Java class name
      *    <LI> <B>DATA_TYPE</B> String => type value defined in java.sql.Types.
      *    One of JAVA_OBJECT, STRUCT, or DISTINCT
      *    <LI> <B>REMARKS</B> String => explanatory comment on the type
      *  </OL>
      *  <P>
      *
      *  <B>Note:</B> If the driver does not support UDTs, an empty result set is
      *  returned.
      *
      * @param  catalog a catalog name; "" retrieves those without a catalog;
      *      null means drop catalog name from the selection criteria
      * @param  schemaPattern a schema name pattern; "" retrieves those without a
      *      schema
      * @param  typeNamePattern a type name pattern; may be a fully-qualified
      *      name
      * @param  types a list of user-named types to include (JAVA_OBJECT, STRUCT,
      *      or DISTINCT); null returns all types
      * @return  <code>ResultSet</code> - each row is a type description
      * @exception  SQLException if a database access error occurs
      */
     public final ResultSet getUDTs( String catalog, String schemaPattern,
             String typeNamePattern, int[] types )
         throws SQLException {
         checkIsOpen();
         return wrap( delegate_.getUDTs( catalog, schemaPattern, typeNamePattern, types ) );
     }
 
 
     /***
      *  Retrieves the connection that produced this metadata object.
      *
      * @return  the connection that produced this metadata object
      * @exception  SQLException If an error occurs
      */
     public final Connection getConnection()
         throws SQLException {
         checkIsOpen();
         return connection_;
     }
 
 
     /***
      *  Close this object and any result sets that it created
      *
      * @exception  SQLException If an error occurs
      */
     public final void close()
         throws SQLException {
         if( isOpen_ ) {
             ResultSetWrapper resultSetWrapper;
             final Iterator iterator = openResultSets_.iterator();
             while( iterator.hasNext() ) {
                 resultSetWrapper = (ResultSetWrapper)iterator.next();
                 if( resultSetWrapper.isClosed() == false ) {
                     resultSetWrapper.close();
                 }
             }
             openResultSets_.clear();
         }
         else {
             throw new AlreadyClosedException( "object is already closed" );
         }
         isOpen_ = false;
     }
 
 
     /***
      *  Return true if all the procedures returned by getProcedures can be called by the
      *  current user.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean allProceduresAreCallable()
         throws SQLException {
         checkIsOpen();
         return delegate_.allProceduresAreCallable();
     }
 
 
     /***
      *  Return true if all the tables returned by getTable can be SELECTed by the current user.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean allTablesAreSelectable()
         throws SQLException {
         checkIsOpen();
         return delegate_.allTablesAreSelectable();
     }
 
 
     /***
      *  Return true if NULL values are sorted high.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean nullsAreSortedHigh()
         throws SQLException {
         checkIsOpen();
         return delegate_.nullsAreSortedHigh();
     }
 
 
     /***
      *  Return true if NULL values are sorted low.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean nullsAreSortedLow()
         throws SQLException {
         checkIsOpen();
         return delegate_.nullsAreSortedLow();
     }
 
 
     /***
      *  Return true if NULL values are sorted at the start regardless of sort order.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean nullsAreSortedAtStart()
         throws SQLException {
         checkIsOpen();
         return delegate_.nullsAreSortedAtStart();
     }
 
 
     /***
      *  Return true if NULL values are sorted at the end regardless of sort order.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean nullsAreSortedAtEnd()
         throws SQLException {
         checkIsOpen();
         return delegate_.nullsAreSortedAtEnd();
     }
 
 
     /***
      *  Return true if the database stores tables in a local file.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean usesLocalFiles()
         throws SQLException {
         checkIsOpen();
         return delegate_.usesLocalFiles();
     }
 
 
     /***
      *  Return true if the database uses a file for each table.
      *
      * @return  true if the database uses a local file for each table
      * @exception  SQLException if a database access error occurs
      */
     public final boolean usesLocalFilePerTable()
         throws SQLException {
         checkIsOpen();
         return delegate_.usesLocalFilePerTable();
     }
 
 
     /***
      *  Return true if the database treats mixed case unquoted SQL identifiers as case
      *  sensitive and as a result stores them in mixed case.  A JDBC Compliant
      *  <sup><font size=-2>TM</font></sup> driver will always return false.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsMixedCaseIdentifiers()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsMixedCaseIdentifiers();
     }
 
 
     /***
      *  Return true if the database treats mixed case unquoted SQL identifiers as case
      *  insensitive and stores them in upper case.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean storesUpperCaseIdentifiers()
         throws SQLException {
         checkIsOpen();
         return delegate_.storesUpperCaseIdentifiers();
     }
 
 
     /***
      *  Return true if the database treats mixed case unquoted SQL identifiers as case
      *  insensitive and stores them in lower case.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean storesLowerCaseIdentifiers()
         throws SQLException {
         checkIsOpen();
         return delegate_.storesLowerCaseIdentifiers();
     }
 
 
     /***
      *  Return true if the database treats mixed case unquoted SQL identifiers as case
      *  insensitive and stores them in mixed case.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean storesMixedCaseIdentifiers()
         throws SQLException {
         checkIsOpen();
         return delegate_.storesMixedCaseIdentifiers();
     }
 
 
     /***
      *  Return true if the database treats mixed case quoted SQL identifiers as case
      *  sensitive and as a result stores them in mixed case. A JDBC Compliant
      *  <sup><font size=-2>TM</font></sup> driver will always return true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsMixedCaseQuotedIdentifiers()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsMixedCaseQuotedIdentifiers();
     }
 
 
     /***
      *  Return true if the database treats mixed case quoted SQL identifiers as case
      *  insensitive and stores them in upper case.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean storesUpperCaseQuotedIdentifiers()
         throws SQLException {
         checkIsOpen();
         return delegate_.storesUpperCaseQuotedIdentifiers();
     }
 
 
     /***
      *  Return true if the database treats mixed case quoted SQL identifiers as case
      *  insensitive and store them in lower case.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean storesLowerCaseQuotedIdentifiers()
         throws SQLException {
         checkIsOpen();
         return delegate_.storesLowerCaseQuotedIdentifiers();
     }
 
 
     /***
      *  Return true if the database treats mixed case quoted SQL identifiers as case
      *  insensitive and stores them in mixed case.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean storesMixedCaseQuotedIdentifiers()
         throws SQLException {
         checkIsOpen();
         return delegate_.storesMixedCaseQuotedIdentifiers();
     }
 
     //--------------------------------------------------------------------
     // Functions describing which features are supported.
 
     /***
      *  Return true if "ALTER TABLE" with add column is supported.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsAlterTableWithAddColumn()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsAlterTableWithAddColumn();
     }
 
 
     /***
      *  Return true if "ALTER TABLE" with drop column is supported.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsAlterTableWithDropColumn()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsAlterTableWithDropColumn();
     }
 
 
     /***
      *  Return true if column aliasing is supported. <P>
      *
      *  If so, the SQL AS clause can be used to provide names for computed
      *  columns or to provide alias names for columns as required. A JDBC
      *  Compliant<sup><font size=-2>TM</font></sup> driver always returns true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsColumnAliasing()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsColumnAliasing();
     }
 
 
     /***
      *  Return true if concatenations between NULL and non-NULL values are NULL. For SQL-92
      *  compliance, a JDBC technology-enabled driver will return <code>true</code>
      *  .
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean nullPlusNonNullIsNull()
         throws SQLException {
         checkIsOpen();
         return delegate_.nullPlusNonNullIsNull();
     }
 
 
     /***
      *  Return true if the CONVERT function between SQL types supported.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsConvert()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsConvert();
     }
 
 
     /***
      *  Return true if CONVERT between the given SQL types supported.
      *
      * @param  fromType the type to convert from
      * @param  toType the type to convert to
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsConvert( int fromType, int toType )
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsConvert( fromType, toType );
     }
 
 
     /***
      *  Return true if table correlation names supported. A JDBC
      * Compliant<sup><font size=-2>TM</font></sup> driver always returns true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsTableCorrelationNames()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsTableCorrelationNames();
     }
 
 
     /***
      *  If table correlation names are supported, are they restricted to be
      *  different from the names of the tables?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsDifferentTableCorrelationNames()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsDifferentTableCorrelationNames();
     }
 
 
     /***
      *  Are expressions in "ORDER BY" lists supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsExpressionsInOrderBy()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsExpressionsInOrderBy();
     }
 
 
     /***
      *  Can an "ORDER BY" clause use columns not in the SELECT statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsOrderByUnrelated()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsOrderByUnrelated();
     }
 
 
     /***
      *  Is some form of "GROUP BY" clause supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsGroupBy()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsGroupBy();
     }
 
 
     /***
      *  Can a "GROUP BY" clause use columns not in the SELECT?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsGroupByUnrelated()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsGroupByUnrelated();
     }
 
 
     /***
      *  Return true if a "GROUP BY" clause can add columns not in the SELECT provided it
      *  specifies all the columns in the SELECT.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsGroupByBeyondSelect()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsGroupByBeyondSelect();
     }
 
 
     /***
      *  Return true if the escape character in "LIKE" clauses is supported.  A JDBC Compliant
      *  <sup><font size=-2>TM</font></sup> driver always returns true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsLikeEscapeClause()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsLikeEscapeClause();
     }
 
 
     /***
      *  Are multiple <code>ResultSet</code> from a single execute supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsMultipleResultSets()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsMultipleResultSets();
     }
 
 
     /***
      *  Can we have multiple transactions open at once (on different
      *  connections)?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsMultipleTransactions()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsMultipleTransactions();
     }
 
 
     /***
      *  Return true if columns can be defined as non-nullable. A JDBC Compliant<sup><font
      *  size=-2>TM</font></sup> driver always returns true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsNonNullableColumns()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsNonNullableColumns();
     }
 
 
     /***
      *  Return true if the ODBC Minimum SQL grammar is supported. All JDBC Compliant<sup><font
      *  size=-2>TM</font></sup> drivers must return true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsMinimumSQLGrammar()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsMinimumSQLGrammar();
     }
 
 
     /***
      *  Is the ODBC Core SQL grammar supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsCoreSQLGrammar()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsCoreSQLGrammar();
     }
 
 
     /***
      *  Is the ODBC Extended SQL grammar supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsExtendedSQLGrammar()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsExtendedSQLGrammar();
     }
 
 
     /***
      *  Return true if the ANSI92 entry level SQL grammar is supported. All JDBC Compliant<sup>
      *  <font size=-2>TM</font></sup> drivers must return true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsANSI92EntryLevelSQL()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsANSI92EntryLevelSQL();
     }
 
 
     /***
      *  Is the ANSI92 intermediate SQL grammar supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsANSI92IntermediateSQL()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsANSI92IntermediateSQL();
     }
 
 
     /***
      *  Is the ANSI92 full SQL grammar supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsANSI92FullSQL()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsANSI92FullSQL();
     }
 
 
     /***
      *  Is the SQL Integrity Enhancement Facility supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsIntegrityEnhancementFacility()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsIntegrityEnhancementFacility();
     }
 
 
     /***
      *  Is some form of outer join supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsOuterJoins()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsOuterJoins();
     }
 
 
     /***
      *  Are full nested outer joins supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsFullOuterJoins()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsFullOuterJoins();
     }
 
 
     /***
      *  Return true if there is limited support for outer joins.  This will be true if
      *  supportFullOuterJoins is true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsLimitedOuterJoins()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsLimitedOuterJoins();
     }
 
 
     /***
      *  Can a schema name be used in a data manipulation statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsSchemasInDataManipulation()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsSchemasInDataManipulation();
     }
 
 
     /***
      *  Can a schema name be used in a procedure call statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsSchemasInProcedureCalls()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsSchemasInProcedureCalls();
     }
 
 
     /***
      *  Can a schema name be used in a table definition statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsSchemasInTableDefinitions()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsSchemasInTableDefinitions();
     }
 
 
     /***
      *  Can a schema name be used in an index definition statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsSchemasInIndexDefinitions()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsSchemasInIndexDefinitions();
     }
 
 
     /***
      *  Can a schema name be used in a privilege definition statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsSchemasInPrivilegeDefinitions()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsSchemasInPrivilegeDefinitions();
     }
 
 
     /***
      *  Can a catalog name be used in a data manipulation statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsCatalogsInDataManipulation()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsCatalogsInDataManipulation();
     }
 
 
     /***
      *  Can a catalog name be used in a procedure call statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsCatalogsInProcedureCalls()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsCatalogsInProcedureCalls();
     }
 
 
     /***
      *  Can a catalog name be used in a table definition statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsCatalogsInTableDefinitions()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsCatalogsInTableDefinitions();
     }
 
 
     /***
      *  Can a catalog name be used in an index definition statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsCatalogsInIndexDefinitions()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsCatalogsInIndexDefinitions();
     }
 
 
     /***
      *  Can a catalog name be used in a privilege definition statement?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsCatalogsInPrivilegeDefinitions()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsCatalogsInPrivilegeDefinitions();
     }
 
 
     /***
      *  Is positioned DELETE supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsPositionedDelete()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsPositionedDelete();
     }
 
 
     /***
      *  Is positioned UPDATE supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsPositionedUpdate()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsPositionedUpdate();
     }
 
 
     /***
      *  Is SELECT for UPDATE supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsSelectForUpdate()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsSelectForUpdate();
     }
 
 
     /***
      *  Return true if stored procedure calls using the stored procedure escape syntax
      *  are supported.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsStoredProcedures()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsStoredProcedures();
     }
 
 
     /***
      *  Return true if subqueries in comparison expressions are supported. A JDBC Compliant
      *  <sup><font size=-2>TM</font></sup> driver always returns true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsSubqueriesInComparisons()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsSubqueriesInComparisons();
     }
 
 
     /***
      *  Return true if subqueries in 'exists' expressions are supported. A JDBC Compliant<sup>
      *  <font size=-2>TM</font></sup> driver always returns true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsSubqueriesInExists()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsSubqueriesInExists();
     }
 
 
     /***
      *  Return true if subqueries in 'in' statements are supported.  A JDBC Compliant<sup><font
      *  size=-2>TM</font></sup> driver always returns true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsSubqueriesInIns()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsSubqueriesInIns();
     }
 
 
     /***
      *  Return true if subqueries in quantified expressions are supported.  A JDBC Compliant
      *  <sup><font size=-2>TM</font></sup> driver always returns true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsSubqueriesInQuantifieds()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsSubqueriesInQuantifieds();
     }
 
 
     /***
      *  Return true if correlated subqueries are supported.  A JDBC Compliant<sup><font size=-2>
      *  TM</font></sup> driver always returns true.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsCorrelatedSubqueries()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsCorrelatedSubqueries();
     }
 
 
     /***
      *  Return true if SQL UNION is supported.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsUnion()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsUnion();
     }
 
 
     /***
      *  Return true if SQL UNION ALL is supported.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsUnionAll()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsUnionAll();
     }
 
 
     /***
      *  Return true if cursors can remain open across commits.
      *
      * @return  <code>true</code> if cursors always remain open; <code>false</code>
      *      if they might not remain open
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsOpenCursorsAcrossCommit()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsOpenCursorsAcrossCommit();
     }
 
 
     /***
      *  Return true if cursors can remain open across rollbacks.
      *
      * @return  <code>true</code> if cursors always remain open; <code>false</code>
      *      if they might not remain open
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsOpenCursorsAcrossRollback()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsOpenCursorsAcrossRollback();
     }
 
 
     /***
      *  Return true if statements can remain open across commits.
      *
      * @return  <code>true</code> if statements always remain open; <code>false</code>
      *      if they might not remain open
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsOpenStatementsAcrossCommit()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsOpenStatementsAcrossCommit();
     }
 
 
     /***
      *  Return true if statements can remain open across rollbacks.
      *
      * @return  <code>true</code> if statements always remain open; <code>false</code>
      *      if they might not remain open
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsOpenStatementsAcrossRollback()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsOpenStatementsAcrossRollback();
     }
 
 
     /***
      *  Return true if getMaxRowSize() included LONGVARCHAR and LONGVARBINARY blobs.
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean doesMaxRowSizeIncludeBlobs()
         throws SQLException {
         checkIsOpen();
         return delegate_.doesMaxRowSizeIncludeBlobs();
     }
 
 
     /***
      *  Return true if transactions are supported. If not, invoking the method <code>commit</code>
      *  is a noop and the isolation level is TRANSACTION_NONE.
      *
      * @return  <code>true</code> if transactions are supported; <code>false</code>
      *      otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsTransactions()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsTransactions();
     }
 
 
     /***
      *  Does this database support the given transaction isolation level?
      *
      * @param  level the values are defined in <code>java.sql.Connection</code>
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsTransactionIsolationLevel( int level )
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsTransactionIsolationLevel( level );
     }
 
 
     /***
      *  Are both data definition and data manipulation statements within a
      *  transaction supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsDataDefinitionAndDataManipulationTransactions()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsDataDefinitionAndDataManipulationTransactions();
     }
 
 
     /***
      *  Are only data manipulation statements within a transaction supported?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsDataManipulationTransactionsOnly()
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsDataManipulationTransactionsOnly();
     }
 
 
     /***
      *  Does a data definition statement within a transaction force the
      *  transaction to commit?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean dataDefinitionCausesTransactionCommit()
         throws SQLException {
         checkIsOpen();
         return delegate_.dataDefinitionCausesTransactionCommit();
     }
 
 
     /***
      *  Is a data definition statement within a transaction ignored?
      *
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean dataDefinitionIgnoredInTransactions()
         throws SQLException {
         checkIsOpen();
         return delegate_.dataDefinitionIgnoredInTransactions();
     }
 
 
     /***
      *  Does the database support the given result set type?
      *
      * @param  type defined in <code>java.sql.ResultSet</code>
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsResultSetType( int type )
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsResultSetType( type );
     }
 
 
     /***
      *  Does the database support the concurrency type in combination with the
      *  given result set type?
      *
      * @param  type defined in <code>java.sql.ResultSet</code>
      * @param  concurrency type defined in <code>java.sql.ResultSet</code>
      * @return  <code>true</code> if so; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean supportsResultSetConcurrency( int type, int concurrency )
         throws SQLException {
         checkIsOpen();
         return delegate_.supportsResultSetConcurrency( type, concurrency );
     }
 
 
     /***
      *  Indicates whether a result set's own updates are visible.
      *
      * @param  type result set type, i.e. ResultSet.TYPE_XXX
      * @return  <code>true</code> if updates are visible for the result set
      *      type; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean ownUpdatesAreVisible( int type )
         throws SQLException {
         checkIsOpen();
         return delegate_.ownUpdatesAreVisible( type );
     }
 
 
     /***
      *  Indicates whether a result set's own deletes are visible.
      *
      * @param  type result set type, i.e. ResultSet.TYPE_XXX
      * @return  <code>true</code> if deletes are visible for the result set
      *      type; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean ownDeletesAreVisible( int type )
         throws SQLException {
         checkIsOpen();
         return delegate_.ownDeletesAreVisible( type );
     }
 
 
     /***
      *  Indicates whether a result set's own inserts are visible.
      *
      * @param  type result set type, i.e. ResultSet.TYPE_XXX
      * @return  <code>true</code> if inserts are visible for the result set
      *      type; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean ownInsertsAreVisible( int type )
         throws SQLException {
         checkIsOpen();
         return delegate_.ownInsertsAreVisible( type );
     }
 
 
     /***
      *  Indicates whether updates made by others are visible.
      *
      * @param  type result set type, i.e. ResultSet.TYPE_XXX
      * @return  <code>true</code> if updates made by others are visible for the
      *      result set type; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean othersUpdatesAreVisible( int type )
         throws SQLException {
         checkIsOpen();
         return delegate_.othersUpdatesAreVisible( type );
     }
 
 
     /***
      *  Indicates whether deletes made by others are visible.
      *
      * @param  type result set type, i.e. ResultSet.TYPE_XXX
      * @return  <code>true</code> if deletes made by others are visible for the
      *      result set type; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean othersDeletesAreVisible( int type )
         throws SQLException {
         checkIsOpen();
         return delegate_.othersDeletesAreVisible( type );
     }
 
 
     /***
      *  Indicates whether inserts made by others are visible.
      *
      * @param  type result set type, i.e. ResultSet.TYPE_XXX
      * @return  <code>true</code> if inserts made by others are visible for the
      *      result set type; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean othersInsertsAreVisible( int type )
         throws SQLException {
         checkIsOpen();
         return delegate_.othersInsertsAreVisible( type );
     }
 
 
     /***
      *  Indicates whether or not a visible row update can be detected by calling
      *  the method <code>ResultSet.rowUpdated</code>.
      *
      * @param  type result set type, i.e. ResultSet.TYPE_XXX
      * @return  <code>true</code> if changes are detected by the result set
      *      type; <code>false</code> otherwise
      * @exception  SQLException if a database access error occurs
      */
     public final boolean updatesAreDetected( int type )
         throws SQLException {
         checkIsOpen();
         return delegate_.updatesAreDetected( type );
     }
 
 
     /***
      *  Indicates whether or not a visible row delete can be detected by calling
      *  ResultSet.rowDeleted(). If deletesAreDetected() returns false, then
      *  deleted rows are removed from the result set.
      *
      * @param  type result set type, i.e. ResultSet.TYPE_XXX
      * @return  true if changes are detected by the resultset type
      * @exception  SQLException if a database access error occurs
      */
     public final boolean deletesAreDetected( int type )
         throws SQLException {
         checkIsOpen();
         return delegate_.deletesAreDetected( type );
     }
 
 
     /***
      *  Indicates whether or not a visible row insert can be detected by calling
      *  ResultSet.rowInserted().
      *
      * @param  type result set type, i.e. ResultSet.TYPE_XXX
      * @return  true if changes are detected by the resultset type
      * @exception  SQLException if a database access error occurs
      */
     public final boolean insertsAreDetected( int type )
         throws SQLException {
         checkIsOpen();
         return delegate_.insertsAreDetected( type );
     }
 
 
     /***
      *  Indicates whether the driver supports batch updates.
      *
      * @return  true if the driver supports batch updates; false otherwise
      * @exception  SQLException If an error occurs
      */
     public final boolean supportsBatchUpdates() throws SQLException {
         checkIsOpen();
         return delegate_.supportsBatchUpdates();
     }
 
 
     /***
      * @exception  SQLException
      */
     private void checkIsOpen()
         throws SQLException {
         if( isOpen_ == false ) {
             throw new SQLException( "connection is closed" );
         }
     }
 
 
     /***
      *  Wrap the specified result set
      *
      * @param  resultSet The result set to wrap
      * @return The wrapped result set
      */
     private ResultSet wrap( final ResultSet resultSet ) {
         if( resultSet == null ) {
             throw new NullPointerException( "resultSet" );
         }
         final ResultSetWrapper wrapper = new ResultSetWrapper( resultSet );
         openResultSets_.add( wrapper );
         return wrapper;
     }
 
 
     /***
      * Retrieves whether this database supports savepoints.
      *
      * @return <code>true</code> if savepoints are supported;
      *         <code>false</code> otherwise
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public boolean supportsSavepoints() throws SQLException {
         checkIsOpen();
         return delegate_.supportsSavepoints();
     }
 
 
     /***
      * Retrieves whether this database supports named parameters to callable
      * statements.
      *
      * @return <code>true</code> if named parameters are supported;
      *         <code>false</code> otherwise
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public boolean supportsNamedParameters() throws SQLException {
         checkIsOpen();
         return delegate_.supportsNamedParameters();
     }
 
 
     /***
      * Retrieves whether it is possible to have multiple <code>ResultSet</code> objects
      * returned from a <code>CallableStatement</code> object
      * simultaneously.
      *
      * @return <code>true</code> if a <code>CallableStatement</code> object
      *         can return multiple <code>ResultSet</code> objects
      *         simultaneously; <code>false</code> otherwise
      * @exception SQLException if a datanase access error occurs
      * @since 1.4
      */
     public boolean supportsMultipleOpenResults() throws SQLException {
         checkIsOpen();
         return delegate_.supportsMultipleOpenResults();
     }
 
 
     /***
      * Retrieves whether auto-generated keys can be retrieved after
      * a statement has been executed.
      *
      * @return <code>true</code> if auto-generated keys can be retrieved
      *         after a statement has executed; <code>false</code> otherwise
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public boolean supportsGetGeneratedKeys() throws SQLException {
         checkIsOpen();
         return delegate_.supportsGetGeneratedKeys();
     }
 
 
     /***
      * Retrieves a description of the user-defined type (UDT) hierarchies defined in a
      * particular schema in this database. Only the immediate super type/
      * sub type relationship is modeled.
      * <P>
      * Only supertype information for UDTs matching the catalog,
      * schema, and type name is returned. The type name parameter
      * may be a fully-qualified name. When the UDT name supplied is a
      * fully-qualified name, the catalog and schemaPattern parameters are
      * ignored.
      * <P>
      * If a UDT does not have a direct super type, it is not listed here.
      * A row of the <code>ResultSet</code> object returned by this method
      * describes the designated UDT and a direct supertype. A row has the following
      * columns:
      *  <OL>
      *  <LI><B>TYPE_CAT</B> String => the UDT's catalog (may be <code>null</code>)
      *  <LI><B>TYPE_SCHEM</B> String => UDT's schema (may be <code>null</code>)
      *  <LI><B>TYPE_NAME</B> String => type name of the UDT
      *  <LI><B>SUPERTYPE_CAT</B> String => the direct super type's catalog
      *                           (may be <code>null</code>)
      *  <LI><B>SUPERTYPE_SCHEM</B> String => the direct super type's schema
      *                             (may be <code>null</code>)
      *  <LI><B>SUPERTYPE_NAME</B> String => the direct super type's name
      *  </OL>
      *
      * <P><B>Note:</B> If the driver does not support type hierarchies, an
      * empty result set is returned.
      *
      * @param catalog a catalog name; "" retrieves those without a catalog;
      *        <code>null</code> means drop catalog name from the selection criteria
      * @param schemaPattern a schema name pattern; "" retrieves those
      *        without a schema
      * @param typeNamePattern a UDT name pattern; may be a fully-qualified
      *        name
      * @return a <code>ResultSet</code> object in which a row gives information
      *         about the designated UDT
      * @throws SQLException if a database access error occurs
      * @since 1.4
      */
     public ResultSet getSuperTypes(String catalog, String schemaPattern,
         String typeNamePattern) throws SQLException {
         checkIsOpen();
         return delegate_.getSuperTypes(catalog, schemaPattern, typeNamePattern);
     }
 
 
     /***
      * Retrieves a description of the table hierarchies defined in a particular
      * schema in this database.
      *
      * <P>Only supertable information for tables matching the catalog, schema
      * and table name are returned. The table name parameter may be a fully-
      * qualified name, in which case, the catalog and schemaPattern parameters
      * are ignored. If a table does not have a super table, it is not listed here.
      * Supertables have to be defined in the same catalog and schema as the
      * sub tables. Therefore, the type description does not need to include
      * this information for the supertable.
      *
      * <P>Each type description has the following columns:
      *  <OL>
      *  <LI><B>TABLE_CAT</B> String => the type's catalog (may be <code>null</code>)
      *  <LI><B>TABLE_SCHEM</B> String => type's schema (may be <code>null</code>)
      *  <LI><B>TABLE_NAME</B> String => type name
      *  <LI><B>SUPERTABLE_NAME</B> String => the direct super type's name
      *  </OL>
      *
      * <P><B>Note:</B> If the driver does not support type hierarchies, an
      * empty result set is returned.
      *
      * @param catalog a catalog name; "" retrieves those without a catalog;
      *        <code>null</code> means drop catalog name from the selection criteria
      * @param schemaPattern a schema name pattern; "" retrieves those
      *        without a schema
      * @param tableNamePattern a table name pattern; may be a fully-qualified
      *        name
      * @return a <code>ResultSet</code> object in which each row is a type description
      * @throws SQLException if a database access error occurs
      * @since 1.4
      */
     public ResultSet getSuperTables(String catalog, String schemaPattern,
         String tableNamePattern) throws SQLException {
         checkIsOpen();
         return delegate_.getSuperTables(catalog, schemaPattern, tableNamePattern);
     }
 
 
     /***
      * Retrieves a description of the given attribute of the given type
      * for a user-defined type (UDT) that is available in the given schema
      * and catalog.
      * <P>
      * Descriptions are returned only for attributes of UDTs matching the
      * catalog, schema, type, and attribute name criteria. They are ordered by
      * TYPE_SCHEM, TYPE_NAME and ORDINAL_POSITION. This description
      * does not contain inherited attributes.
      * <P>
      * The <code>ResultSet</code> object that is returned has the following
      * columns:
      * <OL>
      *  <LI><B>TYPE_CAT</B> String => type catalog (may be <code>null</code>)
      *  <LI><B>TYPE_SCHEM</B> String => type schema (may be <code>null</code>)
      *  <LI><B>TYPE_NAME</B> String => type name
      *  <LI><B>ATTR_NAME</B> String => attribute name
      *  <LI><B>DATA_TYPE</B> int => attribute type SQL type from java.sql.Types
      *  <LI><B>ATTR_TYPE_NAME</B> String => Data source dependent type name.
      *  For a UDT, the type name is fully qualified. For a REF, the type name is
      *  fully qualified and represents the target type of the reference type.
      *  <LI><B>ATTR_SIZE</B> int => column size.  For char or date
      *      types this is the maximum number of characters; for numeric or
      *      decimal types this is precision.
      *  <LI><B>DECIMAL_DIGITS</B> int => the number of fractional digits
      *  <LI><B>NUM_PREC_RADIX</B> int => Radix (typically either 10 or 2)
      *  <LI><B>NULLABLE</B> int => whether NULL is allowed
      *      <UL>
      *      <LI> attributeNoNulls - might not allow NULL values
      *      <LI> attributeNullable - definitely allows NULL values
      *      <LI> attributeNullableUnknown - nullability unknown
      *      </UL>
      *  <LI><B>REMARKS</B> String => comment describing column (may be <code>null</code>)
      *  <LI><B>ATTR_DEF</B> String => default value (may be <code>null</code>)
      *  <LI><B>SQL_DATA_TYPE</B> int => unused
      *  <LI><B>SQL_DATETIME_SUB</B> int => unused
      *  <LI><B>CHAR_OCTET_LENGTH</B> int => for char types the
      *       maximum number of bytes in the column
      *  <LI><B>ORDINAL_POSITION</B> int => index of column in table
      *      (starting at 1)
      *  <LI><B>IS_NULLABLE</B> String => "NO" means column definitely
      *      does not allow NULL values; "YES" means the column might
      *      allow NULL values.  An empty string means unknown.
      *  <LI><B>SCOPE_CATALOG</B> String => catalog of table that is the
      *      scope of a reference attribute (<code>null</code> if DATA_TYPE isn't REF)
      *  <LI><B>SCOPE_SCHEMA</B> String => schema of table that is the
      *      scope of a reference attribute (<code>null</code> if DATA_TYPE isn't REF)
      *  <LI><B>SCOPE_TABLE</B> String => table name that is the scope of a
      *      reference attribute (<code>null</code> if the DATA_TYPE isn't REF)
      * <LI><B>SOURCE_DATA_TYPE</B> short => source type of a distinct type or user-generated
      *      Ref type,SQL type from java.sql.Types (<code>null</code> if DATA_TYPE
      *      isn't DISTINCT or user-generated REF)
      *  </OL>
      * @param catalog a catalog name; must match the catalog name as it
      *        is stored in the database; "" retrieves those without a catalog;
      *        <code>null</code> means that the catalog name should not be used to narrow
      *        the search
      * @param schemaPattern a schema name pattern; must match the schema name
      *        as it is stored in the database; "" retrieves those without a schema;
      *        <code>null</code> means that the schema name should not be used to narrow
      *        the search
      * @param typeNamePattern a type name pattern; must match the
      *        type name as it is stored in the database
      * @param attributeNamePattern an attribute name pattern; must match the attribute
      *        name as it is declared in the database
      * @return a <code>ResultSet</code> object in which each row is an
      *         attribute description
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public ResultSet getAttributes(String catalog, String schemaPattern,
         String typeNamePattern, String attributeNamePattern) throws SQLException {
         checkIsOpen();
         return delegate_.getAttributes(catalog, schemaPattern, typeNamePattern, attributeNamePattern);
     }
 
 
     /***
      * Retrieves whether this database supports the given result set holdability.
      *
      * @param holdability one of the following constants:
      *          <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
      *          <code>ResultSet.CLOSE_CURSORS_AT_COMMIT<code>
      * @return <code>true</code> if so; <code>false</code> otherwise
      * @exception SQLException if a database access error occurs
      * @see Connection
      * @since 1.4
      */
     public boolean supportsResultSetHoldability(int holdability) throws SQLException {
         checkIsOpen();
         return delegate_.supportsResultSetHoldability(holdability);
     }
 
 
     /***
      * Retrieves the default holdability of this <code>ResultSet</code>
      * object.
      *
      * @return the default holdability; either
      *         <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
      *         <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public int getResultSetHoldability() throws SQLException {
         checkIsOpen();
         return delegate_.getResultSetHoldability();
     }
 
 
     /***
      * Retrieves the major version number of the underlying database.
      *
      * @return the underlying database's major version
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public int getDatabaseMajorVersion() throws SQLException {
         checkIsOpen();
         return delegate_.getDatabaseMajorVersion();
     }
 
 
     /***
      * Retrieves the minor version number of the underlying database.
      *
      * @return underlying database's minor version
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public int getDatabaseMinorVersion() throws SQLException {
         checkIsOpen();
         return delegate_.getDatabaseMinorVersion();
     }
 
 
     /***
      * Retrieves the major JDBC version number for this
      * driver.
      *
      * @return JDBC version major number
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public int getJDBCMajorVersion() throws SQLException {
         checkIsOpen();
         return delegate_.getJDBCMajorVersion();
     }
 
 
     /***
      * Retrieves the minor JDBC version number for this
      * driver.
      *
      * @return JDBC version minor number
      * @exception SQLException if a database access error occurs
      * @since 1.4
      */
     public int getJDBCMinorVersion() throws SQLException {
         checkIsOpen();
         return delegate_.getJDBCMinorVersion();
     }
 
 
     /***
      * Indicates whether the SQLSTATE returned by <code>SQLException.getSQLState</code>
      * is X/Open (now known as Open Group) SQL CLI or SQL99.
      * @return the type of SQLSTATE; one of:
      *        sqlStateXOpen or
      *        sqlStateSQL99
      * @throws SQLException if a database access error occurs
      * @since 1.4
      */
     public int getSQLStateType() throws SQLException {
         checkIsOpen();
         return delegate_.getSQLStateType();
     }
 
 
     /***
      * Indicates whether updates made to a LOB are made on a copy or directly
      * to the LOB.
      * @return <code>true</code> if updates are made to a copy of the LOB;
      *         <code>false</code> if updates are made directly to the LOB
      * @throws SQLException if a database access error occurs
      * @since 1.4
      */
     public boolean locatorsUpdateCopy() throws SQLException {
         checkIsOpen();
         return delegate_.locatorsUpdateCopy();
     }
 
 
     /***
      * Retrieves whether this database supports statement pooling.
      *
      * @return <code>true</code> if so; <code>false</code> otherwise
      * @throws SQLException if a database access error occurs
      * @since 1.4
      */
     public boolean supportsStatementPooling() throws SQLException {
         checkIsOpen();
         return delegate_.supportsStatementPooling();
     }
 }