/*
 * Copyright 2004-2023 H2 Group. Multiple-Licensed under the MPL 2.0,
 * and the EPL 1.0 (https://h2database.com/html/license.html).
 * Initial Developer: H2 Group
 */
package org.h2.jdbc;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.RowIdLifetime;
import java.sql.SQLException;
import java.util.Map.Entry;
import java.util.Properties;

import org.h2.engine.Constants;
import org.h2.engine.Session;
import org.h2.jdbc.meta.DatabaseMeta;
import org.h2.jdbc.meta.DatabaseMetaLegacy;
import org.h2.message.DbException;
import org.h2.message.Trace;
import org.h2.message.TraceObject;
import org.h2.mode.DefaultNullOrdering;
import org.h2.result.ResultInterface;
import org.h2.result.SimpleResult;
import org.h2.value.TypeInfo;
import org.h2.value.ValueInteger;
import org.h2.value.ValueVarchar;

/**
 * Represents the meta data for a database.
 */
public final class JdbcDatabaseMetaData extends TraceObject
        implements DatabaseMetaData, JdbcDatabaseMetaDataBackwardsCompat {

    private final JdbcConnection conn;

    private final DatabaseMeta meta;

    JdbcDatabaseMetaData(JdbcConnection conn, Trace trace, int id) {
        setTrace(trace, TraceObject.DATABASE_META_DATA, id);
        this.conn = conn;
        Session session = conn.getSession();
        meta = session.isOldInformationSchema() ? new DatabaseMetaLegacy(session)
                : conn.getSession().getDatabaseMeta();
    }

    /**
     * Returns the major version of this driver.
     *
     * @return the major version number
     */
    @Override
    public int getDriverMajorVersion() {
        debugCodeCall("getDriverMajorVersion");
        return Constants.VERSION_MAJOR;
    }

    /**
     * Returns the minor version of this driver.
     *
     * @return the minor version number
     */
    @Override
    public int getDriverMinorVersion() {
        debugCodeCall("getDriverMinorVersion");
        return Constants.VERSION_MINOR;
    }

    /**
     * Gets the database product name.
     *
     * @return the product name ("H2")
     */
    @Override
    public String getDatabaseProductName() {
        debugCodeCall("getDatabaseProductName");
        // This value must stay like that, see
        // https://hibernate.atlassian.net/browse/HHH-2682
        return "H2";
    }

    /**
     * Gets the product version of the database.
     *
     * @return the product version
     */
    @Override
    public String getDatabaseProductVersion() throws SQLException {
        try {
            debugCodeCall("getDatabaseProductVersion");
            return meta.getDatabaseProductVersion();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the name of the JDBC driver.
     *
     * @return the driver name ("H2 JDBC Driver")
     */
    @Override
    public String getDriverName() {
        debugCodeCall("getDriverName");
        return "H2 JDBC Driver";
    }

    /**
     * Gets the version number of the driver. The format is
     * [MajorVersion].[MinorVersion].
     *
     * @return the version number
     */
    @Override
    public String getDriverVersion() {
        debugCodeCall("getDriverVersion");
        return Constants.FULL_VERSION;
    }

    /**
     * Gets the list of tables in the database. The result set is sorted by
     * TABLE_TYPE, TABLE_SCHEM, and TABLE_NAME.
     *
     * <ol>
     * <li>TABLE_CAT (String) table catalog</li>
     * <li>TABLE_SCHEM (String) table schema</li>
     * <li>TABLE_NAME (String) table name</li>
     * <li>TABLE_TYPE (String) table type</li>
     * <li>REMARKS (String) comment</li>
     * <li>TYPE_CAT (String) always null</li>
     * <li>TYPE_SCHEM (String) always null</li>
     * <li>TYPE_NAME (String) always null</li>
     * <li>SELF_REFERENCING_COL_NAME (String) always null</li>
     * <li>REF_GENERATION (String) always null</li>
     * <li>SQL (String) the create table statement or NULL for systems tables.</li>
     * </ol>
     *
     * @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
     *            (uppercase for unquoted names)
     * @param types null or a list of table types
     * @return the list of columns
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types)
            throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getTables(" + quote(catalog) + ", " + quote(schemaPattern) + ", " + quote(tableNamePattern)
                        + ", " + quoteArray(types) + ')');
            }
            return getResultSet(meta.getTables(catalog, schemaPattern, tableNamePattern, types));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of columns. The result set is sorted by TABLE_SCHEM,
     * TABLE_NAME, and ORDINAL_POSITION.
     *
     * <ol>
     * <li>TABLE_CAT (String) table catalog</li>
     * <li>TABLE_SCHEM (String) table schema</li>
     * <li>TABLE_NAME (String) table name</li>
     * <li>COLUMN_NAME (String) column name</li>
     * <li>DATA_TYPE (int) data type (see java.sql.Types)</li>
     * <li>TYPE_NAME (String) data type name ("INTEGER", "VARCHAR",...)</li>
     * <li>COLUMN_SIZE (int) precision
     *         (values larger than 2 GB are returned as 2 GB)</li>
     * <li>BUFFER_LENGTH (int) unused</li>
     * <li>DECIMAL_DIGITS (int) scale (0 for INTEGER and VARCHAR)</li>
     * <li>NUM_PREC_RADIX (int) radix</li>
     * <li>NULLABLE (int) columnNoNulls or columnNullable</li>
     * <li>REMARKS (String) comment</li>
     * <li>COLUMN_DEF (String) default value</li>
     * <li>SQL_DATA_TYPE (int) unused</li>
     * <li>SQL_DATETIME_SUB (int) unused</li>
     * <li>CHAR_OCTET_LENGTH (int) unused</li>
     * <li>ORDINAL_POSITION (int) the column index (1,2,...)</li>
     * <li>IS_NULLABLE (String) "NO" or "YES"</li>
     * <li>SCOPE_CATALOG (String) always null</li>
     * <li>SCOPE_SCHEMA (String) always null</li>
     * <li>SCOPE_TABLE (String) always null</li>
     * <li>SOURCE_DATA_TYPE (short) null</li>
     * <li>IS_AUTOINCREMENT (String) "NO" or "YES"</li>
     * <li>IS_GENERATEDCOLUMN (String) "NO" or "YES"</li>
     * </ol>
     *
     * @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
     *            (uppercase for unquoted names)
     * @param columnNamePattern null (to get all objects) or a column name
     *            (uppercase for unquoted names)
     * @return the list of columns
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern,
            String columnNamePattern) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getColumns(" + quote(catalog)+", "
                        +quote(schemaPattern)+", "
                        +quote(tableNamePattern)+", "
                        +quote(columnNamePattern)+')');
            }
            return getResultSet(meta.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of indexes for this database. The primary key index (if
     * there is one) is also listed, with the name PRIMARY_KEY. The result set
     * is sorted by NON_UNIQUE ('false' first), TYPE, TABLE_SCHEM, INDEX_NAME,
     * and ORDINAL_POSITION.
     *
     * <ol>
     * <li>TABLE_CAT (String) table catalog</li>
     * <li>TABLE_SCHEM (String) table schema</li>
     * <li>TABLE_NAME (String) table name</li>
     * <li>NON_UNIQUE (boolean) 'true' if non-unique</li>
     * <li>INDEX_QUALIFIER (String) index catalog</li>
     * <li>INDEX_NAME (String) index name</li>
     * <li>TYPE (short) the index type (tableIndexOther or tableIndexHash for
     * unique indexes on non-nullable columns, tableIndexStatistics for other
     * indexes)</li>
     * <li>ORDINAL_POSITION (short) column index (1, 2, ...)</li>
     * <li>COLUMN_NAME (String) column name</li>
     * <li>ASC_OR_DESC (String) ascending or descending (always 'A')</li>
     * <li>CARDINALITY (long) number of rows or numbers of unique values for
     * unique indexes on non-nullable columns</li>
     * <li>PAGES (long) number of pages use</li>
     * <li>FILTER_CONDITION (String) filter condition (always empty)</li>
     * </ol>
     *
     * @param catalog null or the catalog name
     * @param schema null (to get all objects) or a schema name
     *            (uppercase for unquoted names)
     * @param table table name (must be specified)
     * @param unique only unique indexes
     * @param approximate if true, return fast, but approximate CARDINALITY
     * @return the list of indexes and columns
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate)
            throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getIndexInfo(" + quote(catalog) + ", " + quote(schema) + ", " + quote(table) + ", " + unique
                        + ", " + approximate + ')');
            }
            return getResultSet(meta.getIndexInfo(catalog, schema, table, unique, approximate));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the primary key columns for a table. The result set is sorted by
     * TABLE_SCHEM, and COLUMN_NAME (and not by KEY_SEQ).
     *
     * <ol>
     * <li>TABLE_CAT (String) table catalog</li>
     * <li>TABLE_SCHEM (String) table schema</li>
     * <li>TABLE_NAME (String) table name</li>
     * <li>COLUMN_NAME (String) column name</li>
     * <li>KEY_SEQ (short) the column index of this column (1,2,...)</li>
     * <li>PK_NAME (String) the name of the primary key index</li>
     * </ol>
     *
     * @param catalog null or the catalog name
     * @param schema null (to get all objects) or a schema name
     *            (uppercase for unquoted names)
     * @param table table name (must be specified)
     * @return the list of primary key columns
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getPrimaryKeys(" + quote(catalog) + ", " + quote(schema) + ", " + quote(table) + ')');
            }
            return getResultSet(meta.getPrimaryKeys(catalog, schema, table));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Checks if all procedures callable.
     *
     * @return true
     */
    @Override
    public boolean allProceduresAreCallable() {
        debugCodeCall("allProceduresAreCallable");
        return true;
    }

    /**
     * Checks if it possible to query all tables returned by getTables.
     *
     * @return true
     */
    @Override
    public boolean allTablesAreSelectable() {
        debugCodeCall("allTablesAreSelectable");
        return true;
    }

    /**
     * Returns the database URL for this connection.
     *
     * @return the url
     */
    @Override
    public String getURL() throws SQLException {
        try {
            debugCodeCall("getURL");
            return conn.getURL();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns the user name as passed to DriverManager.getConnection(url, user,
     * password).
     *
     * @return the user name
     */
    @Override
    public String getUserName() throws SQLException {
        try {
            debugCodeCall("getUserName");
            return conn.getUser();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns the same as Connection.isReadOnly().
     *
     * @return if read only optimization is switched on
     */
    @Override
    public boolean isReadOnly() throws SQLException {
        try {
            debugCodeCall("isReadOnly");
            return conn.isReadOnly();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Checks if NULL values are sorted high (bigger than anything that is not
     * null).
     *
     * @return if NULL values are sorted high
     */
    @Override
    public boolean nullsAreSortedHigh() throws SQLException {
        try {
            debugCodeCall("nullsAreSortedHigh");
            return meta.defaultNullOrdering() == DefaultNullOrdering.HIGH;
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Checks if NULL values are sorted low (smaller than anything that is not
     * null).
     *
     * @return if NULL values are sorted low
     */
    @Override
    public boolean nullsAreSortedLow() throws SQLException {
        try {
            debugCodeCall("nullsAreSortedLow");
            return meta.defaultNullOrdering() == DefaultNullOrdering.LOW;
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Checks if NULL values are sorted at the beginning (no matter if ASC or
     * DESC is used).
     *
     * @return if NULL values are sorted at the beginning
     */
    @Override
    public boolean nullsAreSortedAtStart() throws SQLException {
        try {
            debugCodeCall("nullsAreSortedAtStart");
            return meta.defaultNullOrdering() == DefaultNullOrdering.FIRST;
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Checks if NULL values are sorted at the end (no matter if ASC or DESC is
     * used).
     *
     * @return if NULL values are sorted at the end
     */
    @Override
    public boolean nullsAreSortedAtEnd() throws SQLException {
        try {
            debugCodeCall("nullsAreSortedAtEnd");
            return meta.defaultNullOrdering() == DefaultNullOrdering.LAST;
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns the connection that created this object.
     *
     * @return the connection
     */
    @Override
    public Connection getConnection() {
        debugCodeCall("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.
     *
     * <ol>
     * <li>PROCEDURE_CAT (String) catalog</li>
     * <li>PROCEDURE_SCHEM (String) schema</li>
     * <li>PROCEDURE_NAME (String) name</li>
     * <li>reserved</li>
     * <li>reserved</li>
     * <li>reserved</li>
     * <li>REMARKS (String) description</li>
     * <li>PROCEDURE_TYPE (short) if this procedure returns a result
     * (procedureNoResult or procedureReturnsResult)</li>
     * <li>SPECIFIC_NAME (String) non-ambiguous name to distinguish
     * overloads</li>
     * </ol>
     *
     * @param catalog 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 SQLException if the connection is closed
     */
    @Override
    public ResultSet getProcedures(String catalog, String schemaPattern,
            String procedureNamePattern) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getProcedures("
                        +quote(catalog)+", "
                        +quote(schemaPattern)+", "
                        +quote(procedureNamePattern)+')');
            }
            return getResultSet(meta.getProcedures(catalog, schemaPattern, procedureNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of procedure columns. The result set is sorted by
     * PROCEDURE_SCHEM, PROCEDURE_NAME, NUM_INPUT_PARAMS, and POS.
     * There are potentially multiple procedures with the same name, each with a
     * different number of input parameters.
     *
     * <ol>
     * <li>PROCEDURE_CAT (String) catalog</li>
     * <li>PROCEDURE_SCHEM (String) schema</li>
     * <li>PROCEDURE_NAME (String) name</li>
     * <li>COLUMN_NAME (String) column name</li>
     * <li>COLUMN_TYPE (short) column type
     * (always DatabaseMetaData.procedureColumnIn)</li>
     * <li>DATA_TYPE (short) sql type</li>
     * <li>TYPE_NAME (String) type name</li>
     * <li>PRECISION (int) precision</li>
     * <li>LENGTH (int) length</li>
     * <li>SCALE (short) scale</li>
     * <li>RADIX (int)</li>
     * <li>NULLABLE (short) nullable
     * (DatabaseMetaData.columnNoNulls for primitive data types,
     * DatabaseMetaData.columnNullable otherwise)</li>
     * <li>REMARKS (String) description</li>
     * <li>COLUMN_DEF (String) always null</li>
     * <li>SQL_DATA_TYPE (int) for future use</li>
     * <li>SQL_DATETIME_SUB (int) for future use</li>
     * <li>CHAR_OCTET_LENGTH (int)</li>
     * <li>ORDINAL_POSITION (int) the parameter index
     * starting from 1 (0 is the return value)</li>
     * <li>IS_NULLABLE (String) always "YES"</li>
     * <li>SPECIFIC_NAME (String) non-ambiguous procedure name to distinguish
     * overloads</li>
     * </ol>
     *
     * @param catalog 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 SQLException if the connection is closed
     */
    @Override
    public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern,
            String columnNamePattern) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getProcedureColumns(" + quote(catalog) + ", " + quote(schemaPattern) + ", "
                        + quote(procedureNamePattern) + ", " + quote(columnNamePattern) + ')');
            }
            checkClosed();
            return getResultSet(
                    meta.getProcedureColumns(catalog, schemaPattern, procedureNamePattern, columnNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of schemas.
     * The result set is sorted by TABLE_SCHEM.
     *
     * <ol>
     * <li>TABLE_SCHEM (String) schema name</li>
     * <li>TABLE_CATALOG (String) catalog name</li>
     * </ol>
     *
     * @return the schema list
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getSchemas() throws SQLException {
        try {
            debugCodeCall("getSchemas");
            return getResultSet(meta.getSchemas());
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of catalogs.
     * The result set is sorted by TABLE_CAT.
     *
     * <ol>
     * <li>TABLE_CAT (String) catalog name</li>
     * </ol>
     *
     * @return the catalog list
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getCatalogs() throws SQLException {
        try {
            debugCodeCall("getCatalogs");
            return getResultSet(meta.getCatalogs());
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of table types. This call returns a result set with five
     * records: "SYSTEM TABLE", "TABLE", "VIEW", "TABLE LINK" and "EXTERNAL".
     * <ol>
     * <li>TABLE_TYPE (String) table type</li>
     * </ol>
     *
     * @return the table types
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getTableTypes() throws SQLException {
        try {
            debugCodeCall("getTableTypes");
            return getResultSet(meta.getTableTypes());
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of column privileges. The result set is sorted by
     * COLUMN_NAME and PRIVILEGE
     *
     * <ol>
     * <li>TABLE_CAT (String) table catalog</li>
     * <li>TABLE_SCHEM (String) table schema</li>
     * <li>TABLE_NAME (String) table name</li>
     * <li>COLUMN_NAME (String) column name</li>
     * <li>GRANTOR (String) grantor of access</li>
     * <li>GRANTEE (String) grantee of access</li>
     * <li>PRIVILEGE (String) SELECT, INSERT, UPDATE, DELETE or REFERENCES
     * (only one per row)</li>
     * <li>IS_GRANTABLE (String) YES means the grantee can grant access to
     * others</li>
     * </ol>
     *
     * @param catalog null (to get all objects) or the catalog name
     * @param schema 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 SQLException if the connection is closed
     */
    @Override
    public ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern)
            throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getColumnPrivileges(" + quote(catalog) + ", " + quote(schema) + ", " + quote(table) + ", "
                        + quote(columnNamePattern) + ')');
            }
            return getResultSet(meta.getColumnPrivileges(catalog, schema, table, columnNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of table privileges. The result set is sorted by
     * TABLE_SCHEM, TABLE_NAME, and PRIVILEGE.
     *
     * <ol>
     * <li>TABLE_CAT (String) table catalog</li>
     * <li>TABLE_SCHEM (String) table schema</li>
     * <li>TABLE_NAME (String) table name</li>
     * <li>GRANTOR (String) grantor of access</li>
     * <li>GRANTEE (String) grantee of access</li>
     * <li>PRIVILEGE (String) SELECT, INSERT, UPDATE, DELETE or REFERENCES
     * (only one per row)</li>
     * <li>IS_GRANTABLE (String) YES means the grantee can grant access to
     * others</li>
     * </ol>
     *
     * @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
     *            (uppercase for unquoted names)
     * @return the list of privileges
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern)
            throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getTablePrivileges(" + quote(catalog) + ", " + quote(schemaPattern) + ", "
                        + quote(tableNamePattern) + ')');
            }
            checkClosed();
            return getResultSet(meta.getTablePrivileges(catalog, schemaPattern, tableNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of columns that best identifier a row in a table.
     * The list is ordered by SCOPE.
     *
     * <ol>
     * <li>SCOPE (short) scope of result (always bestRowSession)</li>
     * <li>COLUMN_NAME (String) column name</li>
     * <li>DATA_TYPE (short) SQL data type, see also java.sql.Types</li>
     * <li>TYPE_NAME (String) type name</li>
     * <li>COLUMN_SIZE (int) precision
     *         (values larger than 2 GB are returned as 2 GB)</li>
     * <li>BUFFER_LENGTH (int) unused</li>
     * <li>DECIMAL_DIGITS (short) scale</li>
     * <li>PSEUDO_COLUMN (short) (always bestRowNotPseudo)</li>
     * </ol>
     *
     * @param catalog null (to get all objects) or the catalog name
     * @param schema null (to get all objects) or a schema name
     *            (uppercase for unquoted names)
     * @param table table name (must be specified)
     * @param scope ignored
     * @param nullable ignored
     * @return the primary key index
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable)
            throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getBestRowIdentifier(" + quote(catalog) + ", " + quote(schema) + ", " + quote(table) + ", "
                        + scope + ", " + nullable + ')');
            }
            return getResultSet(meta.getBestRowIdentifier(catalog, schema, table, scope, nullable));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Get the list of columns that are update when any value is updated.
     * The result set is always empty.
     *
     * <ol>
     * <li>1 SCOPE (int) not used</li>
     * <li>2 COLUMN_NAME (String) column name</li>
     * <li>3 DATA_TYPE (int) SQL data type - see also java.sql.Types</li>
     * <li>4 TYPE_NAME (String) data type name</li>
     * <li>5 COLUMN_SIZE (int) precision
     *         (values larger than 2 GB are returned as 2 GB)</li>
     * <li>6 BUFFER_LENGTH (int) length (bytes)</li>
     * <li>7 DECIMAL_DIGITS (int) scale</li>
     * <li>8 PSEUDO_COLUMN (int) is this column a pseudo column</li>
     * </ol>
     *
     * @param catalog null (to get all objects) or the catalog name
     * @param schema null (to get all objects) or a schema name
     * @param table table name (must be specified)
     * @return an empty result set
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getVersionColumns(" + quote(catalog) + ", " + quote(schema) + ", " + quote(table) + ')');
            }
            return getResultSet(meta.getVersionColumns(catalog, schema, table));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of primary key columns that are referenced by a table. The
     * result set is sorted by PKTABLE_CAT, PKTABLE_SCHEM, PKTABLE_NAME,
     * FK_NAME, KEY_SEQ.
     *
     * <ol>
     * <li>PKTABLE_CAT (String) primary catalog</li>
     * <li>PKTABLE_SCHEM (String) primary schema</li>
     * <li>PKTABLE_NAME (String) primary table</li>
     * <li>PKCOLUMN_NAME (String) primary column</li>
     * <li>FKTABLE_CAT (String) foreign catalog</li>
     * <li>FKTABLE_SCHEM (String) foreign schema</li>
     * <li>FKTABLE_NAME (String) foreign table</li>
     * <li>FKCOLUMN_NAME (String) foreign column</li>
     * <li>KEY_SEQ (short) sequence number (1, 2, ...)</li>
     * <li>UPDATE_RULE (short) action on update (see
     * DatabaseMetaData.importedKey...)</li>
     * <li>DELETE_RULE (short) action on delete (see
     * DatabaseMetaData.importedKey...)</li>
     * <li>FK_NAME (String) foreign key name</li>
     * <li>PK_NAME (String) primary key name</li>
     * <li>DEFERRABILITY (short) deferrable or not (always
     * importedKeyNotDeferrable)</li>
     * </ol>
     *
     * @param catalog null (to get all objects) or the catalog name
     * @param schema the schema name of the foreign table
     * @param table the name of the foreign table
     * @return the result set
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getImportedKeys(" + quote(catalog) + ", " + quote(schema) + ", " + quote(table) + ')');
            }
            return getResultSet(meta.getImportedKeys(catalog, schema, table));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of foreign key columns that reference a table. The result
     * set is sorted by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, FK_NAME,
     * KEY_SEQ.
     *
     * <ol>
     * <li>PKTABLE_CAT (String) primary catalog</li>
     * <li>PKTABLE_SCHEM (String) primary schema</li>
     * <li>PKTABLE_NAME (String) primary table</li>
     * <li>PKCOLUMN_NAME (String) primary column</li>
     * <li>FKTABLE_CAT (String) foreign catalog</li>
     * <li>FKTABLE_SCHEM (String) foreign schema</li>
     * <li>FKTABLE_NAME (String) foreign table</li>
     * <li>FKCOLUMN_NAME (String) foreign column</li>
     * <li>KEY_SEQ (short) sequence number (1,2,...)</li>
     * <li>UPDATE_RULE (short) action on update (see
     * DatabaseMetaData.importedKey...)</li>
     * <li>DELETE_RULE (short) action on delete (see
     * DatabaseMetaData.importedKey...)</li>
     * <li>FK_NAME (String) foreign key name</li>
     * <li>PK_NAME (String) primary key name</li>
     * <li>DEFERRABILITY (short) deferrable or not (always
     * importedKeyNotDeferrable)</li>
     * </ol>
     *
     * @param catalog null or the catalog name
     * @param schema the schema name of the primary table
     * @param table the name of the primary table
     * @return the result set
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getExportedKeys(" + quote(catalog) + ", " + quote(schema) + ", " + quote(table) + ')');
            }
            return getResultSet(meta.getExportedKeys(catalog, schema, table));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of foreign key columns that references a table, as well as
     * the list of primary key columns that are references by a table. The
     * result set is sorted by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME,
     * FK_NAME, KEY_SEQ.
     *
     * <ol>
     * <li>PKTABLE_CAT (String) primary catalog</li>
     * <li>PKTABLE_SCHEM (String) primary schema</li>
     * <li>PKTABLE_NAME (String) primary table</li>
     * <li>PKCOLUMN_NAME (String) primary column</li>
     * <li>FKTABLE_CAT (String) foreign catalog</li>
     * <li>FKTABLE_SCHEM (String) foreign schema</li>
     * <li>FKTABLE_NAME (String) foreign table</li>
     * <li>FKCOLUMN_NAME (String) foreign column</li>
     * <li>KEY_SEQ (short) sequence number (1,2,...)</li>
     * <li>UPDATE_RULE (short) action on update (see
     * DatabaseMetaData.importedKey...)</li>
     * <li>DELETE_RULE (short) action on delete (see
     * DatabaseMetaData.importedKey...)</li>
     * <li>FK_NAME (String) foreign key name</li>
     * <li>PK_NAME (String) primary key name</li>
     * <li>DEFERRABILITY (short) deferrable or not (always
     * importedKeyNotDeferrable)</li>
     * </ol>
     *
     * @param primaryCatalog null or the catalog name
     * @param primarySchema the schema name of the primary table
     *          (optional)
     * @param primaryTable the name of the primary table (must be specified)
     * @param foreignCatalog null or the catalog name
     * @param foreignSchema the schema name of the foreign table
     *          (optional)
     * @param foreignTable the name of the foreign table (must be specified)
     * @return the result set
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getCrossReference(String primaryCatalog, String primarySchema, String primaryTable,
            String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getCrossReference(" + quote(primaryCatalog) + ", " + quote(primarySchema) + ", "
                        + quote(primaryTable) + ", " + quote(foreignCatalog) + ", " + quote(foreignSchema) + ", "
                        + quote(foreignTable) + ')');
            }
            return getResultSet(meta.getCrossReference(primaryCatalog, primarySchema, primaryTable, foreignCatalog,
                    foreignSchema, foreignTable));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of user-defined data types.
     * This call returns an empty result set.
     *
     * <ol>
     * <li>TYPE_CAT (String) catalog</li>
     * <li>TYPE_SCHEM (String) schema</li>
     * <li>TYPE_NAME (String) type name</li>
     * <li>CLASS_NAME (String) Java class</li>
     * <li>DATA_TYPE (short) SQL Type - see also java.sql.Types</li>
     * <li>REMARKS (String) description</li>
     * <li>BASE_TYPE (short) base type - see also java.sql.Types</li>
     * </ol>
     *
     * @param catalog ignored
     * @param schemaPattern ignored
     * @param typeNamePattern ignored
     * @param types ignored
     * @return an empty result set
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getUDTs(String catalog, String schemaPattern,
            String typeNamePattern, int[] types) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getUDTs("
                        +quote(catalog)+", "
                        +quote(schemaPattern)+", "
                        +quote(typeNamePattern)+", "
                        +quoteIntArray(types)+')');
            }
            return getResultSet(meta.getUDTs(catalog, schemaPattern, typeNamePattern, types));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the list of data types. The result set is sorted by DATA_TYPE and
     * afterwards by how closely the data type maps to the corresponding JDBC
     * SQL type (best match first).
     *
     * <ol>
     * <li>TYPE_NAME (String) type name</li>
     * <li>DATA_TYPE (short) SQL data type - see also java.sql.Types</li>
     * <li>PRECISION (int) maximum precision</li>
     * <li>LITERAL_PREFIX (String) prefix used to quote a literal</li>
     * <li>LITERAL_SUFFIX (String) suffix used to quote a literal</li>
     * <li>CREATE_PARAMS (String) parameters used (may be null)</li>
     * <li>NULLABLE (short) typeNoNulls (NULL not allowed) or typeNullable</li>
     * <li>CASE_SENSITIVE (boolean) case sensitive</li>
     * <li>SEARCHABLE (short) typeSearchable</li>
     * <li>UNSIGNED_ATTRIBUTE (boolean) unsigned</li>
     * <li>FIXED_PREC_SCALE (boolean) fixed precision</li>
     * <li>AUTO_INCREMENT (boolean) auto increment</li>
     * <li>LOCAL_TYPE_NAME (String) localized version of the data type</li>
     * <li>MINIMUM_SCALE (short) minimum scale</li>
     * <li>MAXIMUM_SCALE (short) maximum scale</li>
     * <li>SQL_DATA_TYPE (int) unused</li>
     * <li>SQL_DATETIME_SUB (int) unused</li>
     * <li>NUM_PREC_RADIX (int) 2 for binary, 10 for decimal</li>
     * </ol>
     *
     * @return the list of data types
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getTypeInfo() throws SQLException {
        try {
            debugCodeCall("getTypeInfo");
            return getResultSet(meta.getTypeInfo());
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Checks if this database store data in local files.
     *
     * @return true
     */
    @Override
    public boolean usesLocalFiles() {
        debugCodeCall("usesLocalFiles");
        return true;
    }

    /**
     * Checks if this database use one file per table.
     *
     * @return false
     */
    @Override
    public boolean usesLocalFilePerTable() {
        debugCodeCall("usesLocalFilePerTable");
        return false;
    }

    /**
     * Returns the string used to quote identifiers.
     *
     * @return a double quote
     */
    @Override
    public String getIdentifierQuoteString() {
        debugCodeCall("getIdentifierQuoteString");
        return "\"";
    }

    /**
     * Gets the comma-separated list of all SQL keywords that are not supported
     * as unquoted identifiers, in addition to the SQL:2003 reserved words.
     * <p>
     * List of keywords in H2 may depend on compatibility mode and other
     * settings.
     * </p>
     *
     * @return a list of additional keywords
     */
    @Override
    public String getSQLKeywords() throws SQLException {
        try {
            debugCodeCall("getSQLKeywords");
            return meta.getSQLKeywords();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns the list of numeric functions supported by this database.
     *
     * @return the list
     */
    @Override
    public String getNumericFunctions() throws SQLException {
        try {
            debugCodeCall("getNumericFunctions");
            return meta.getNumericFunctions();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns the list of string functions supported by this database.
     *
     * @return the list
     */
    @Override
    public String getStringFunctions() throws SQLException {
        try {
            debugCodeCall("getStringFunctions");
            return meta.getStringFunctions();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns the list of system functions supported by this database.
     *
     * @return the list
     */
    @Override
    public String getSystemFunctions() throws SQLException {
        try {
            debugCodeCall("getSystemFunctions");
            return meta.getSystemFunctions();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns the list of date and time functions supported by this database.
     *
     * @return the list
     */
    @Override
    public String getTimeDateFunctions() throws SQLException {
        try {
            debugCodeCall("getTimeDateFunctions");
            return meta.getTimeDateFunctions();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns the default escape character for DatabaseMetaData search
     * patterns.
     *
     * @return the default escape character (always '\', independent on the
     *         mode)
     */
    @Override
    public String getSearchStringEscape() throws SQLException {
        try {
            debugCodeCall("getSearchStringEscape");
            return meta.getSearchStringEscape();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns the characters that are allowed for identifiers in addiction to
     * A-Z, a-z, 0-9 and '_'.
     *
     * @return an empty String ("")
     */
    @Override
    public String getExtraNameCharacters() {
        debugCodeCall("getExtraNameCharacters");
        return "";
    }

    /**
     * Returns whether alter table with add column is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsAlterTableWithAddColumn() {
        debugCodeCall("supportsAlterTableWithAddColumn");
        return true;
    }

    /**
     * Returns whether alter table with drop column is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsAlterTableWithDropColumn() {
        debugCodeCall("supportsAlterTableWithDropColumn");
        return true;
    }

    /**
     * Returns whether column aliasing is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsColumnAliasing() {
        debugCodeCall("supportsColumnAliasing");
        return true;
    }

    /**
     * Returns whether NULL+1 is NULL or not.
     *
     * @return true
     */
    @Override
    public boolean nullPlusNonNullIsNull() {
        debugCodeCall("nullPlusNonNullIsNull");
        return true;
    }

    /**
     * Returns whether CONVERT is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsConvert() {
        debugCodeCall("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
     */
    @Override
    public boolean supportsConvert(int fromType, int toType) {
        if (isDebugEnabled()) {
            debugCode("supportsConvert(" + fromType + ", " + toType + ')');
        }
        return true;
    }

    /**
     * Returns whether table correlation names (table alias) are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsTableCorrelationNames() {
        debugCodeCall("supportsTableCorrelationNames");
        return true;
    }

    /**
     * Returns whether table correlation names (table alias) are restricted to
     * be different than table names.
     *
     * @return false
     */
    @Override
    public boolean supportsDifferentTableCorrelationNames() {
        debugCodeCall("supportsDifferentTableCorrelationNames");
        return false;
    }

    /**
     * Returns whether expression in ORDER BY are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsExpressionsInOrderBy() {
        debugCodeCall("supportsExpressionsInOrderBy");
        return true;
    }

    /**
     * Returns whether ORDER BY is supported if the column is not in the SELECT
     * list.
     *
     * @return true
     */
    @Override
    public boolean supportsOrderByUnrelated() {
        debugCodeCall("supportsOrderByUnrelated");
        return true;
    }

    /**
     * Returns whether GROUP BY is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsGroupBy() {
        debugCodeCall("supportsGroupBy");
        return true;
    }

    /**
     * Returns whether GROUP BY is supported if the column is not in the SELECT
     * list.
     *
     * @return true
     */
    @Override
    public boolean supportsGroupByUnrelated() {
        debugCodeCall("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
     */
    @Override
    public boolean supportsGroupByBeyondSelect() {
        debugCodeCall("supportsGroupByBeyondSelect");
        return true;
    }

    /**
     * Returns whether LIKE... ESCAPE is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsLikeEscapeClause() {
        debugCodeCall("supportsLikeEscapeClause");
        return true;
    }

    /**
     * Returns whether multiple result sets are supported.
     *
     * @return false
     */
    @Override
    public boolean supportsMultipleResultSets() {
        debugCodeCall("supportsMultipleResultSets");
        return false;
    }

    /**
     * Returns whether multiple transactions (on different connections) are
     * supported.
     *
     * @return true
     */
    @Override
    public boolean supportsMultipleTransactions() {
        debugCodeCall("supportsMultipleTransactions");
        return true;
    }

    /**
     * Returns whether columns with NOT NULL are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsNonNullableColumns() {
        debugCodeCall("supportsNonNullableColumns");
        return true;
    }

    /**
     * Returns whether ODBC Minimum SQL grammar is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsMinimumSQLGrammar() {
        debugCodeCall("supportsMinimumSQLGrammar");
        return true;
    }

    /**
     * Returns whether ODBC Core SQL grammar is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsCoreSQLGrammar() {
        debugCodeCall("supportsCoreSQLGrammar");
        return true;
    }

    /**
     * Returns whether ODBC Extended SQL grammar is supported.
     *
     * @return false
     */
    @Override
    public boolean supportsExtendedSQLGrammar() {
        debugCodeCall("supportsExtendedSQLGrammar");
        return false;
    }

    /**
     * Returns whether SQL-92 entry level grammar is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsANSI92EntryLevelSQL() {
        debugCodeCall("supportsANSI92EntryLevelSQL");
        return true;
    }

    /**
     * Returns whether SQL-92 intermediate level grammar is supported.
     *
     * @return false
     */
    @Override
    public boolean supportsANSI92IntermediateSQL() {
        debugCodeCall("supportsANSI92IntermediateSQL");
        return false;
    }

    /**
     * Returns whether SQL-92 full level grammar is supported.
     *
     * @return false
     */
    @Override
    public boolean supportsANSI92FullSQL() {
        debugCodeCall("supportsANSI92FullSQL");
        return false;
    }

    /**
     * Returns whether referential integrity is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsIntegrityEnhancementFacility() {
        debugCodeCall("supportsIntegrityEnhancementFacility");
        return true;
    }

    /**
     * Returns whether outer joins are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsOuterJoins() {
        debugCodeCall("supportsOuterJoins");
        return true;
    }

    /**
     * Returns whether full outer joins are supported.
     *
     * @return false
     */
    @Override
    public boolean supportsFullOuterJoins() {
        debugCodeCall("supportsFullOuterJoins");
        return false;
    }

    /**
     * Returns whether limited outer joins are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsLimitedOuterJoins() {
        debugCodeCall("supportsLimitedOuterJoins");
        return true;
    }

    /**
     * Returns the term for "schema".
     *
     * @return "schema"
     */
    @Override
    public String getSchemaTerm() {
        debugCodeCall("getSchemaTerm");
        return "schema";
    }

    /**
     * Returns the term for "procedure".
     *
     * @return "procedure"
     */
    @Override
    public String getProcedureTerm() {
        debugCodeCall("getProcedureTerm");
        return "procedure";
    }

    /**
     * Returns the term for "catalog".
     *
     * @return "catalog"
     */
    @Override
    public String getCatalogTerm() {
        debugCodeCall("getCatalogTerm");
        return "catalog";
    }

    /**
     * Returns whether the catalog is at the beginning.
     *
     * @return true
     */
    @Override
    public boolean isCatalogAtStart() {
        debugCodeCall("isCatalogAtStart");
        return true;
    }

    /**
     * Returns the catalog separator.
     *
     * @return "."
     */
    @Override
    public String getCatalogSeparator() {
        debugCodeCall("getCatalogSeparator");
        return ".";
    }

    /**
     * Returns whether the schema name in INSERT, UPDATE, DELETE is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsSchemasInDataManipulation() {
        debugCodeCall("supportsSchemasInDataManipulation");
        return true;
    }

    /**
     * Returns whether the schema name in procedure calls is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsSchemasInProcedureCalls() {
        debugCodeCall("supportsSchemasInProcedureCalls");
        return true;
    }

    /**
     * Returns whether the schema name in CREATE TABLE is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsSchemasInTableDefinitions() {
        debugCodeCall("supportsSchemasInTableDefinitions");
        return true;
    }

    /**
     * Returns whether the schema name in CREATE INDEX is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsSchemasInIndexDefinitions() {
        debugCodeCall("supportsSchemasInIndexDefinitions");
        return true;
    }

    /**
     * Returns whether the schema name in GRANT is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsSchemasInPrivilegeDefinitions() {
        debugCodeCall("supportsSchemasInPrivilegeDefinitions");
        return true;
    }

    /**
     * Returns whether the catalog name in INSERT, UPDATE, DELETE is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsCatalogsInDataManipulation() {
        debugCodeCall("supportsCatalogsInDataManipulation");
        return true;
    }

    /**
     * Returns whether the catalog name in procedure calls is supported.
     *
     * @return false
     */
    @Override
    public boolean supportsCatalogsInProcedureCalls() {
        debugCodeCall("supportsCatalogsInProcedureCalls");
        return false;
    }

    /**
     * Returns whether the catalog name in CREATE TABLE is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsCatalogsInTableDefinitions() {
        debugCodeCall("supportsCatalogsInTableDefinitions");
        return true;
    }

    /**
     * Returns whether the catalog name in CREATE INDEX is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsCatalogsInIndexDefinitions() {
        debugCodeCall("supportsCatalogsInIndexDefinitions");
        return true;
    }

    /**
     * Returns whether the catalog name in GRANT is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsCatalogsInPrivilegeDefinitions() {
        debugCodeCall("supportsCatalogsInPrivilegeDefinitions");
        return true;
    }

    /**
     * Returns whether positioned deletes are supported.
     *
     * @return false
     */
    @Override
    public boolean supportsPositionedDelete() {
        debugCodeCall("supportsPositionedDelete");
        return false;
    }

    /**
     * Returns whether positioned updates are supported.
     *
     * @return false
     */
    @Override
    public boolean supportsPositionedUpdate() {
        debugCodeCall("supportsPositionedUpdate");
        return false;
    }

    /**
     * Returns whether SELECT ... FOR UPDATE is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsSelectForUpdate() {
        debugCodeCall("supportsSelectForUpdate");
        return true;
    }

    /**
     * Returns whether stored procedures are supported.
     *
     * @return false
     */
    @Override
    public boolean supportsStoredProcedures() {
        debugCodeCall("supportsStoredProcedures");
        return false;
    }

    /**
     * Returns whether subqueries (SELECT) in comparisons are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsSubqueriesInComparisons() {
        debugCodeCall("supportsSubqueriesInComparisons");
        return true;
    }

    /**
     * Returns whether SELECT in EXISTS is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsSubqueriesInExists() {
        debugCodeCall("supportsSubqueriesInExists");
        return true;
    }

    /**
     * Returns whether IN(SELECT...) is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsSubqueriesInIns() {
        debugCodeCall("supportsSubqueriesInIns");
        return true;
    }

    /**
     * Returns whether subqueries in quantified expression are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsSubqueriesInQuantifieds() {
        debugCodeCall("supportsSubqueriesInQuantifieds");
        return true;
    }

    /**
     * Returns whether correlated subqueries are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsCorrelatedSubqueries() {
        debugCodeCall("supportsCorrelatedSubqueries");
        return true;
    }

    /**
     * Returns whether UNION SELECT is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsUnion() {
        debugCodeCall("supportsUnion");
        return true;
    }

    /**
     * Returns whether UNION ALL SELECT is supported.
     *
     * @return true
     */
    @Override
    public boolean supportsUnionAll() {
        debugCodeCall("supportsUnionAll");
        return true;
    }

    /**
     * Returns whether open result sets across commits are supported.
     *
     * @return false
     */
    @Override
    public boolean supportsOpenCursorsAcrossCommit() {
        debugCodeCall("supportsOpenCursorsAcrossCommit");
        return false;
    }

    /**
     * Returns whether open result sets across rollback are supported.
     *
     * @return false
     */
    @Override
    public boolean supportsOpenCursorsAcrossRollback() {
        debugCodeCall("supportsOpenCursorsAcrossRollback");
        return false;
    }

    /**
     * Returns whether open statements across commit are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsOpenStatementsAcrossCommit() {
        debugCodeCall("supportsOpenStatementsAcrossCommit");
        return true;
    }

    /**
     * Returns whether open statements across rollback are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsOpenStatementsAcrossRollback() {
        debugCodeCall("supportsOpenStatementsAcrossRollback");
        return true;
    }

    /**
     * Returns whether transactions are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsTransactions() {
        debugCodeCall("supportsTransactions");
        return true;
    }

    /**
     * Returns whether a specific transaction isolation level is supported.
     *
     * @param level the transaction isolation level (Connection.TRANSACTION_*)
     * @return true
     */
    @Override
    public boolean supportsTransactionIsolationLevel(int level) throws SQLException {
        debugCodeCall("supportsTransactionIsolationLevel");
        switch (level) {
        case Connection.TRANSACTION_READ_UNCOMMITTED:
        case Connection.TRANSACTION_READ_COMMITTED:
        case Connection.TRANSACTION_REPEATABLE_READ:
        case Constants.TRANSACTION_SNAPSHOT:
        case Connection.TRANSACTION_SERIALIZABLE:
            return true;
        default:
            return false;
        }
    }

    /**
     * Returns whether data manipulation and CREATE/DROP is supported in
     * transactions.
     *
     * @return false
     */
    @Override
    public boolean supportsDataDefinitionAndDataManipulationTransactions() {
        debugCodeCall("supportsDataDefinitionAndDataManipulationTransactions");
        return false;
    }

    /**
     * Returns whether only data manipulations are supported in transactions.
     *
     * @return true
     */
    @Override
    public boolean supportsDataManipulationTransactionsOnly() {
        debugCodeCall("supportsDataManipulationTransactionsOnly");
        return true;
    }

    /**
     * Returns whether CREATE/DROP commit an open transaction.
     *
     * @return true
     */
    @Override
    public boolean dataDefinitionCausesTransactionCommit() {
        debugCodeCall("dataDefinitionCausesTransactionCommit");
        return true;
    }

    /**
     * Returns whether CREATE/DROP do not affect transactions.
     *
     * @return false
     */
    @Override
    public boolean dataDefinitionIgnoredInTransactions() {
        debugCodeCall("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_SCROLL_SENSITIVE
     */
    @Override
    public boolean supportsResultSetType(int type) {
        debugCodeCall("supportsResultSetType", 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
     */
    @Override
    public boolean supportsResultSetConcurrency(int type, int concurrency) {
        if (isDebugEnabled()) {
            debugCode("supportsResultSetConcurrency(" + type + ", " + concurrency + ')');
        }
        return type != ResultSet.TYPE_SCROLL_SENSITIVE;
    }

    /**
     * Returns whether own updates are visible.
     *
     * @param type the result set type
     * @return true
     */
    @Override
    public boolean ownUpdatesAreVisible(int type) {
        debugCodeCall("ownUpdatesAreVisible", type);
        return true;
    }

    /**
     * Returns whether own deletes are visible.
     *
     * @param type the result set type
     * @return false
     */
    @Override
    public boolean ownDeletesAreVisible(int type) {
        debugCodeCall("ownDeletesAreVisible", type);
        return false;
    }

    /**
     * Returns whether own inserts are visible.
     *
     * @param type the result set type
     * @return false
     */
    @Override
    public boolean ownInsertsAreVisible(int type) {
        debugCodeCall("ownInsertsAreVisible", type);
        return false;
    }

    /**
     * Returns whether other updates are visible.
     *
     * @param type the result set type
     * @return false
     */
    @Override
    public boolean othersUpdatesAreVisible(int type) {
        debugCodeCall("othersUpdatesAreVisible", type);
        return false;
    }

    /**
     * Returns whether other deletes are visible.
     *
     * @param type the result set type
     * @return false
     */
    @Override
    public boolean othersDeletesAreVisible(int type) {
        debugCodeCall("othersDeletesAreVisible", type);
        return false;
    }

    /**
     * Returns whether other inserts are visible.
     *
     * @param type the result set type
     * @return false
     */
    @Override
    public boolean othersInsertsAreVisible(int type) {
        debugCodeCall("othersInsertsAreVisible", type);
        return false;
    }

    /**
     * Returns whether updates are detected.
     *
     * @param type the result set type
     * @return false
     */
    @Override
    public boolean updatesAreDetected(int type) {
        debugCodeCall("updatesAreDetected", type);
        return false;
    }

    /**
     * Returns whether deletes are detected.
     *
     * @param type the result set type
     * @return false
     */
    @Override
    public boolean deletesAreDetected(int type) {
        debugCodeCall("deletesAreDetected", type);
        return false;
    }

    /**
     * Returns whether inserts are detected.
     *
     * @param type the result set type
     * @return false
     */
    @Override
    public boolean insertsAreDetected(int type) {
        debugCodeCall("insertsAreDetected", type);
        return false;
    }

    /**
     * Returns whether batch updates are supported.
     *
     * @return true
     */
    @Override
    public boolean supportsBatchUpdates() {
        debugCodeCall("supportsBatchUpdates");
        return true;
    }

    /**
     * Returns whether the maximum row size includes blobs.
     *
     * @return false
     */
    @Override
    public boolean doesMaxRowSizeIncludeBlobs() {
        debugCodeCall("doesMaxRowSizeIncludeBlobs");
        return false;
    }

    /**
     * Returns the default transaction isolation level.
     *
     * @return Connection.TRANSACTION_READ_COMMITTED
     */
    @Override
    public int getDefaultTransactionIsolation() {
        debugCodeCall("getDefaultTransactionIsolation");
        return Connection.TRANSACTION_READ_COMMITTED;
    }

    /**
     * Checks if for CREATE TABLE Test(ID INT), getTables returns Test as the
     * table name and identifiers are case sensitive.
     *
     * @return true is so, false otherwise
     */
    @Override
    public boolean supportsMixedCaseIdentifiers() throws SQLException {
        debugCodeCall("supportsMixedCaseIdentifiers");
        Session.StaticSettings settings = conn.getStaticSettings();
        return !settings.databaseToUpper && !settings.databaseToLower && !settings.caseInsensitiveIdentifiers;
    }

    /**
     * Checks if for CREATE TABLE Test(ID INT), getTables returns TEST as the
     * table name.
     *
     * @return true is so, false otherwise
     */
    @Override
    public boolean storesUpperCaseIdentifiers() throws SQLException {
        debugCodeCall("storesUpperCaseIdentifiers");
        return conn.getStaticSettings().databaseToUpper;
    }

    /**
     * Checks if for CREATE TABLE Test(ID INT), getTables returns test as the
     * table name.
     *
     * @return true is so, false otherwise
     */
    @Override
    public boolean storesLowerCaseIdentifiers() throws SQLException {
        debugCodeCall("storesLowerCaseIdentifiers");
        return conn.getStaticSettings().databaseToLower;
    }

    /**
     * Checks if for CREATE TABLE Test(ID INT), getTables returns Test as the
     * table name and identifiers are not case sensitive.
     *
     * @return true is so, false otherwise
     */
    @Override
    public boolean storesMixedCaseIdentifiers() throws SQLException {
        debugCodeCall("storesMixedCaseIdentifiers");
        Session.StaticSettings settings = conn.getStaticSettings();
        return !settings.databaseToUpper && !settings.databaseToLower && settings.caseInsensitiveIdentifiers;
    }

    /**
     * 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 is so, false otherwise
     */
    @Override
    public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
        debugCodeCall("supportsMixedCaseQuotedIdentifiers");
        return !conn.getStaticSettings().caseInsensitiveIdentifiers;
    }

    /**
     * Checks if for CREATE TABLE "Test"(ID INT), getTables returns TEST as the
     * table name.
     *
     * @return false
     */
    @Override
    public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
        debugCodeCall("storesUpperCaseQuotedIdentifiers");
        return false;
    }

    /**
     * Checks if for CREATE TABLE "Test"(ID INT), getTables returns test as the
     * table name.
     *
     * @return false
     */
    @Override
    public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
        debugCodeCall("storesLowerCaseQuotedIdentifiers");
        return false;
    }

    /**
     * Checks if for CREATE TABLE "Test"(ID INT), getTables returns Test as the
     * table name and identifiers are case insensitive.
     *
     * @return true is so, false otherwise
     */
    @Override
    public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
        debugCodeCall("storesMixedCaseQuotedIdentifiers");
        return conn.getStaticSettings().caseInsensitiveIdentifiers;
    }

    /**
     * Returns the maximum length for hex values (characters).
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxBinaryLiteralLength() {
        debugCodeCall("getMaxBinaryLiteralLength");
        return 0;
    }

    /**
     * Returns the maximum length for literals.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxCharLiteralLength() {
        debugCodeCall("getMaxCharLiteralLength");
        return 0;
    }

    /**
     * Returns the maximum length for column names.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxColumnNameLength() {
        debugCodeCall("getMaxColumnNameLength");
        return 0;
    }

    /**
     * Returns the maximum number of columns in GROUP BY.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxColumnsInGroupBy() {
        debugCodeCall("getMaxColumnsInGroupBy");
        return 0;
    }

    /**
     * Returns the maximum number of columns in CREATE INDEX.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxColumnsInIndex() {
        debugCodeCall("getMaxColumnsInIndex");
        return 0;
    }

    /**
     * Returns the maximum number of columns in ORDER BY.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxColumnsInOrderBy() {
        debugCodeCall("getMaxColumnsInOrderBy");
        return 0;
    }

    /**
     * Returns the maximum number of columns in SELECT.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxColumnsInSelect() {
        debugCodeCall("getMaxColumnsInSelect");
        return 0;
    }

    /**
     * Returns the maximum number of columns in CREATE TABLE.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxColumnsInTable() {
        debugCodeCall("getMaxColumnsInTable");
        return 0;
    }

    /**
     * Returns the maximum number of open connection.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxConnections() {
        debugCodeCall("getMaxConnections");
        return 0;
    }

    /**
     * Returns the maximum length for a cursor name.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxCursorNameLength() {
        debugCodeCall("getMaxCursorNameLength");
        return 0;
    }

    /**
     * Returns the maximum length for an index (in bytes).
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxIndexLength() {
        debugCodeCall("getMaxIndexLength");
        return 0;
    }

    /**
     * Returns the maximum length for a schema name.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxSchemaNameLength() {
        debugCodeCall("getMaxSchemaNameLength");
        return 0;
    }

    /**
     * Returns the maximum length for a procedure name.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxProcedureNameLength() {
        debugCodeCall("getMaxProcedureNameLength");
        return 0;
    }

    /**
     * Returns the maximum length for a catalog name.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxCatalogNameLength() {
        debugCodeCall("getMaxCatalogNameLength");
        return 0;
    }

    /**
     * Returns the maximum size of a row (in bytes).
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxRowSize() {
        debugCodeCall("getMaxRowSize");
        return 0;
    }

    /**
     * Returns the maximum length of a statement.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxStatementLength() {
        debugCodeCall("getMaxStatementLength");
        return 0;
    }

    /**
     * Returns the maximum number of open statements.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxStatements() {
        debugCodeCall("getMaxStatements");
        return 0;
    }

    /**
     * Returns the maximum length for a table name.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxTableNameLength() {
        debugCodeCall("getMaxTableNameLength");
        return 0;
    }

    /**
     * Returns the maximum number of tables in a SELECT.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxTablesInSelect() {
        debugCodeCall("getMaxTablesInSelect");
        return 0;
    }

    /**
     * Returns the maximum length for a user name.
     *
     * @return 0 for limit is unknown
     */
    @Override
    public int getMaxUserNameLength() {
        debugCodeCall("getMaxUserNameLength");
        return 0;
    }

    /**
     * Does the database support savepoints.
     *
     * @return true
     */
    @Override
    public boolean supportsSavepoints() {
        debugCodeCall("supportsSavepoints");
        return true;
    }

    /**
     * Does the database support named parameters.
     *
     * @return false
     */
    @Override
    public boolean supportsNamedParameters() {
        debugCodeCall("supportsNamedParameters");
        return false;
    }

    /**
     * Does the database support multiple open result sets returned from a
     * <code>CallableStatement</code>.
     *
     * @return false
     */
    @Override
    public boolean supportsMultipleOpenResults() {
        debugCodeCall("supportsMultipleOpenResults");
        return false;
    }

    /**
     * Does the database support getGeneratedKeys.
     *
     * @return true
     */
    @Override
    public boolean supportsGetGeneratedKeys() {
        debugCodeCall("supportsGetGeneratedKeys");
        return true;
    }

    /**
     * [Not supported]
     */
    @Override
    public ResultSet getSuperTypes(String catalog, String schemaPattern, String typeNamePattern) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getSuperTypes(" + quote(catalog) + ", " + quote(schemaPattern) + ", "
                        + quote(typeNamePattern) + ')');
            }
            return getResultSet(meta.getSuperTypes(catalog, schemaPattern, typeNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Get the list of super tables of a table. This method currently returns an
     * empty result set.
     * <ol>
     * <li>TABLE_CAT (String) table catalog</li>
     * <li>TABLE_SCHEM (String) table schema</li>
     * <li>TABLE_NAME (String) table name</li>
     * <li>SUPERTABLE_NAME (String) the name of the super table</li>
     * </ol>
     *
     * @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
     */
    @Override
    public ResultSet getSuperTables(String catalog, String schemaPattern, String tableNamePattern) //
            throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getSuperTables(" + quote(catalog) + ", " + quote(schemaPattern) + ", "
                        + quote(tableNamePattern) + ')');
            }
            return getResultSet(meta.getSuperTables(catalog, schemaPattern, tableNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * [Not supported]
     */
    @Override
    public ResultSet getAttributes(String catalog, String schemaPattern, String typeNamePattern,
            String attributeNamePattern) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getAttributes(" + quote(catalog) + ", " + quote(schemaPattern) + ", "
                        + quote(typeNamePattern) + ", " + quote(attributeNamePattern) + ')');
            }
            return getResultSet(meta.getAttributes(catalog, schemaPattern, typeNamePattern, attributeNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * 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
     */
    @Override
    public boolean supportsResultSetHoldability(int holdability) {
        debugCodeCall("supportsResultSetHoldability", holdability);
        return holdability == ResultSet.CLOSE_CURSORS_AT_COMMIT;
    }

    /**
     * Gets the result set holdability.
     *
     * @return ResultSet.CLOSE_CURSORS_AT_COMMIT
     */
    @Override
    public int getResultSetHoldability() {
        debugCodeCall("getResultSetHoldability");
        return ResultSet.CLOSE_CURSORS_AT_COMMIT;
    }

    /**
     * Gets the major version of the database.
     *
     * @return the major version
     */
    @Override
    public int getDatabaseMajorVersion() throws SQLException {
        try {
            debugCodeCall("getDatabaseMajorVersion");
            return meta.getDatabaseMajorVersion();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the minor version of the database.
     *
     * @return the minor version
     */
    @Override
    public int getDatabaseMinorVersion() throws SQLException {
        try {
            debugCodeCall("getDatabaseMinorVersion");
            return meta.getDatabaseMinorVersion();
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Gets the major version of the supported JDBC API.
     *
     * @return the major version (4)
     */
    @Override
    public int getJDBCMajorVersion() {
        debugCodeCall("getJDBCMajorVersion");
        return 4;
    }

    /**
     * Gets the minor version of the supported JDBC API.
     *
     * @return the minor version (2)
     */
    @Override
    public int getJDBCMinorVersion() {
        debugCodeCall("getJDBCMinorVersion");
        return 2;
    }

    /**
     * Gets the SQL State type.
     *
     * @return {@link DatabaseMetaData#sqlStateSQL}
     */
    @Override
    public int getSQLStateType() {
        debugCodeCall("getSQLStateType");
        return DatabaseMetaData.sqlStateSQL;
    }

    /**
     * Does the database make a copy before updating.
     *
     * @return false
     */
    @Override
    public boolean locatorsUpdateCopy() {
        debugCodeCall("locatorsUpdateCopy");
        return false;
    }

    /**
     * Does the database support statement pooling.
     *
     * @return false
     */
    @Override
    public boolean supportsStatementPooling() {
        debugCodeCall("supportsStatementPooling");
        return false;
    }

    // =============================================================

    private void checkClosed() {
        conn.checkClosed();
    }

    /**
     * Get the lifetime of a rowid.
     *
     * @return ROWID_UNSUPPORTED
     */
    @Override
    public RowIdLifetime getRowIdLifetime() {
        debugCodeCall("getRowIdLifetime");
        return RowIdLifetime.ROWID_UNSUPPORTED;
    }

    /**
     * Gets the list of schemas in the database.
     * The result set is sorted by TABLE_SCHEM.
     *
     * <ol>
     * <li>TABLE_SCHEM (String) schema name</li>
     * <li>TABLE_CATALOG (String) catalog name</li>
     * </ol>
     *
     * @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)
     * @return the schema list
     * @throws SQLException if the connection is closed
     */
    @Override
    public ResultSet getSchemas(String catalogPattern, String schemaPattern)
            throws SQLException {
        try {
            debugCodeCall("getSchemas(String,String)");
            return getResultSet(meta.getSchemas(catalogPattern, schemaPattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns whether the database supports calling functions using the call
     * syntax.
     *
     * @return true
     */
    @Override
    public boolean supportsStoredFunctionsUsingCallSyntax() {
        debugCodeCall("supportsStoredFunctionsUsingCallSyntax");
        return true;
    }

    /**
     * Returns whether an exception while auto commit is on closes all result
     * sets.
     *
     * @return false
     */
    @Override
    public boolean autoCommitFailureClosesAllResultSets() {
        debugCodeCall("autoCommitFailureClosesAllResultSets");
        return false;
    }

    @Override
    public ResultSet getClientInfoProperties() throws SQLException {
        Properties clientInfo = conn.getClientInfo();
        SimpleResult result = new SimpleResult();
        result.addColumn("NAME", TypeInfo.TYPE_VARCHAR);
        result.addColumn("MAX_LEN", TypeInfo.TYPE_INTEGER);
        result.addColumn("DEFAULT_VALUE", TypeInfo.TYPE_VARCHAR);
        result.addColumn("DESCRIPTION", TypeInfo.TYPE_VARCHAR);
        // Non-standard column
        result.addColumn("VALUE", TypeInfo.TYPE_VARCHAR);
        for (Entry<Object, Object> entry : clientInfo.entrySet()) {
            result.addRow(ValueVarchar.get((String) entry.getKey()), ValueInteger.get(Integer.MAX_VALUE),
                    ValueVarchar.EMPTY, ValueVarchar.EMPTY, ValueVarchar.get((String) entry.getValue()));
        }
        int id = getNextId(TraceObject.RESULT_SET);
        debugCodeAssign("ResultSet", TraceObject.RESULT_SET, id, "getClientInfoProperties()");
        return new JdbcResultSet(conn, null, null, result, id, true, false, false);
    }

    /**
     * Return an object of this class if possible.
     *
     * @param iface the class
     * @return this
     */
    @Override
    @SuppressWarnings("unchecked")
    public <T> T unwrap(Class<T> iface) throws SQLException {
        try {
            if (isWrapperFor(iface)) {
                return (T) this;
            }
            throw DbException.getInvalidValueException("iface", iface);
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Checks if unwrap can return an object of this class.
     *
     * @param iface the class
     * @return whether or not the interface is assignable from this class
     */
    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return iface != null && iface.isAssignableFrom(getClass());
    }

    /**
     * [Not supported] Gets the list of function columns.
     */
    @Override
    public ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern,
            String columnNamePattern) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getFunctionColumns(" + quote(catalog) + ", " + quote(schemaPattern) + ", "
                        + quote(functionNamePattern) + ", " + quote(columnNamePattern) + ')');
            }
            return getResultSet(
                    meta.getFunctionColumns(catalog, schemaPattern, functionNamePattern, columnNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * [Not supported] Gets the list of functions.
     */
    @Override
    public ResultSet getFunctions(String catalog, String schemaPattern, String functionNamePattern)
            throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getFunctions(" + quote(catalog) + ", " + quote(schemaPattern) + ", "
                        + quote(functionNamePattern) + ')');
            }
            return getResultSet(meta.getFunctions(catalog, schemaPattern, functionNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * Returns whether database always returns generated keys if valid names or
     * indexes of columns were specified and command was completed successfully.
     *
     * @return true
     */
    @Override
    public boolean generatedKeyAlwaysReturned() {
        return true;
    }

    /**
     * Gets the list of pseudo and invisible columns. The result set is sorted
     * by TABLE_SCHEM, TABLE_NAME, and COLUMN_NAME.
     *
     * <ol>
     * <li>TABLE_CAT (String) table catalog</li>
     * <li>TABLE_SCHEM (String) table schema</li>
     * <li>TABLE_NAME (String) table name</li>
     * <li>COLUMN_NAME (String) column name</li>
     * <li>DATA_TYPE (int) data type (see java.sql.Types)</li>
     * <li>COLUMN_SIZE (int) precision
     *         (values larger than 2 GB are returned as 2 GB)</li>
     * <li>DECIMAL_DIGITS (int) scale (0 for INTEGER and VARCHAR)</li>
     * <li>NUM_PREC_RADIX (int) radix</li>
     * <li>COLUMN_USAGE (String) he allowed usage for the column,
     *         see {@link java.sql.PseudoColumnUsage}</li>
     * <li>REMARKS (String) comment</li>
     * <li>CHAR_OCTET_LENGTH (int) for char types the
     *         maximum number of bytes in the column</li>
     * <li>IS_NULLABLE (String) "NO" or "YES"</li>
     * </ol>
     *
     * @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
     *            (uppercase for unquoted names)
     * @param columnNamePattern null (to get all objects) or a column name
     *            (uppercase for unquoted names)
     * @return the list of pseudo and invisible columns
     */
    @Override
    public ResultSet getPseudoColumns(String catalog, String schemaPattern, String tableNamePattern,
            String columnNamePattern) throws SQLException {
        try {
            if (isDebugEnabled()) {
                debugCode("getPseudoColumns(" + quote(catalog) + ", " + quote(schemaPattern) + ", "
                        + quote(tableNamePattern) + ", " + quote(columnNamePattern) + ')');
            }
            return getResultSet(meta.getPseudoColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern));
        } catch (Exception e) {
            throw logAndConvert(e);
        }
    }

    /**
     * INTERNAL
     */
    @Override
    public String toString() {
        return getTraceObjectName() + ": " + conn;
    }

    private JdbcResultSet getResultSet(ResultInterface result) {
        return new JdbcResultSet(conn, null, null, result, getNextId(TraceObject.RESULT_SET), true, false, false);
    }

}
