Source code: org/apache/derby/impl/jdbc/EmbedDatabaseMetaData.java

   /*
   
      Derby - Class org.apache.derby.impl.jdbc.EmbedDatabaseMetaData
   
      Copyright 1997, 2004 The Apache Software Foundation or its licensors, as applicable.
   
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
  
        http://www.apache.org/licenses/LICENSE-2.0
  
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
  
   */
  
  package org.apache.derby.impl.jdbc;
  
  import org.apache.derby.iapi.services.info.ProductVersionHolder;
  
  import org.apache.derby.iapi.services.monitor.Monitor;
  
  import org.apache.derby.iapi.sql.conn.LanguageConnectionContext;
  
  import org.apache.derby.iapi.sql.dictionary.DataDictionary;
  import org.apache.derby.iapi.sql.dictionary.SPSDescriptor;
  
  import org.apache.derby.iapi.error.StandardException;
  
  import org.apache.derby.impl.sql.execute.GenericConstantActionFactory;
  import org.apache.derby.impl.sql.execute.GenericExecutionFactory;
  
  import org.apache.derby.iapi.reference.Limits;
  import org.apache.derby.iapi.reference.JDBC20Translation;
  import org.apache.derby.iapi.reference.JDBC30Translation;
  
  import java.util.Properties;
  
  import java.sql.DatabaseMetaData;
  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.sql.SQLException;
  import java.sql.ResultSet;
  import java.sql.Types;
  
  import java.io.IOException;
  import java.io.InputStream;
  
  /**
   * This class provides information about the database as a whole.
   *
   * <P>Many of the methods here return lists of information in ResultSets.
   * You can use the normal ResultSet methods such as getString and getInt
   * to retrieve the data from these ResultSets.  If a given form of
   * metadata is not available, these methods should throw a SQLException.
   *
   * <P>Some of these methods take arguments that are String patterns.  These
   * arguments all have names such as fooPattern.  Within a pattern String, "%"
   * means match any substring of 0 or more characters, and "_" means match
   * any one character. Only metadata entries matching the search pattern
   * are returned. If a search pattern argument is set to a null ref, it means
   * that argument's criteria should be dropped from the search.
   *
   * <P>A SQLException will be thrown if a driver does not support a meta
   * data method.  In the case of methods that return a ResultSet,
   * either a ResultSet (which may be empty) is returned or a
   * SQLException is thrown.
   * <p>
   * This implementation gets instructions from the Database for how to satisfy
   * most requests for information.  Each instruction is either a simple string
   * containing the desired information, or the text of a query that may be
   * executed on the database connection to gather the information.  We get the
   * instructions via an "InstructionReader," which requires the database
   * Connection for initialization.
   * <p>
   * Those few pieces of metadata that are related to the driver, rather than the
   * database, come from a separate InstructionReader.  Note that in that case it
   * probably doesn't make sense to allow an instruction to specify a query.
   *
   * @author ames
   */
  public class EmbedDatabaseMetaData extends ConnectionChild 
    implements DatabaseMetaData, java.security.PrivilegedAction {
  
    /*
    ** Property and values related to using
    ** stored prepared statements for metatdata.
    */
  
    private final String url;
    
    /*
    ** Set to true if metadata is off
    */
  
   private  GenericConstantActionFactory  constantActionFactory;
 
   //////////////////////////////////////////////////////////////
   //
   // CONSTRUCTORS
   //
   //////////////////////////////////////////////////////////////
   /**
       @exception SQLException on error
    */
   public EmbedDatabaseMetaData (EmbedConnection connection, String url) 
     throws SQLException {
 
       super(connection);
     this.url = url;
 
   }
 
   private static Properties queryDescriptions;
   protected final Properties getQueryDescriptions() {
     Properties p = EmbedDatabaseMetaData.queryDescriptions;
     if (p != null)
       return p;
 
     return (EmbedDatabaseMetaData.queryDescriptions = loadQueryDescriptions());
   }
 
   private Properties PBloadQueryDescriptions() {
     Properties p = new Properties();
     try {
 
       // SECURITY PERMISSION - IP3
       InputStream is = getClass().getResourceAsStream("metadata.properties");
       
       p.load(is);
       is.close();
     } catch (IOException ioe) {
     }
     return p;
   }
 
   //////////////////////////////////////////////////////////////
   //
   // DatabaseMetaData interface
   //
   //////////////////////////////////////////////////////////////
 
     //----------------------------------------------------------------------
   // First, a variety of minor information about the target database.
 
     /**
      * Can all the procedures returned by getProcedures be called by the
      * current user?
      *
      * @return true if so
      */
   public boolean allProceduresAreCallable() {
     return true;
   }
 
     /**
      * Can all the tables returned by getTable be SELECTed by the
      * current user?
      *
      * @return true if so
      */
   public boolean allTablesAreSelectable() {
     return true;
   }
 
     /**
      * What's the url for this database?
      *
      * @return the url or null if it can't be generated
      */
   public final String getURL()  {
 
     if (url == null)
       return url;
     int attributeStart = url.indexOf(';');
     if (attributeStart == -1)
       return url;
     else
       return url.substring(0,attributeStart);
   }
 
     /**
      * What's our user name as known to the database?
      *
      * @return our database user name
      */
   public String getUserName() {
     return (getEmbedConnection().getTR().getUserName());
   }
 
     /**
      * Is the database in read-only mode?
      *
      * @return true if so
      */
   public boolean isReadOnly() {
     return getLanguageConnectionContext().getDatabase().isReadOnly();
   }
 
     /**
      * Are NULL values sorted high?
      *
      * @return true if so
      */
   public boolean nullsAreSortedHigh() {
     return true;
   }
 
     /**
      * Are NULL values sorted low?
      *
      * @return true if so
      */
   public boolean nullsAreSortedLow() {
     return false;
   }
 
     /**
      * Are NULL values sorted at the start regardless of sort order?
      *
      * @return true if so
      */
   public boolean nullsAreSortedAtStart() {
     return false;
   }
 
     /**
      * Are NULL values sorted at the end regardless of sort order?
      *
      * @return true if so
      */
   public boolean nullsAreSortedAtEnd() {
     return false;
   }
 
     /**
      * What's the name of this database product?
      *
      * @return database product name
      */
   public String getDatabaseProductName() {
     return Monitor.getMonitor().getEngineVersion().getProductName();
   }
 
     /**
      * What's the version of this database product?
      *
      * @return database version
      */
   public String getDatabaseProductVersion() {
     ProductVersionHolder myPVH = Monitor.getMonitor().getEngineVersion();
 
     return myPVH.getVersionBuildString(false);
   }
 
     /**
      * What's the name of this JDBC driver?
      *
      * @return JDBC driver name
      */
   public String getDriverName() {
     return "Apache Derby Embedded JDBC Driver";
   }
 
     /**
      * What's the version of this JDBC driver?
      *
      * @return JDBC driver version
      */
   public String getDriverVersion()  {
     return getDatabaseProductVersion();
   }
 
     /**
      * What's this JDBC driver's major version number?
      *
      * @return JDBC driver major version
      */
   public int getDriverMajorVersion() {
     return getEmbedConnection().getLocalDriver().getMajorVersion();
   }
 
     /**
      * What's this JDBC driver's minor version number?
      *
      * @return JDBC driver minor version number
      */
   public int getDriverMinorVersion() {
     return getEmbedConnection().getLocalDriver().getMinorVersion();
   }
 
     /**
      * Does the database store tables in a local file?
      *
      * @return true if so
      */
   public boolean usesLocalFiles() {
     return true;
   }
 
     /**
      * Does the database use a file for each table?
      *
      * @return true if the database uses a local file for each table
      */
   public boolean usesLocalFilePerTable() {
     return true;
   }
 
     /**
      * Does the database treat mixed case unquoted SQL identifiers as
      * case sensitive and as a result store them in mixed case?
      *
      * A JDBC-Compliant driver will always return false.
      *
      * @return true if so
      */
   public boolean supportsMixedCaseIdentifiers() {
     return false;
   }
 
     /**
      * Does the database treat mixed case unquoted SQL identifiers as
      * case insensitive and store them in upper case?
      *
      * @return true if so
      */
   public boolean storesUpperCaseIdentifiers() {
     return true;
   }
 
     /**
      * Does the database treat mixed case unquoted SQL identifiers as
      * case insensitive and store them in lower case?
      *
      * @return true if so
      */
   public boolean storesLowerCaseIdentifiers() {
     return false;
   }
 
     /**
      * Does the database treat mixed case unquoted SQL identifiers as
      * case insensitive and store them in mixed case?
      *
      * @return true if so
      */
   public boolean storesMixedCaseIdentifiers() {
     return false;
   }
 
     /**
      * Does the database treat mixed case quoted SQL identifiers as
      * case sensitive and as a result store them in mixed case?
      *
      * A JDBC-Compliant driver will always return true.
      *
      * @return true if so
      */
   public boolean supportsMixedCaseQuotedIdentifiers() {
     return true;
   }
 
     /**
      * Does the database treat mixed case quoted SQL identifiers as
      * case insensitive and store them in upper case?
      *
      * @return true if so
      */
   public boolean storesUpperCaseQuotedIdentifiers() {
     return false;
   }
 
     /**
      * Does the database treat mixed case quoted SQL identifiers as
      * case insensitive and store them in lower case?
      *
      * @return true if so
      */
   public boolean storesLowerCaseQuotedIdentifiers() {
     return false;
   }
 
     /**
      * Does the database treat mixed case quoted SQL identifiers as
      * case insensitive and store them in mixed case?
      *
      * @return true if so
      */
   public boolean storesMixedCaseQuotedIdentifiers() {
     return true;
   }
 
     /**
      * What's the string used to quote SQL identifiers?
      * This returns a space " " if identifier quoting isn't supported.
      *
      * A JDBC-Compliant driver always uses a double quote character.
      *
      * @return the quoting string
      */
   public String getIdentifierQuoteString() {
     return "\"";
   }
 
     /**
      * Get a comma separated list of all a database's SQL keywords
      * that are NOT also SQL92 keywords.
   includes reserved and non-reserved keywords.
 
      * @return the list
      */
   public String getSQLKeywords() {
     return "ALIAS,BIGINT,BOOLEAN,CALL,CLASS,COPY,DB2J_DEBUG,EXECUTE,EXPLAIN,FILE,FILTER,"
       +  "GETCURRENTCONNECTION,INDEX,INSTANCEOF,METHOD,NEW,OFF,PROPERTIES,PUBLICATION,RECOMPILE,"
       +  "REFRESH,RENAME,RUNTIMESTATISTICS,STATEMENT,STATISTICS,TIMING,WAIT";
   }
 
     /**
      * Get a comma separated list of math functions.
   getNumericFunctions lists "math functions" -- so built-in operators and
   things like EXTRACT are not included.
   FIXME: find a way to reference method aliases known to be "numeric"
     *
      * @return the list
      */
   public String getNumericFunctions() {
     return "ABS,SQRT";
   }
 
     /**
      * Get a comma separated list of string functions.
     REMIND, when they show up, something like this might appear here:
     FIXME: find a way to reference method aliases known to be "string"
      * @return the list
      */
   public String getStringFunctions() {
     return "LENGTH,LOWER,LTRIM,RTRIM,SUBSTR,SUBSTRING,UPPER";
   }
 
     /**
      * Get a comma separated list of system functions.
     FIXME: find a way to reference system functions on Database when/if
     they are registered as aliases or include the Database object too.
      * @return the list
      */
   public String getSystemFunctions()  {
     return "CURRENT_USER,getCurrentConnection,runTimeStatistics,SESSION_USER,USER,CURRENT SCHEMA";
   }
 
     /**
      * Get a comma separated list of time and date functions.
     not sure if this includes these built-ins or not, but here they are.
     FIXME: find a way to reference method aliases known to be "date/time"
      * @return the list
      */
   public String getTimeDateFunctions() {
     return "CURDATE,CURTIME,CURRENT_DATE,CURRENT_TIME,CURRENT_TIMESTAMP,EXTRACT";
   }
 
     /**
      * This is the string that can be used to escape '_' or '%' in
      * the string pattern style catalog search parameters.
         we have no default escape value, so = is the end of the next line
      * <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
      */
   public String getSearchStringEscape()  {
     return "";
   }
 
     /**
      * Get 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
      */
   public String getExtraNameCharacters()  {
     return "";
   }
 
     //--------------------------------------------------------------------
     // Functions describing which features are supported.
 
     /**
      * Is "ALTER TABLE" with add column supported?
      *
      * @return true if so
      */
   public boolean supportsAlterTableWithAddColumn() {
     return true;
   }
 
     /**
      * Is "ALTER TABLE" with drop column supported?
      *
      * @return true if so
      */
   public boolean supportsAlterTableWithDropColumn() {
     return true;
   }
 
     /**
      * Is column aliasing 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 driver always returns true.
      *
      * @return true if so
      */
   public boolean supportsColumnAliasing() {
     return true;
   }
 
     /**
      * Are concatenations between NULL and non-NULL values NULL?
      *
      * A JDBC-Compliant driver always returns true.
      *
      * @return true if so
      */
   public boolean nullPlusNonNullIsNull()  {
     return true;
   }
 
     /**
      * Is the CONVERT function between SQL types supported?
      *
      * @return true if so
      */
   public boolean supportsConvert() {
     return true;
   }
 
     /**
      * Is CONVERT between the given SQL types supported?
      *
      * @param fromType the type to convert from
      * @param toType the type to convert to
      * @return true if so
      * @see Types
      */
   public boolean supportsConvert(int fromType, int toType) {
     /*
      * at the moment we don't support CONVERT at all, so we take the easy
      * way out.  Eventually we need to figure out how to handle this
      * cleanly.
      */
     return false;
   }
 
     /**
      * Are table correlation names supported?
      *
      * A JDBC-Compliant driver always returns true.
      *
      * @return true if so
      */
   public boolean supportsTableCorrelationNames()  {
     return true;
   }
 
     /**
      * If table correlation names are supported, are they restricted
      * to be different from the names of the tables?
      *
      * @return true if so
      */
   public boolean supportsDifferentTableCorrelationNames() {
     return true;
   }
 
     /**
      * Are expressions in "ORDER BY" lists supported?
      *
      * @return true if so
      */
   public boolean supportsExpressionsInOrderBy() {
     return false;
   }
 
     /**
      * Can an "ORDER BY" clause use columns not in the SELECT?
      *
      * @return true if so
      */
   public boolean supportsOrderByUnrelated() {
     return false;
   }
 
     /**
      * Is some form of "GROUP BY" clause supported?
      *
      * @return true if so
      */
   public boolean supportsGroupBy() {
     return true;
   }
 
     /**
      * Can a "GROUP BY" clause use columns not in the SELECT?
      *
      * @return true if so
      */
   public boolean supportsGroupByUnrelated()  {
     return true;
   }
 
     /**
      * Can a "GROUP BY" clause add columns not in the SELECT
      * provided it specifies all the columns in the SELECT?
      *
      * @return true if so
      */
   public boolean supportsGroupByBeyondSelect() {
     return true;
   }
 
     /**
      * Is the escape character in "LIKE" clauses supported?
      *
      * A JDBC-Compliant driver always returns true.
      *
      * @return true if so
      */
   public boolean supportsLikeEscapeClause() {
     return true;
   }
 
     /**
      * Are multiple ResultSets from a single execute supported?
      *
      * @return true if so
      */
   public boolean supportsMultipleResultSets()  {
     return true;
   }
 
     /**
      * Can we have multiple transactions open at once (on different
      * connections)?
      *
      * @return true if so
      */
   public boolean supportsMultipleTransactions() {
     return true;
   }
 
     /**
      * Can columns be defined as non-nullable?
      *
      * A JDBC-Compliant driver always returns true.
      *
      * @return true if so
      */
   public boolean supportsNonNullableColumns()  {
     return true;
   }
 
     /**
      * Is the ODBC Minimum SQL grammar supported?
      *
      * All JDBC-Compliant drivers must return true.
      *
      * @return true if so
      */
   public boolean supportsMinimumSQLGrammar() {
     return true;
   }
 
     /**
      * Is the ODBC Core SQL grammar supported?
      *
      * @return true if so
      */
   public boolean supportsCoreSQLGrammar() {
     return false;
   }
 
     /**
      * Is the ODBC Extended SQL grammar supported?
      *
      * @return true if so
      */
   public boolean supportsExtendedSQLGrammar() {
     return false;
   }
 
     /**
      * Is the ANSI92 entry level SQL grammar supported?
      *
      * All JDBC-Compliant drivers must return true.
      *
      * @return true if so
      */
   public boolean supportsANSI92EntryLevelSQL() {
     return false;
   }
 
     /**
      * Is the ANSI92 intermediate SQL grammar supported?
      *
      * @return true if so
    * 
      */
   public boolean supportsANSI92IntermediateSQL() {
     return false;
   }
 
     /**
      * Is the ANSI92 full SQL grammar supported?
      *
      * @return true if so
    * 
      */
   public boolean supportsANSI92FullSQL() {
     return false;
   }
 
     /**
      * Is the SQL Integrity Enhancement Facility supported?
      *
      * @return true if so
    * 
      */
   public boolean supportsIntegrityEnhancementFacility() {
     return false;
   }
 
     /**
      * Is some form of outer join supported?
      *
      * @return true if so
    * 
      */
   public boolean supportsOuterJoins() {
     return true;
   }
 
     /**
      * Are full nested outer joins supported?
      *
      * @return true if so
    * 
      */
   public boolean supportsFullOuterJoins()  {
     return false;
   }
 
     /**
      * Is there limited support for outer joins?  (This will be true
      * if supportFullOuterJoins is true.)
      *
      * @return true if so
    * 
      */
   public boolean supportsLimitedOuterJoins() {
     return true;
   }
 
     /**
      * What's the database vendor's preferred term for "schema"?
      *
      * @return the vendor term
    * 
      */
   public String getSchemaTerm() {
     return "SCHEMA";
   }
 
     /**
      * What's the database vendor's preferred term for "procedure"?
      *
      * @return the vendor term
    * 
      */
   public String getProcedureTerm() {
     return "PROCEDURE";
   }
 
     /**
      * What's the database vendor's preferred term for "catalog"?
      *
      * @return the vendor term
    * 
      */
   public String getCatalogTerm() {
     return "CATALOG";
   }
 
     /**
      * Does a catalog appear at the start of a qualified table name?
      * (Otherwise it appears at the end)
      *
      * @return true if it appears at the start
    * 
      */
   public boolean isCatalogAtStart() {
     return false;
   }
 
     /**
      * What's the separator between catalog and table name?
      *
      * @return the separator string
    * 
      */
   public String getCatalogSeparator() {
     return "";
   }
 
     /**
      * Can a schema name be used in a data manipulation statement?
      *
      * @return true if so
    * 
      */
   public boolean supportsSchemasInDataManipulation() {
     return true;
   }
 
     /**
      * Can a schema name be used in a procedure call statement?
      *
      * @return true if so
    * 
      */
   public boolean supportsSchemasInProcedureCalls() {
     return true;
   }
 
     /**
      * Can a schema name be used in a table definition statement?
      *
      * @return true if so
    * 
      */
   public boolean supportsSchemasInTableDefinitions() {
     return true;
   }
 
     /**
      * Can a schema name be used in an index definition statement?
      *
      * @return true if so
      */
   public boolean supportsSchemasInIndexDefinitions() {
     return true;
   }
 
     /**
      * Can a schema name be used in a privilege definition statement?
      *
      * @return true if so
    * 
      */
   public boolean supportsSchemasInPrivilegeDefinitions() {
     return true;
   }
 
     /**
      * Can a catalog name be used in a data manipulation statement?
      *
      * @return true if so
    * 
      */
   public boolean supportsCatalogsInDataManipulation() {
     return false;
   }
 
     /**
      * Can a catalog name be used in a procedure call statement?
      *
      * @return true if so
    * 
      */
   public boolean supportsCatalogsInProcedureCalls() {
     return false;
   }
 
     /**
      * Can a catalog name be used in a table definition statement?
      *
      * @return true if so
    * 
      */
   public boolean supportsCatalogsInTableDefinitions() {
     return false;
   }
 
     /**
      * Can a catalog name be used in an index definition statement?
      *
      * @return true if so
      */
   public boolean supportsCatalogsInIndexDefinitions() {
     return false;
   }
 
     /**
      * Can a catalog name be used in a privilege definition statement?
      *
      * @return true if so
      */
   public boolean supportsCatalogsInPrivilegeDefinitions() {
     return false;
   }
 
 
     /**
      * Is positioned DELETE supported?
      *
      * @return true if so
      */
   public boolean supportsPositionedDelete() {
     return true;
   }
 
     /**
      * Is positioned UPDATE supported?
      *
      * @return true if so
      */
   public boolean supportsPositionedUpdate() {
     return true;
   }
 
     /**
      * Is SELECT for UPDATE supported?
      *
      * @return true if so
      */
   public boolean supportsSelectForUpdate() {
     return true;
   }
 
     /**
      * Are stored procedure calls using the stored procedure escape
      * syntax supported?
      *
      * @return true if so
      */
   public boolean supportsStoredProcedures() {
     return true;
   }
 
     /**
      * Are subqueries in comparison expressions supported?
      *
      * A JDBC-Compliant driver always returns true.
      *
      * @return true if so
      */
   public boolean supportsSubqueriesInComparisons() {
     return true;
   }
 
     /**
      * Are subqueries in 'exists' expressions supported?
      *
      * A JDBC-Compliant driver always returns true.
      *
      * @return true if so
      */
   public boolean supportsSubqueriesInExists() {
     return true;
   }
 
     /**
      * Are subqueries in 'in' statements supported?
      *
      * A JDBC-Compliant driver always returns true.
      *
      * @return true if so
      */
   public boolean supportsSubqueriesInIns() {
     return true;
   }
 
     /**
      * Are subqueries in quantified expressions supported?
      *
      * A JDBC-Compliant driver always returns true.
      *
      * @return true if so
      */
   public boolean supportsSubqueriesInQuantifieds() {
     return true;
   }
 
    /**
     * Are correlated subqueries supported?
     *
     * A JDBC-Compliant driver always returns true.
     *
     * @return true if so
     */
  public boolean supportsCorrelatedSubqueries() {
    return true;
  }

    /**
     * Is SQL UNION supported?
     *
     * @return true if so
     */
  public boolean supportsUnion() {
    return true;
  }

    /**
     * Is SQL UNION ALL supported?
     *
     * @return true if so
     */
  public boolean supportsUnionAll() {
    return true;
  }

    /**
     * Can cursors remain open across commits?
     *
     * @return true if cursors always remain open; false if they might not remain open
     */
  //returns false because Derby does not support cursors that are open across commits for XA transactions.
  public boolean supportsOpenCursorsAcrossCommit() {
    return false;
  }

    /**
     * Can cursors remain open across rollbacks?
     *
     * @return true if cursors always remain open; false if they might not remain open
     */
  public boolean supportsOpenCursorsAcrossRollback() {
    return false;
  }

    /**
     * Can statements remain open across commits?
     *
     * @return true if statements always remain open; false if they might not remain open
     */
  public boolean supportsOpenStatementsAcrossCommit() {
    return true;
  }

    /**
     * Can statements remain open across rollbacks?
     *
     * @return true if statements always remain open; false if they might not remain open
     */
  public boolean supportsOpenStatementsAcrossRollback() {
    return false;
  }



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

    /**
     * How many hex characters can you have in an inline binary literal?
     *
     * @return max literal length
     */
  public int getMaxBinaryLiteralLength() {
    return 0;
  }

    /**
     * What's the max length for a character literal?
     *
     * @return max literal length
     */
  public int getMaxCharLiteralLength() {
    return 0;
  }

    /**
     * What's the limit on column name length?
     *
     * @return max literal length
     */
  public int getMaxColumnNameLength() {
    return Limits.MAX_IDENTIFIER_LENGTH;
  }

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

    /**
     * What's the maximum number of columns allowed in an index?
     *
     * @return max columns
     */
  public int getMaxColumnsInIndex() {
    return 0;
  }

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

    /**
     * What's the maximum number of columns in a "SELECT" list?
     *
     * we don't have a limit...
     *
     * @return max columns
     */
  public int getMaxColumnsInSelect() {
    return 0;
  }

    /**
     * What's the maximum number of columns in a table?
     *
     * @return max columns
     */
  public int getMaxColumnsInTable()  {
    return 0;
  }

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

    /**
     * What's the maximum cursor name length?
     *
     * @return max cursor name length in bytes
     */
  public int getMaxCursorNameLength() {
    return Limits.MAX_IDENTIFIER_LENGTH;
  }

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

    /**
     * What's the maximum length allowed for a schema name?
     *
     * @return max name length in bytes
     */
  public int getMaxSchemaNameLength()  {
    return Limits.MAX_IDENTIFIER_LENGTH;
  }

    /**
     * What's the maximum length of a procedure name?
     *
     * @return max name length in bytes
     */
  public int getMaxProcedureNameLength() {
    return Limits.MAX_IDENTIFIER_LENGTH;
  }

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

    /**
     * What's the maximum length of a single row?
     *
     * @return max row size in bytes
     */
  public int getMaxRowSize() {
    return 0;
  }

    /**
     * Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY
     * blobs?
     *
     * @return true if so
     */
  public boolean doesMaxRowSizeIncludeBlobs() {
    return true;
  }

    /**
     * What's the maximum length of a SQL statement?
     *
     * @return max length in bytes
     */
  public int getMaxStatementLength() {
    return 0;
  }

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

    /**
     * What's the maximum length of a table name?
     *
     * @return max name length in bytes
     */
  public int getMaxTableNameLength() {
    return Limits.MAX_IDENTIFIER_LENGTH;
  }

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

    /**
     * What's the maximum length of a user name?
     *
     * @return max name length  in bytes
     */
  public int getMaxUserNameLength() {
    return Limits.DB2_MAX_USERID_LENGTH;
  }

    //----------------------------------------------------------------------

    /**
     * What's the database's default transaction isolation level?  The
     * values are defined in java.sql.Connection.
     *
     * @return the default isolation level
     * @see Connection
     */
  public int getDefaultTransactionIsolation() {
    return java.sql.Connection.TRANSACTION_READ_COMMITTED;
  }

    /**
     * Are transactions supported? If not, commit is a noop and the
     * isolation level is TRANSACTION_NONE.
     *
     * @return true if transactions are supported
     */
  public boolean supportsTransactions()  {
    return true;
  }

    /**
     * Does the database support the given transaction isolation level?
   *
   * DatabaseMetaData.supportsTransactionIsolation() should return false for
   * isolation levels that are not supported even if a higher level can be
   * substituted.
     *
     * @param level the values are defined in java.sql.Connection
     * @return true if so
     * @see Connection
    */  
  public boolean supportsTransactionIsolationLevel(int level)
               {
    // REMIND: This is hard-coded for the moment because it doesn't nicely
    // fit within the framework we've set up for the rest of these values.
    // Part of the reason is that it has a parameter, so it's not just a
    // simple value look-up.  Some ideas for the future on how to make this
    // not hard-coded:
    //    - code it as a query: "select true from <something> where ? in
    //      (a,b,c)" where a,b,c are the supported isolation levels.  The
    //      parameter would be set to "level".  This seems awfully awkward.
    //    - somehow what you'd really like is to enable the instructions
    //      file to contain the list, or set, of supported isolation
    //      levels.  Something like:
    //          supportsTr...ionLevel=SERIALIZABLE | REPEATABLE_READ | ...
    //      That would take some more code that doesn't seem worthwhile at
    //      the moment for this one case.

    /*
      REMIND: this could be moved into a query that is e.g.
      VALUES ( ? in (8,...) )
      so that database could control the list of supported
      isolations.  For now, it's hard coded, and just the one.
     */

    return (level == Connection.TRANSACTION_SERIALIZABLE    ||
            level == Connection.TRANSACTION_REPEATABLE_READ ||
          level == Connection.TRANSACTION_READ_COMMITTED  ||
          level == Connection.TRANSACTION_READ_UNCOMMITTED);
  }

    /**
     * Are both data definition and data manipulation statements
     * within a transaction supported?
     *
     * @return true if so
     */
  public boolean supportsDataDefinitionAndDataManipulationTransactions() {
       return true;
  }
    /**
     * Are only data manipulation statements within a transaction
     * supported?
     *
     * @return true if so
     */
  public boolean supportsDataManipulationTransactionsOnly()
  {
       return false;
  }
    /**
     * Does a data definition statement within a transaction force the
     * transaction to commit?
     *
     * @return true if so
   * 
     */
  public boolean dataDefinitionCausesTransactionCommit() {
    return false;
  }
    /**
     * Is a data definition statement within a transaction ignored?
     *
     * @return true if so
   * 
     */
  public boolean dataDefinitionIgnoredInTransactions(){
    return false;
  }


    /**
     * Get a description of 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 ResultSet - each row is a procedure description
     * @see #getSearchStringEscape
   * @exception SQLException thrown on failure.
     */
  public ResultSet getProcedures(String catalog, String schemaPattern,
      String procedureNamePattern) throws SQLException {

    return doGetProcs(catalog, schemaPattern,
      procedureNamePattern, "getProcedures");
  }

  /**
   * Get a description of stored procedures available in a
   * catalog.  Same as getProcedures() above, except that
   * the result set will conform to ODBC specifications.
   */
  public ResultSet getProceduresForODBC(String catalog, String schemaPattern,
      String procedureNamePattern) throws SQLException {

    return doGetProcs(catalog, schemaPattern,
      procedureNamePattern, "odbc_getProcedures");
  }

  /**
   * Does the actual work for the getProcedures metadata calls.
   * See getProcedures() method above for parameter descriptions.
   * @param queryName Name of the query to execute; is used
   *  to determine whether the result set should conform to
   *  JDBC or ODBC specifications.
   */
  private ResultSet doGetProcs(String catalog, String schemaPattern,
    String procedureNamePattern, String queryName)
    throws SQLException {

    PreparedStatement s = getPreparedQuery(queryName);
    s.setString(1, swapNull(catalog));
    s.setString(2, swapNull(schemaPattern));
    s.setString(3, swapNull(procedureNamePattern));
    return s.executeQuery();
  }

    /**
     * Get 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 ResultSet 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 ResultSet
     *      </UL>
     *  <LI><B>DATA_TYPE</B> short => SQL type from java.sql.Types
     *  <LI><B>TYPE_NAME</B> String => SQL type name
     *  <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 ResultSet - each row is a stored procedure parameter or
     *      column description
     * @see #getSearchStringEscape
   * @exception SQLException thrown on failure.
     */
  public ResultSet getProcedureColumns(String catalog,
      String schemaPattern,
      String procedureNamePattern,
      String columnNamePattern) throws SQLException {

    return doGetProcCols(catalog, schemaPattern,
      procedureNamePattern, columnNamePattern,
      "getProcedureColumns");
  }

  /**
   * Get a description of a catalog's stored procedure parameters
   * and result columns.  Same as getProcedureColumns() above,
   * except that the result set will conform to ODBC specifications.
   */
  public ResultSet getProcedureColumnsForODBC(String catalog,
      String schemaPattern, String procedureNamePattern,
      String columnNamePattern) throws SQLException {

    return doGetProcCols(catalog, schemaPattern,
      procedureNamePattern, columnNamePattern,
      "odbc_getProcedureColumns");
  }

  /**
   * Does the actual work for the getProcedureColumns metadata
   * calls. See getProcedureColumns() method above for parameter
   * descriptions.
   * @param queryName Name of the query to execute; is used
   *  to determine whether the result set should conform to
   *  JDBC or ODBC specifications.
   */
  private ResultSet doGetProcCols(String catalog, String schemaPattern,
      String procedureNamePattern, String columnNamePattern,
      String queryName) throws SQLException {

    PreparedStatement s = getPreparedQuery(queryName);
    // 
                // catalog is not part of the query
                //
    s.setString(1, swapNull(schemaPattern));
    s.setString(2, swapNull(procedureNamePattern));
    s.setString(3, swapNull(columnNamePattern));
    return s.executeQuery();
  }

    /**
     * Get 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 ResultSet - each row is a table description
     * @see #getSearchStringEscape
   * @exception SQLException thrown on failure.
     */
  public ResultSet getTables(String catalog, String schemaPattern,
    String tableNamePattern, String types[]) throws SQLException {
    synchronized (getConnectionSynchronization()) {
                        setupContextStack();
      ResultSet rs = null;
      try {
      
      String queryText = getQueryDescriptions().getProperty("getTables");

      /*
       * The query text is assumed to end with a "where" clause, so
       * that we can safely append
       * "and table_Type in ('xxx','yyy','zzz', ...)" and
       * have it become part of the where clause.
       *
       * Let's assume for now that the table type first char corresponds
       * to JBMS table type identifiers.
       */
      StringBuffer whereClauseTail = new StringBuffer(queryText);

      if (types != null  &&  types.length >= 1) {
        whereClauseTail.append(" AND TABLETYPE IN ('");
        whereClauseTail.append(types[0].substring(0, 1));

        for (int i=1; i<types.length; i++) {
          whereClauseTail.append("','");
          whereClauseTail.append(types[i].substring(0, 1));
        }
        whereClauseTail.append("')");
      }
      // Add the order by clause after the 'in' list.
      whereClauseTail.append(
        " ORDER BY TABLE_TYPE, TABLE_SCHEM, TABLE_NAME");

      PreparedStatement s =
        getEmbedConnection().prepareMetaDataStatement(whereClauseTail.toString());

      s.setString(1, swapNull(catalog));
      s.setString(2, swapNull(schemaPattern));
      s.setString(3, swapNull(tableNamePattern));

      rs = s.executeQuery();
        } catch (Throwable t) {
        throw handleException(t);
      } finally {
          restoreContextStack();
      }

      return rs;
    }
  }

    /**
     * Get 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 ResultSet - each row has a single String column that is a
     * schema name
   * @exception SQLException thrown on failure.
     */
  public ResultSet getSchemas() throws SQLException {
    return getSimpleQuery("getSchemas");
  }

    /**
     * Get the catalog names available in this database.  The results
     * are ordered by catalog name.
     *
     * <P>The catalog column is:
     *  <OL>
     *  <LI><B>TABLE_CAT</B> String => catalog name
     *  </OL>
     *
     * @return ResultSet - each row has a single String column that is a
     * catalog name
   * @exception SQLException thrown on failure.
     */
  public ResultSet getCatalogs() throws SQLException {
    return getSimpleQuery("getCatalogs");
  }

    /**
     * Get 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 ResultSet - each row has a single String column that is a
     * table type
   * @exception SQLException thrown on failure.
     */
  public ResultSet getTableTypes() throws SQLException {
    return getSimpleQuery("getTableTypes");
  }

    /**
     * Get a description of table columns available in a 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
     *  <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 schem