content: /**
   * Copyright 2010 The Apache Software Foundation
   *
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you 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 com.alibaba.wasp.jdbc.result;
  
  import com.alibaba.wasp.FConstants;
  import com.alibaba.wasp.jdbc.JdbcConnection;
  import com.alibaba.wasp.jdbc.JdbcException;
  import com.alibaba.wasp.jdbc.Logger;
  import org.apache.commons.lang.NotImplementedException;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import java.sql.Connection;
  import java.sql.DatabaseMetaData;
  import java.sql.ResultSet;
  import java.sql.RowIdLifetime;
  import java.sql.SQLException;
  
  /**
   * Represents the meta data for a database.
   */
  public class JdbcDatabaseMetaData implements DatabaseMetaData {
  
    private static Log log = LogFactory.getLog(JdbcDatabaseMetaData.class);
  
    private final JdbcConnection conn;
  
    public JdbcDatabaseMetaData(JdbcConnection conn) {
      this.conn = conn;
    }
  
    /**
     * Returns the major version of this driver.
     * 
     * @return the major version number
     */
    public int getDriverMajorVersion() {
      return FConstants.VERSION_MAJOR;
    }
  
    /**
     * Returns the minor version of this driver.
     * 
     * @return the minor version number
     */
    public int getDriverMinorVersion() {
      return FConstants.VERSION_MINOR;
    }
  
    /**
     * Gets the database product name.
     * 
     * @return the product name ("wasp")
     */
    public String getDatabaseProductName() {
      return "WASP";
    }
  
    /**
     * Gets the product version of the database.
     * 
     * @return the product version
     */
    public String getDatabaseProductVersion() {
      return FConstants.getFullVersion();
    }
  
    /**
     * Gets the name of the JDBC driver.
     * 
     * @return the driver name ("WASP JDBC Driver")
     */
    public String getDriverName() {
      return "WASP JDBC Driver";
    }
  
    /**
     * Gets the version number of the driver. The format is
     * [MajorVersion].[MinorVersion].
     * 
     * @return the version number
     */
    public String getDriverVersion() {
      return FConstants.getFullVersion();
    }
  
  
    public ResultSet getTables(String catalogPattern, String schemaPattern,
        String tableNamePattern, String[] types) throws SQLException {
      throw JdbcException.getUnsupportedException("getTables");
    }
  
  
    public ResultSet getColumns(String catalogPattern, String schemaPattern,
        String tableNamePattern, String columnNamePattern) throws SQLException {
      throw JdbcException.getUnsupportedException("getColumns");
    }
  
    /**
     * Unsupported
     * @param catalogPattern
     *          null or the catalog name
     * @param schemaPattern
     *          null (to get all objects) or a schema name (uppercase for unquoted
     *          names)
     * @param tableName
     *          table name (must be specified)
     * @param unique
     *          only unique indexes
     * @param approximate
     *          is ignored
     * @return the list of indexes and columns
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getIndexInfo(String catalogPattern, String schemaPattern,
        String tableName, boolean unique, boolean approximate)
        throws SQLException {
      throw JdbcException.getUnsupportedException("getIndexInfo");
    }
  
    /**
     * Unsupported
     *
     * @param catalogPattern
     *          null or the catalog name
     * @param schemaPattern
     *          null (to get all objects) or a schema name (uppercase for unquoted
     *          names)
     * @param tableName
     *          table name (must be specified)
     * @return the list of primary key columns
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getPrimaryKeys(String catalogPattern, String schemaPattern,
        String tableName) throws SQLException {
      throw JdbcException.getUnsupportedException("getPrimaryKeys");
    }
  
    /**
     * Checks if all procedures callable.
     * 
     * @return true
     */
    public boolean allProceduresAreCallable() {
      return true;
    }
  
    /**
     * Checks if it possible to query all tables returned by getTables.
     * 
     * @return true
     */
    public boolean allTablesAreSelectable() {
      return true;
    }
  
    /**
     * Returns the database URL for this connection.
     * 
     * @return the url
     */
    public String getURL() throws SQLException {
      try {
        return conn.getURL();
      } catch (Exception e) {
        throw Logger.logAndConvert(log, e);
      }
    }
  
    /**
     * Returns the user name as passed to DriverManager.getConnection(url, user,
     * password).
     * 
     * @return the user name
     */
    public String getUserName() throws SQLException {
      try {
        return conn.getUser();
      } catch (Exception e) {
        throw Logger.logAndConvert(log, e);
      }
    }
  
    /**
     * Returns the same as Connection.isReadOnly().
     * 
     * @return if read only optimization is switched on
     */
    public boolean isReadOnly() throws SQLException {
      try {
        return conn.isReadOnly();
      } catch (Exception e) {
        throw Logger.logAndConvert(log, e);
      }
    }
  
    /**
     * Checks if NULL is sorted high (bigger than anything that is not null).
     * 
     * @return false by default; true if the system property h2.sortNullsHigh is
     *         set to true
     */
    public boolean nullsAreSortedHigh() {
      return false;
    }
  
    /**
     * Checks if NULL is sorted low (smaller than anything that is not null).
     * 
     * @return true by default; false if the system property h2.sortNullsHigh is
     *         set to true
     */
    public boolean nullsAreSortedLow() {
      return false;
    }
  
    /**
     * Checks if NULL is sorted at the beginning (no matter if ASC or DESC is
     * used).
     * 
     * @return false
     */
    public boolean nullsAreSortedAtStart() {
      return false;
    }
  
    /**
     * Checks if NULL is sorted at the end (no matter if ASC or DESC is used).
     * 
     * @return false
     */
    public boolean nullsAreSortedAtEnd() {
      return false;
    }
  
    /**
     * Returns the connection that created this object.
     * 
     * @return the connection
     */
    public Connection getConnection() {
      return conn;
    }
  
    /**
     * Gets the list of procedures. The result set is sorted by PROCEDURE_SCHEM,
     * PROCEDURE_NAME, and NUM_INPUT_PARAMS. There are potentially multiple
     * procedures with the same name, each with a different number of input
     * parameters.
     * 
     * <ul>
     * <li>1 PROCEDURE_CAT (String) catalog</li>
     * <li>2 PROCEDURE_SCHEM (String) schema</li>
     * <li>3 PROCEDURE_NAME (String) name</li>
     * <li>4 NUM_INPUT_PARAMS (int) the number of arguments</li>
     * <li>5 NUM_OUTPUT_PARAMS (int) for future use, always 0</li>
     * <li>6 NUM_RESULT_SETS (int) for future use, always 0</li>
     * <li>7 REMARKS (String) description</li>
     * <li>8 PROCEDURE_TYPE (short) if this procedure returns a result
     * (procedureNoResult or procedureReturnsResult)</li>
     * <li>9 SPECIFIC_NAME (String) name</li>
     * </ul>
     * 
     * @param catalogPattern
     *          null or the catalog name
     * @param schemaPattern
     *          null (to get all objects) or a schema name (uppercase for unquoted
     *          names)
     * @param procedureNamePattern
     *          the procedure name pattern
     * @return the procedures
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getProcedures(String catalogPattern, String schemaPattern,
        String procedureNamePattern) throws SQLException {
      throw JdbcException.getUnsupportedException("getProcedures");
    }
  
    /**
     * Unsupported
     * @param catalogPattern
     *          null or the catalog name
     * @param schemaPattern
     *          null (to get all objects) or a schema name (uppercase for unquoted
     *          names)
     * @param procedureNamePattern
     *          the procedure name pattern
     * @param columnNamePattern
     *          the procedure name pattern
     * @return the procedure columns
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getProcedureColumns(String catalogPattern,
        String schemaPattern, String procedureNamePattern,
        String columnNamePattern) throws SQLException {
      throw JdbcException.getUnsupportedException("getProcedureColumns");
    }
  
    /**
     * Gets the list of schemas. The result set is sorted by TABLE_SCHEM.
     * 
     * <ul>
     * <li>1 TABLE_SCHEM (String) schema name</li>
     * <li>2 TABLE_CATALOG (String) catalog name</li>
     * <li>3 IS_DEFAULT (boolean) if this is the default schema</li>
     * </ul>
     * 
     * @return the schema list
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getSchemas() throws SQLException {
      throw JdbcException.getUnsupportedException("getSchemas");
    }
  
    /**
     * unsupported
     * 
     * <ul>
     * <li>1 TABLE_CAT (String) catalog name</li>
     * </ul>
     * 
     * @return the catalog list
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getCatalogs() throws SQLException {
      throw JdbcException.getUnsupportedException("getCatalogs");
    }
  
    /**
     * unsupported
     *
     * @return the table types
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getTableTypes() throws SQLException {
      throw JdbcException.getUnsupportedException("getTableTypes");
    }
  
    /**
     * unsupported
     *
     * @param catalogPattern
     *          null (to get all objects) or the catalog name
     * @param schemaPattern
     *          null (to get all objects) or a schema name (uppercase for unquoted
     *          names)
     * @param table
     *          a table name (uppercase for unquoted names)
     * @param columnNamePattern
     *          null (to get all objects) or a column name (uppercase for unquoted
     *          names)
     * @return the list of privileges
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getColumnPrivileges(String catalogPattern,
        String schemaPattern, String table, String columnNamePattern)
        throws SQLException {
      throw JdbcException.getUnsupportedException("getColumnPrivileges");
    }
  
    /**
     * unsupported
     * 
     * @param catalogPattern
     *          null (to get all objects) or the catalog name
     * @param schemaPattern
     *          null (to get all objects) or a schema name (uppercase for unquoted
     *          names)
     * @param tableNamePattern
     *          null (to get all objects) or a table name (uppercase for unquoted
     *          names)
     * @return the list of privileges
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getTablePrivileges(String catalogPattern,
        String schemaPattern, String tableNamePattern) throws SQLException {
      throw JdbcException.getUnsupportedException("getTablePrivileges");
    }
  
    /**
     * unsupported
     * 
     * @param catalogPattern
     *          null (to get all objects) or the catalog name
     * @param schemaPattern
     *          null (to get all objects) or a schema name (uppercase for unquoted
     *          names)
     * @param tableName
     *          table name (must be specified)
     * @param scope
     *          ignored
     * @param nullable
     *          ignored
     * @return the primary key index
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getBestRowIdentifier(String catalogPattern,
        String schemaPattern, String tableName, int scope, boolean nullable)
        throws SQLException {
      throw JdbcException.getUnsupportedException("getBestRowIdentifier");
    }
  
    /**
     *
     * 
     * @param catalog
     *          null (to get all objects) or the catalog name
     * @param schema
     *          null (to get all objects) or a schema name
     * @param tableName
     *          table name (must be specified)
     * @return an empty result set
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getVersionColumns(String catalog, String schema,
        String tableName) throws SQLException {
      throw JdbcException.getUnsupportedException("getVersionColumns");
    }
  
    /**
     *
     * 
     * @param catalogPattern
     *          null (to get all objects) or the catalog name
     * @param schemaPattern
     *          the schema name of the foreign table
     * @param tableName
     *          the name of the foreign table
     * @return the result set
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getImportedKeys(String catalogPattern, String schemaPattern,
        String tableName) throws SQLException {
      throw JdbcException.getUnsupportedException("getImportedKeys");
    }
  
    /**
     *
     * @param catalogPattern
     *          null or the catalog name
     * @param schemaPattern
     *          the schema name of the primary table
     * @param tableName
     *          the name of the primary table
     * @return the result set
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getExportedKeys(String catalogPattern, String schemaPattern,
        String tableName) throws SQLException {
      throw JdbcException.getUnsupportedException("getExportedKeys");
    }
  
    /**
     *
     * @param primaryCatalogPattern
     *          null or the catalog name
     * @param primarySchemaPattern
     *          the schema name of the primary table (optional)
     * @param primaryTable
     *          the name of the primary table (must be specified)
     * @param foreignCatalogPattern
     *          null or the catalog name
     * @param foreignSchemaPattern
     *          the schema name of the foreign table (optional)
     * @param foreignTable
     *          the name of the foreign table (must be specified)
     * @return the result set
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getCrossReference(String primaryCatalogPattern,
        String primarySchemaPattern, String primaryTable,
        String foreignCatalogPattern, String foreignSchemaPattern,
        String foreignTable) throws SQLException {
      throw JdbcException.getUnsupportedException("getCrossReference");
    }
  
    /**
     *
     * @param catalog
     *          ignored
     * @param schemaPattern
     *          ignored
     * @param typeNamePattern
     *          ignored
     * @param types
     *          ignored
     * @return an empty result set
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getUDTs(String catalog, String schemaPattern,
        String typeNamePattern, int[] types) throws SQLException {
      throw JdbcException.getUnsupportedException("getUDTs");
    }
  
    /**
     *
     * @return the list of data types
     * @throws java.sql.SQLException
     *           if the connection is closed
     */
    public ResultSet getTypeInfo() throws SQLException {
      throw JdbcException.getUnsupportedException("getTypeInfo");
    }
  
    /**
     * Checks if this database store data in local files.
     * 
     * @return true
     */
    public boolean usesLocalFiles() {
      return true;
    }
  
    /**
     * Checks if this database use one file per table.
     * 
     * @return false
     */
    public boolean usesLocalFilePerTable() {
      return false;
    }
  
    /**
     * Returns the string used to quote identifiers.
     * 
     * @return a double quote
     */
    public String getIdentifierQuoteString() {
      return "\"";
    }
  
    /**
     *
     * @return a list of additional the keywords
     */
    public String getSQLKeywords() {
      return "LIMIT,MINUS,ROWNUM,SYSDATE,SYSTIME,SYSTIMESTAMP,TODAY";
    }
  
    /**
     * Returns the list of numeric functions supported by this database.
     * 
     * @return the list
     */
    public String getNumericFunctions() throws SQLException {
      return getFunctions("Functions (Numeric)");
    }
  
    /**
     * Returns the list of string functions supported by this database.
     * 
     * @return the list
     */
    public String getStringFunctions() throws SQLException {
      return getFunctions("Functions (String)");
    }
  
    /**
     * Returns the list of system functions supported by this database.
     * 
     * @return the list
     */
    public String getSystemFunctions() throws SQLException {
      return getFunctions("Functions (System)");
    }
  
    /**
     * Returns the list of date and time functions supported by this database.
     * 
     * @return the list
     */
    public String getTimeDateFunctions() throws SQLException {
      return getFunctions("Functions (Time and Date)");
    }
  
    private String getFunctions(String section) throws SQLException {
      throw JdbcException.getUnsupportedException("getFunctions");
    }
  
    /**
     * Returns the default escape character for DatabaseMetaData search patterns.
     * 
     * @return the default escape character (always '\', independent on the mode)
     */
    public String getSearchStringEscape() {
      return "\\";
    }
  
    /**
     * Returns the characters that are allowed for identifiers in addiction to
     * A-Z, a-z, 0-9 and '_'.
     * 
     * @return an empty String ("")
     */
    public String getExtraNameCharacters() {
      return "";
    }
  
    /**
     * Returns whether alter table with add column is supported.
     * 
     * @return true
     */
    public boolean supportsAlterTableWithAddColumn() {
      return true;
    }
  
    /**
     * Returns whether alter table with drop column is supported.
     * 
     * @return true
     */
    public boolean supportsAlterTableWithDropColumn() {
      return true;
    }
  
    /**
     * Returns whether column aliasing is supported.
     * 
     * @return true
     */
    public boolean supportsColumnAliasing() {
      return true;
    }
  
    /**
     * Returns whether NULL+1 is NULL or not.
     * 
     * @return true
     */
    public boolean nullPlusNonNullIsNull() {
      return true;
    }
  
    /**
     * Returns whether CONVERT is supported.
     * 
     * @return true
     */
    public boolean supportsConvert() {
      return true;
    }
  
    /**
     * Returns whether CONVERT is supported for one datatype to another.
     * 
     * @param fromType
     *          the source SQL type
     * @param toType
     *          the target SQL type
     * @return true
     */
    public boolean supportsConvert(int fromType, int toType) {
      return true;
    }
  
    /**
     * Returns whether table correlation names (table alias) are supported.
     * 
     * @return true
     */
    public boolean supportsTableCorrelationNames() {
      return true;
    }
  
    /**
     * Returns whether table correlation names (table alias) are restricted to be
     * different than table names.
     * 
     * @return false
     */
    public boolean supportsDifferentTableCorrelationNames() {
      return false;
    }
  
    /**
     * Returns whether expression in ORDER BY are supported.
     * 
     * @return true
     */
    public boolean supportsExpressionsInOrderBy() {
      return true;
    }
  
    /**
     * Returns whether ORDER BY is supported if the column is not in the SELECT
     * list.
     * 
     * @return true
     */
    public boolean supportsOrderByUnrelated() {
      return true;
    }
  
    /**
     * Returns whether GROUP BY is supported.
     * 
     * @return true
     */
    public boolean supportsGroupBy() {
      return true;
    }
  
    /**
     * Returns whether GROUP BY is supported if the column is not in the SELECT
     * list.
     * 
     * @return true
     */
    public boolean supportsGroupByUnrelated() {
      return true;
    }
  
    /**
     * Checks whether a GROUP BY clause can use columns that are not in the SELECT
     * clause, provided that it specifies all the columns in the SELECT clause.
     * 
     * @return true
     */
    public boolean supportsGroupByBeyondSelect() {
      return true;
    }
  
    /**
     * Returns whether LIKE... ESCAPE is supported.
     * 
     * @return true
     */
    public boolean supportsLikeEscapeClause() {
      return true;
    }
  
    /**
     * Returns whether multiple result sets are supported.
     * 
     * @return false
     */
    public boolean supportsMultipleResultSets() {
      return false;
    }
  
    /**
     * Returns whether multiple transactions (on different connections) are
     * supported.
     * 
     * @return true
     */
    public boolean supportsMultipleTransactions() {
      return true;
    }
  
    /**
     * Returns whether columns with NOT NULL are supported.
     * 
     * @return true
     */
    public boolean supportsNonNullableColumns() {
      return true;
    }
  
    /**
     * Returns whether ODBC Minimum SQL grammar is supported.
     * 
     * @return true
     */
    public boolean supportsMinimumSQLGrammar() {
      return true;
    }
  
    /**
     * Returns whether ODBC Core SQL grammar is supported.
     * 
     * @return true
     */
    public boolean supportsCoreSQLGrammar() {
      return true;
    }
  
    /**
     * Returns whether ODBC Extended SQL grammar is supported.
     * 
     * @return false
     */
    public boolean supportsExtendedSQLGrammar() {
      return false;
    }
  
    /**
     * Returns whether SQL-92 entry level grammar is supported.
     * 
     * @return true
     */
    public boolean supportsANSI92EntryLevelSQL() {
      return true;
    }
  
    /**
     * Returns whether SQL-92 intermediate level grammar is supported.
     * 
     * @return false
     */
    public boolean supportsANSI92IntermediateSQL() {
      return false;
    }
  
    /**
     * Returns whether SQL-92 full level grammar is supported.
     * 
     * @return false
     */
    public boolean supportsANSI92FullSQL() {
      return false;
    }
  
    /**
     * Returns whether referential integrity is supported.
     * 
     * @return true
     */
    public boolean supportsIntegrityEnhancementFacility() {
      return true;
    }
  
    /**
     * Returns whether outer joins are supported.
     * 
     * @return true
     */
    public boolean supportsOuterJoins() {
      return true;
    }
  
    /**
     * Returns whether full outer joins are supported.
     * 
     * @return false
     */
    public boolean supportsFullOuterJoins() {
      return false;
    }
  
    /**
     * Returns whether limited outer joins are supported.
     * 
     * @return true
     */
    public boolean supportsLimitedOuterJoins() {
      return true;
    }
  
    /**
     * Returns the term for "schema".
     * 
     * @return "schema"
     */
    public String getSchemaTerm() {
      return "schema";
    }
  
    /**
     * Returns the term for "procedure".
     * 
     * @return "procedure"
     */
    public String getProcedureTerm() {
      return "procedure";
    }
  
    /**
     * Returns the term for "catalog".
     * 
     * @return "catalog"
     */
    public String getCatalogTerm() {
      return "catalog";
    }
  
    /**
     * Returns whether the catalog is at the beginning.
     * 
     * @return true
     */
    public boolean isCatalogAtStart() {
      return true;
    }
  
    /**
     * Returns the catalog separator.
     * 
     * @return "."
     */
    public String getCatalogSeparator() {
      return ".";
    }
  
    /**
     * Returns whether the schema name in INSERT, UPDATE, DELETE is supported.
     * 
     * @return true
     */
    public boolean supportsSchemasInDataManipulation() {
      return true;
    }
  
    /**
     * Returns whether the schema name in procedure calls is supported.
     * 
     * @return true
     */
    public boolean supportsSchemasInProcedureCalls() {
      return true;
    }
  
    /**
     * Returns whether the schema name in CREATE TABLE is supported.
     * 
     * @return true
     */
    public boolean supportsSchemasInTableDefinitions() {
      return true;
    }
  
    /**
     * Returns whether the schema name in CREATE INDEX is supported.
     * 
     * @return true
     */
    public boolean supportsSchemasInIndexDefinitions() {
      return true;
    }
  
    /**
     * Returns whether the schema name in GRANT is supported.
     * 
     * @return true
     */
    public boolean supportsSchemasInPrivilegeDefinitions() {
      return true;
    }
  
    /**
     * Returns whether the catalog name in INSERT, UPDATE, DELETE is supported.
     * 
     * @return true
     */
    public boolean supportsCatalogsInDataManipulation() {
      return true;
    }
  
    /**
     * Returns whether the catalog name in procedure calls is supported.
     * 
     * @return false
     */
    public boolean supportsCatalogsInProcedureCalls() {
      return false;
    }
  
    /**
     * Returns whether the catalog name in CREATE TABLE is supported.
     * 
     * @return true
     */
    public boolean supportsCatalogsInTableDefinitions() {
      return true;
    }
  
    /**
     * Returns whether the catalog name in CREATE INDEX is supported.
     * 
     * @return true
     */
    public boolean supportsCatalogsInIndexDefinitions() {
      return true;
    }
  
    /**
     * Returns whether the catalog name in GRANT is supported.
     * 
     * @return true
     */
    public boolean supportsCatalogsInPrivilegeDefinitions() {
      return true;
    }
  
    /**
     * Returns whether positioned deletes are supported.
     * 
     * @return true
     */
    public boolean supportsPositionedDelete() {
      return true;
    }
  
    /**
     * Returns whether positioned updates are supported.
     * 
     * @return true
     */
    public boolean supportsPositionedUpdate() {
      return true;
    }
  
    /**
     * Returns whether SELECT ... FOR UPDATE is supported.
     * 
     * @return true
     */
    public boolean supportsSelectForUpdate() {
      return true;
    }
  
    /**
     * Returns whether stored procedures are supported.
     * 
     * @return false
     */
    public boolean supportsStoredProcedures() {
      return false;
    }
  
    /**
     * Returns whether subqueries (SELECT) in comparisons are supported.
     * 
     * @return true
     */
    public boolean supportsSubqueriesInComparisons() {
      return true;
    }
  
    /**
     * Returns whether SELECT in EXISTS is supported.
     * 
     * @return true
     */
    public boolean supportsSubqueriesInExists() {
      return true;
    }
  
    /**
     * Returns whether IN(SELECT...) is supported.
     * 
     * @return true
     */
    public boolean supportsSubqueriesInIns() {
      return true;
    }
  
    /**
     * Returns whether subqueries in quantified expression are supported.
     * 
     * @return true
     */
    public boolean supportsSubqueriesInQuantifieds() {
      return true;
    }
  
    /**
     * Returns whether correlated subqueries are supported.
     * 
     * @return true
     */
    public boolean supportsCorrelatedSubqueries() {
      return true;
    }
  
    /**
     * Returns whether UNION SELECT is supported.
     * 
     * @return true
     */
    public boolean supportsUnion() {
      return true;
    }
  
    /**
     * Returns whether UNION ALL SELECT is supported.
     * 
     * @return true
     */
    public boolean supportsUnionAll() {
      return true;
    }
  
    /**
     * Returns whether open result sets across commits are supported.
     * 
     * @return false
     */
    public boolean supportsOpenCursorsAcrossCommit() {
      return false;
    }
  
    /**
     * Returns whether open result sets across rollback are supported.
     * 
     * @return false
     */
    public boolean supportsOpenCursorsAcrossRollback() {
      return false;
    }
  
    /**
     * Returns whether open statements across commit are supported.
     * 
     * @return true
     */
    public boolean supportsOpenStatementsAcrossCommit() {
      return true;
    }
  
    /**
     * Returns whether open statements across rollback are supported.
     * 
     * @return true
     */
    public boolean supportsOpenStatementsAcrossRollback() {
      return true;
    }
  
    /**
     * Returns whether transactions are supported.
     * 
     * @return true
     */
    public boolean supportsTransactions() {
      return true;
    }
  
    /**
     * Returns whether a specific transaction isolation level is supported.
     * 
     * @param level
     *          the transaction isolation level (Connection.TRANSACTION_*)
     * @return true
     */
    public boolean supportsTransactionIsolationLevel(int level) {
      return true;
    }
  
    /**
     * Returns whether data manipulation and CREATE/DROP is supported in
     * transactions.
     * 
     * @return false
     */
    public boolean supportsDataDefinitionAndDataManipulationTransactions() {
      return false;
    }
  
    /**
     * Returns whether only data manipulations are supported in transactions.
     * 
     * @return true
     */
    public boolean supportsDataManipulationTransactionsOnly() {
      return true;
    }
  
    /**
     * Returns whether CREATE/DROP commit an open transaction.
     * 
     * @return true
     */
    public boolean dataDefinitionCausesTransactionCommit() {
      return true;
    }
  
    /**
     * Returns whether CREATE/DROP do not affect transactions.
     * 
     * @return false
     */
    public boolean dataDefinitionIgnoredInTransactions() {
      return false;
    }
  
    /**
     * Returns whether a specific result set type is supported.
     * ResultSet.TYPE_SCROLL_SENSITIVE is not supported.
     * 
     * @param type
     *          the result set type
     * @return true for all types except ResultSet.TYPE_FORWARD_ONLY
     */
    public boolean supportsResultSetType(int type) {
      return type != ResultSet.TYPE_SCROLL_SENSITIVE;
    }
  
    /**
     * Returns whether a specific result set concurrency is supported.
     * ResultSet.TYPE_SCROLL_SENSITIVE is not supported.
     * 
     * @param type
     *          the result set type
     * @param concurrency
     *          the result set concurrency
     * @return true if the type is not ResultSet.TYPE_SCROLL_SENSITIVE
     */
    public boolean supportsResultSetConcurrency(int type, int concurrency) {
      return type != ResultSet.TYPE_SCROLL_SENSITIVE;
    }
  
    /**
     * Returns whether own updates are visible.
     * 
     * @param type
     *          the result set type
     * @return true
     */
    public boolean ownUpdatesAreVisible(int type) {
      return true;
    }
  
    /**
     * Returns whether own deletes are visible.
     * 
     * @param type
     *          the result set type
     * @return false
     */
    public boolean ownDeletesAreVisible(int type) {
      return false;
    }
  
    /**
     * Returns whether own inserts are visible.
     * 
     * @param type
     *          the result set type
     * @return false
     */
    public boolean ownInsertsAreVisible(int type) {
      return false;
    }
  
    /**
     * Returns whether other updates are visible.
     * 
     * @param type
     *          the result set type
     * @return false
     */
    public boolean othersUpdatesAreVisible(int type) {
      return false;
    }
  
    /**
     * Returns whether other deletes are visible.
     * 
     * @param type
     *          the result set type
     * @return false
     */
    public boolean othersDeletesAreVisible(int type) {
      return false;
    }
  
    /**
     * Returns whether other inserts are visible.
     * 
     * @param type
     *          the result set type
     * @return false
     */
    public boolean othersInsertsAreVisible(int type) {
      return false;
    }
  
    /**
     * Returns whether updates are detected.
     * 
     * @param type
     *          the result set type
     * @return false
     */
    public boolean updatesAreDetected(int type) {
      return false;
    }
  
    /**
     * Returns whether deletes are detected.
     * 
     * @param type
     *          the result set type
     * @return false
     */
    public boolean deletesAreDetected(int type) {
      return false;
    }
  
    /**
     * Returns whether inserts are detected.
     * 
     * @param type
     *          the result set type
     * @return false
     */
    public boolean insertsAreDetected(int type) {
      return false;
    }
  
    /**
     * Returns whether batch updates are supported.
     * 
     * @return true
     */
    public boolean supportsBatchUpdates() {
      return true;
    }
  
    /**
     * Returns whether the maximum row size includes blobs.
     * 
     * @return false
     */
    public boolean doesMaxRowSizeIncludeBlobs() {
      return false;
    }
  
    /**
     * Returns the default transaction isolation level.
     * 
     * @return Connection.TRANSACTION_READ_COMMITTED
     */
    public int getDefaultTransactionIsolation() {
      return Connection.TRANSACTION_READ_COMMITTED;
    }
  
    /**
     * Checks if for CREATE TABLE Test(ID INT), getTables returns Test as the
     * table name.
     * 
     * @return false
     */
    public boolean supportsMixedCaseIdentifiers() {
      return false;
    }
  
    /**
     * Checks if a table created with CREATE TABLE "Test"(ID INT) is a different
     * table than a table created with CREATE TABLE TEST(ID INT).
     * 
     * @return true
     */
    public boolean supportsMixedCaseQuotedIdentifiers() {
      return true;
    }
  
    /**
     * Checks if for CREATE TABLE Test(ID INT), getTables returns TEST as the
     * table name.
     * 
     * @return true
     */
    public boolean storesUpperCaseIdentifiers() {
      return true;
    }
  
    /**
     * Checks if for CREATE TABLE Test(ID INT), getTables returns test as the
     * table name.
     * 
     * @return false
     */
    public boolean storesLowerCaseIdentifiers() {
      return false;
    }
  
    /**
     * Checks if for CREATE TABLE Test(ID INT), getTables returns Test as the
     * table name.
     * 
     * @return false
     */
    public boolean storesMixedCaseIdentifiers() {
      return false;
    }
  
    /**
     * Checks if for CREATE TABLE "Test"(ID INT), getTables returns TEST as the
     * table name.
     * 
     * @return false
     */
    public boolean storesUpperCaseQuotedIdentifiers() {
      return false;
    }
  
    /**
     * Checks if for CREATE TABLE "Test"(ID INT), getTables returns test as the
     * table name.
     * 
     * @return false
     */
    public boolean storesLowerCaseQuotedIdentifiers() {
      return false;
    }
  
    /**
     * Checks if for CREATE TABLE "Test"(ID INT), getTables returns Test as the
     * table name.
     * 
     * @return true
     */
    public boolean storesMixedCaseQuotedIdentifiers() {
      return true;
    }
  
    /**
     * Returns the maximum length for hex values (characters).
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxBinaryLiteralLength() {
      return 0;
    }
  
    /**
     * Returns the maximum length for literals.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxCharLiteralLength() {
      return 0;
    }
  
    /**
     * Returns the maximum length for column names.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxColumnNameLength() {
      return 0;
    }
  
    /**
     * Returns the maximum number of columns in GROUP BY.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxColumnsInGroupBy() {
      return 0;
    }
  
    /**
     * Returns the maximum number of columns in CREATE INDEX.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxColumnsInIndex() {
      return 0;
    }
  
    /**
     * Returns the maximum number of columns in ORDER BY.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxColumnsInOrderBy() {
      return 0;
    }
  
    /**
     * Returns the maximum number of columns in SELECT.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxColumnsInSelect() {
      return 0;
    }
  
    /**
     * Returns the maximum number of columns in CREATE TABLE.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxColumnsInTable() {
      return 0;
    }
  
    /**
     * Returns the maximum number of open connection.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxConnections() {
      return 0;
    }
  
    /**
     * Returns the maximum length for a cursor name.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxCursorNameLength() {
      return 0;
    }
  
    /**
     * Returns the maximum length for an index (in bytes).
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxIndexLength() {
      return 0;
    }
  
    /**
     * Returns the maximum length for a schema name.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxSchemaNameLength() {
      return 0;
    }
  
    /**
     * Returns the maximum length for a procedure name.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxProcedureNameLength() {
      return 0;
    }
  
    /**
     * Returns the maximum length for a catalog name.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxCatalogNameLength() {
      return 0;
    }
  
    /**
     * Returns the maximum size of a row (in bytes).
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxRowSize() {
      return 0;
    }
  
    /**
     * Returns the maximum length of a statement.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxStatementLength() {
      return 0;
    }
  
    /**
     * Returns the maximum number of open statements.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxStatements() {
      return 0;
    }
  
    /**
     * Returns the maximum length for a table name.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxTableNameLength() {
      return 0;
    }
  
    /**
     * Returns the maximum number of tables in a SELECT.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxTablesInSelect() {
      return 0;
    }
  
    /**
     * Returns the maximum length for a user name.
     * 
     * @return 0 for limit is unknown
     */
    public int getMaxUserNameLength() {
      return 0;
    }
  
    /**
     * Does the database support savepoints.
     * 
     * @return true
     */
    public boolean supportsSavepoints() {
      return true;
    }
  
    /**
     * Does the database support named parameters.
     * 
     * @return false
     */
    public boolean supportsNamedParameters() {
      return false;
    }
  
    /**
     * Does the database support multiple open result sets.
     * 
     * @return true
     */
    public boolean supportsMultipleOpenResults() {
      return true;
    }
  
    /**
     * Does the database support getGeneratedKeys.
     * 
     * @return true
     */
    public boolean supportsGetGeneratedKeys() {
      return true;
    }
  
    /**
     * [Not supported]
     */
    public ResultSet getSuperTypes(String catalog, String schemaPattern,
        String typeNamePattern) throws SQLException {
      throw JdbcException.getUnsupportedException("getSuperTypes");
    }
  
    /**
     *
     * 
     * @param catalog
     *          null (to get all objects) or the catalog name
     * @param schemaPattern
     *          null (to get all objects) or a schema name (uppercase for unquoted
     *          names)
     * @param tableNamePattern
     *          null (to get all objects) or a table name pattern (uppercase for
     *          unquoted names)
     * @return an empty result set
     */
    public ResultSet getSuperTables(String catalog, String schemaPattern,
        String tableNamePattern) throws SQLException {
      throw JdbcException.getUnsupportedException("getSuperTypes");
    }
  
    /**
     * [Not supported]
     */
    public ResultSet getAttributes(String catalog, String schemaPattern,
        String typeNamePattern, String attributeNamePattern) throws SQLException {
      throw JdbcException.getUnsupportedException("getAttributes");
    }
  
    /**
     * Does this database supports a result set holdability.
     * 
     * @param holdability
     *          ResultSet.HOLD_CURSORS_OVER_COMMIT or CLOSE_CURSORS_AT_COMMIT
     * @return true if the holdability is ResultSet.CLOSE_CURSORS_AT_COMMIT
     */
    public boolean supportsResultSetHoldability(int holdability) {
      return holdability == ResultSet.CLOSE_CURSORS_AT_COMMIT;
    }
  
    /**
     * Gets the result set holdability.
     * 
     * @return ResultSet.CLOSE_CURSORS_AT_COMMIT
     */
    public int getResultSetHoldability() {
      return ResultSet.CLOSE_CURSORS_AT_COMMIT;
    }
  
    /**
     * Gets the major version of the database.
     * 
     * @return the major version
     */
    public int getDatabaseMajorVersion() {
      return FConstants.VERSION_MAJOR;
    }
  
    /**
     * Gets the minor version of the database.
     * 
     * @return the minor version
     */
    public int getDatabaseMinorVersion() {
      return FConstants.VERSION_MINOR;
    }
  
    /**
     * Gets the major version of the supported JDBC API. This method returns 4
     * when the driver is compiled using Java 5 or 6. It returns 3 otherwise.
     * 
     * @return the major version (4 or 3)
     */
    public int getJDBCMajorVersion() {
      int majorVersion = 3;
      majorVersion = 4;
      return majorVersion;
    }
  
    /**
     * Gets the minor version of the supported JDBC API.
     * 
     * @return the minor version (0)
     */
    public int getJDBCMinorVersion() {
      return 0;
    }
  
    /**
     * Gets the SQL State type.
     * 
     * @return DatabaseMetaData.sqlStateSQL99
     */
    public int getSQLStateType() {
      return DatabaseMetaData.sqlStateSQL99;
    }
  
    /**
     * Does the database make a copy before updating.
     * 
     * @return false
     */
    public boolean locatorsUpdateCopy() {
      return false;
    }
  
    /**
     * Does the database support statement pooling.
     * 
     * @return false
     */
    public boolean supportsStatementPooling() {
      return false;
    }
  
    /**
     * Get the lifetime of a rowid.
     * 
     * @return ROWID_UNSUPPORTED
     */
    public RowIdLifetime getRowIdLifetime() {
      return RowIdLifetime.ROWID_UNSUPPORTED;
    }
  
    // */
  
    /**
     * [Not supported] Gets the list of schemas.
     */
    public ResultSet getSchemas(String catalog, String schemaPattern)
        throws SQLException {
      throw JdbcException.getUnsupportedException("getSchemas(., .)");
    }
  
    // */
  
    /**
     * Returns whether the database supports calling functions using the call
     * syntax.
     * 
     * @return true
     */
    public boolean supportsStoredFunctionsUsingCallSyntax() {
      return true;
    }
  
    /**
     * Returns whether an exception while auto commit is on closes all result
     * sets.
     * 
     * @return false
     */
    public boolean autoCommitFailureClosesAllResultSets() {
      return false;
    }
  
    /**
     * [Not supported] Returns the client info properties.
     */
    public ResultSet getClientInfoProperties() throws SQLException {
      throw JdbcException.getUnsupportedException("clientInfoProperties");
    }
  
    /**
     * [Not supported] Return an object of this class if possible.
     */
    public <T> T unwrap(Class<T> iface) throws SQLException {
      throw JdbcException.getUnsupportedException("unwrap");
    }
  
    /**
     * [Not supported] Checks if unwrap can return an object of this class.
     */
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
      throw JdbcException.getUnsupportedException("isWrapperFor");
    }
  
    /**
     * [Not supported] Gets the list of function columns.
     */
    public ResultSet getFunctionColumns(String catalog, String schemaPattern,
        String functionNamePattern, String columnNamePattern) throws SQLException {
      throw JdbcException.getUnsupportedException("getFunctionColumns");
    }
  
    /**
     * [Not supported] Gets the list of functions.
     */
    public ResultSet getFunctions(String catalog, String schemaPattern,
        String functionNamePattern) throws SQLException {
      throw JdbcException.getUnsupportedException("getFunctions");
    }
  
  
    /**
     * INTERNAL
     */
    public String toString() {
      return "conn : " + conn;
    }
  
    public ResultSet getPseudoColumns(String catalog, String schemaPattern,
  	  	String tableNamePattern, String columnNamePattern) throws SQLException {
  	  throw new NotImplementedException();
    }
  
    public boolean generatedKeyAlwaysReturned() throws SQLException {
  	  throw new NotImplementedException();
    }
  
  }
  