    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017package org.apache.commons.dbcp2;
    018
    019import java.sql.Connection;
    020import java.sql.DatabaseMetaData;
    021import java.sql.ResultSet;
    022import java.sql.RowIdLifetime;
    023import java.sql.SQLException;
    024
    025/**
    026 * <p>
    027 * A base delegating implementation of {@link DatabaseMetaData}.
    028 * </p>
    029 * <p>
    030 * Methods that create {@link ResultSet} objects are wrapped to create {@link DelegatingResultSet} objects and the
    031 * remaining methods simply call the corresponding method on the "delegate" provided in the constructor.
    032 * </p>
    033 *
    034 * @since 2.0
    035 */
    036public class DelegatingDatabaseMetaData implements DatabaseMetaData {
    037
    038    /** My delegate {@link DatabaseMetaData} */
    039    private final DatabaseMetaData databaseMetaData;
    040
    041    /** The connection that created me. **/
    042    private final DelegatingConnection<?> connection;
    043
    044    /**
    045     * Constructs a new instance for the given delegating connection and database meta data.
    046     *
    047     * @param connection
    048     *            the delegating connection
    049     * @param databaseMetaData
    050     *            the database meta data
    051     */
    052    public DelegatingDatabaseMetaData(final DelegatingConnection<?> connection,
    053            final DatabaseMetaData databaseMetaData) {
    054        this.connection = connection;
    055        this.databaseMetaData = databaseMetaData;
    056    }
    057
    058    @Override
    059    public boolean allProceduresAreCallable() throws SQLException {
    060        try {
    061            return databaseMetaData.allProceduresAreCallable();
    062        } catch (final SQLException e) {
    063            handleException(e);
    064            return false;
    065        }
    066    }
    067
    068    @Override
    069    public boolean allTablesAreSelectable() throws SQLException {
    070        try {
    071            return databaseMetaData.allTablesAreSelectable();
    072        } catch (final SQLException e) {
    073            handleException(e);
    074            return false;
    075        }
    076    }
    077
    078    @Override
    079    public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
    080        try {
    081            return databaseMetaData.autoCommitFailureClosesAllResultSets();
    082        } catch (final SQLException e) {
    083            handleException(e);
    084            return false;
    085        }
    086    }
    087
    088    @Override
    089    public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
    090        try {
    091            return databaseMetaData.dataDefinitionCausesTransactionCommit();
    092        } catch (final SQLException e) {
    093            handleException(e);
    094            return false;
    095        }
    096    }
    097
    098    @Override
    099    public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
    100        try {
    101            return databaseMetaData.dataDefinitionIgnoredInTransactions();
    102        } catch (final SQLException e) {
    103            handleException(e);
    104            return false;
    105        }
    106    }
    107
    108    @Override
    109    public boolean deletesAreDetected(final int type) throws SQLException {
    110        try {
    111            return databaseMetaData.deletesAreDetected(type);
    112        } catch (final SQLException e) {
    113            handleException(e);
    114            return false;
    115        }
    116    }
    117
    118    @Override
    119    public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
    120        try {
    121            return databaseMetaData.doesMaxRowSizeIncludeBlobs();
    122        } catch (final SQLException e) {
    123            handleException(e);
    124            return false;
    125        }
    126    }
    127
    128    @Override
    129    public boolean generatedKeyAlwaysReturned() throws SQLException {
    130        connection.checkOpen();
    131        try {
    132            return Jdbc41Bridge.generatedKeyAlwaysReturned(databaseMetaData);
    133        } catch (final SQLException e) {
    134            handleException(e);
    135            return false;
    136        }
    137    }
    138
    139    @Override
    140    public ResultSet getAttributes(final String catalog, final String schemaPattern, final String typeNamePattern,
    141            final String attributeNamePattern) throws SQLException {
    142        connection.checkOpen();
    143        try {
    144            return DelegatingResultSet.wrapResultSet(connection,
    145                    databaseMetaData.getAttributes(catalog, schemaPattern, typeNamePattern, attributeNamePattern));
    146        } catch (final SQLException e) {
    147            handleException(e);
    148            throw new AssertionError();
    149        }
    150    }
    151
    152    @Override
    153    public ResultSet getBestRowIdentifier(final String catalog, final String schema, final String table,
    154            final int scope, final boolean nullable) throws SQLException {
    155        connection.checkOpen();
    156        try {
    157            return DelegatingResultSet.wrapResultSet(connection,
    158                    databaseMetaData.getBestRowIdentifier(catalog, schema, table, scope, nullable));
    159        } catch (final SQLException e) {
    160            handleException(e);
    161            throw new AssertionError();
    162        }
    163    }
    164
    165    @Override
    166    public ResultSet getCatalogs() throws SQLException {
    167        connection.checkOpen();
    168        try {
    169            return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getCatalogs());
    170        } catch (final SQLException e) {
    171            handleException(e);
    172            throw new AssertionError();
    173        }
    174    }
    175
    176    @Override
    177    public String getCatalogSeparator() throws SQLException {
    178        try {
    179            return databaseMetaData.getCatalogSeparator();
    180        } catch (final SQLException e) {
    181            handleException(e);
    182            throw new AssertionError();
    183        }
    184    }
    185
    186    @Override
    187    public String getCatalogTerm() throws SQLException {
    188        try {
    189            return databaseMetaData.getCatalogTerm();
    190        } catch (final SQLException e) {
    191            handleException(e);
    192            throw new AssertionError();
    193        }
    194    }
    195
    196    @Override
    197    public ResultSet getClientInfoProperties() throws SQLException {
    198        connection.checkOpen();
    199        try {
    200            return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getClientInfoProperties());
    201        } catch (final SQLException e) {
    202            handleException(e);
    203            throw new AssertionError();
    204        }
    205    }
    206
    207    @Override
    208    public ResultSet getColumnPrivileges(final String catalog, final String schema, final String table,
    209            final String columnNamePattern) throws SQLException {
    210        connection.checkOpen();
    211        try {
    212            return DelegatingResultSet.wrapResultSet(connection,
    213                    databaseMetaData.getColumnPrivileges(catalog, schema, table, columnNamePattern));
    214        } catch (final SQLException e) {
    215            handleException(e);
    216            throw new AssertionError();
    217        }
    218    }
    219
    220    @Override
    221    public ResultSet getColumns(final String catalog, final String schemaPattern, final String tableNamePattern,
    222            final String columnNamePattern) throws SQLException {
    223        connection.checkOpen();
    224        try {
    225            return DelegatingResultSet.wrapResultSet(connection,
    226                    databaseMetaData.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern));
    227        } catch (final SQLException e) {
    228            handleException(e);
    229            throw new AssertionError();
    230        }
    231    }
    232
    233    @Override
    234    public Connection getConnection() throws SQLException {
    235        return connection;
    236    }
    237
    238    @Override
    239    public ResultSet getCrossReference(final String parentCatalog, final String parentSchema, final String parentTable,
    240            final String foreignCatalog, final String foreignSchema, final String foreignTable) throws SQLException {
    241        connection.checkOpen();
    242        try {
    243            return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getCrossReference(parentCatalog,
    244                    parentSchema, parentTable, foreignCatalog, foreignSchema, foreignTable));
    245        } catch (final SQLException e) {
    246            handleException(e);
    247            throw new AssertionError();
    248        }
    249    }
    250
    251    @Override
    252    public int getDatabaseMajorVersion() throws SQLException {
    253        try {
    254            return databaseMetaData.getDatabaseMajorVersion();
    255        } catch (final SQLException e) {
    256            handleException(e);
    257            return 0;
    258        }
    259    }
    260
    261    @Override
    262    public int getDatabaseMinorVersion() throws SQLException {
    263        try {
    264            return databaseMetaData.getDatabaseMinorVersion();
    265        } catch (final SQLException e) {
    266            handleException(e);
    267            return 0;
    268        }
    269    }
    270
    271    @Override
    272    public String getDatabaseProductName() throws SQLException {
    273        try {
    274            return databaseMetaData.getDatabaseProductName();
    275        } catch (final SQLException e) {
    276            handleException(e);
    277            throw new AssertionError();
    278        }
    279    }
    280
    281    @Override
    282    public String getDatabaseProductVersion() throws SQLException {
    283        try {
    284            return databaseMetaData.getDatabaseProductVersion();
    285        } catch (final SQLException e) {
    286            handleException(e);
    287            throw new AssertionError();
    288        }
    289    }
    290
    291    @Override
    292    public int getDefaultTransactionIsolation() throws SQLException {
    293        try {
    294            return databaseMetaData.getDefaultTransactionIsolation();
    295        } catch (final SQLException e) {
    296            handleException(e);
    297            return 0;
    298        }
    299    }
    300
    301    /**
    302     * Gets the underlying database meta data.
    303     *
    304     * @return The underlying database meta data.
    305     */
    306    public DatabaseMetaData getDelegate() {
    307        return databaseMetaData;
    308    }
    309
    310    @Override
    311    public int getDriverMajorVersion() {
    312        return databaseMetaData.getDriverMajorVersion();
    313    }
    314
    315    @Override
    316    public int getDriverMinorVersion() {
    317        return databaseMetaData.getDriverMinorVersion();
    318    }
    319
    320    @Override
    321    public String getDriverName() throws SQLException {
    322        try {
    323            return databaseMetaData.getDriverName();
    324        } catch (final SQLException e) {
    325            handleException(e);
    326            throw new AssertionError();
    327        }
    328    }
    329
    330    @Override
    331    public String getDriverVersion() throws SQLException {
    332        try {
    333            return databaseMetaData.getDriverVersion();
    334        } catch (final SQLException e) {
    335            handleException(e);
    336            throw new AssertionError();
    337        }
    338    }
    339
    340    @Override
    341    public ResultSet getExportedKeys(final String catalog, final String schema, final String table)
    342            throws SQLException {
    343        connection.checkOpen();
    344        try {
    345            return DelegatingResultSet.wrapResultSet(connection,
    346                    databaseMetaData.getExportedKeys(catalog, schema, table));
    347        } catch (final SQLException e) {
    348            handleException(e);
    349            throw new AssertionError();
    350        }
    351    }
    352
    353    @Override
    354    public String getExtraNameCharacters() throws SQLException {
    355        try {
    356            return databaseMetaData.getExtraNameCharacters();
    357        } catch (final SQLException e) {
    358            handleException(e);
    359            throw new AssertionError();
    360        }
    361    }
    362
    363    @Override
    364    public ResultSet getFunctionColumns(final String catalog, final String schemaPattern,
    365            final String functionNamePattern, final String columnNamePattern) throws SQLException {
    366        connection.checkOpen();
    367        try {
    368            return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getFunctionColumns(catalog,
    369                    schemaPattern, functionNamePattern, columnNamePattern));
    370        } catch (final SQLException e) {
    371            handleException(e);
    372            throw new AssertionError();
    373        }
    374    }
    375
    376    @Override
    377    public ResultSet getFunctions(final String catalog, final String schemaPattern, final String functionNamePattern)
    378            throws SQLException {
    379        connection.checkOpen();
    380        try {
    381            return DelegatingResultSet.wrapResultSet(connection,
    382                    databaseMetaData.getFunctions(catalog, schemaPattern, functionNamePattern));
    383        } catch (final SQLException e) {
    384            handleException(e);
    385            throw new AssertionError();
    386        }
    387    }
    388
    389    @Override
    390    public String getIdentifierQuoteString() throws SQLException {
    391        try {
    392            return databaseMetaData.getIdentifierQuoteString();
    393        } catch (final SQLException e) {
    394            handleException(e);
    395            throw new AssertionError();
    396        }
    397    }
    398
    399    @Override
    400    public ResultSet getImportedKeys(final String catalog, final String schema, final String table)
    401            throws SQLException {
    402        connection.checkOpen();
    403        try {
    404            return DelegatingResultSet.wrapResultSet(connection,
    405                    databaseMetaData.getImportedKeys(catalog, schema, table));
    406        } catch (final SQLException e) {
    407            handleException(e);
    408            throw new AssertionError();
    409        }
    410    }
    411
    412    @Override
    413    public ResultSet getIndexInfo(final String catalog, final String schema, final String table, final boolean unique,
    414            final boolean approximate) throws SQLException {
    415        connection.checkOpen();
    416        try {
    417            return DelegatingResultSet.wrapResultSet(connection,
    418                    databaseMetaData.getIndexInfo(catalog, schema, table, unique, approximate));
    419        } catch (final SQLException e) {
    420            handleException(e);
    421            throw new AssertionError();
    422        }
    423    }
    424
    425    /**
    426     * If my underlying {@link ResultSet} is not a {@code DelegatingResultSet}, returns it, otherwise recursively
    427     * invokes this method on my delegate.
    428     * <p>
    429     * Hence this method will return the first delegate that is not a {@code DelegatingResultSet}, or {@code null} when
    430     * no non-{@code DelegatingResultSet} delegate can be found by traversing this chain.
    431     * </p>
    432     * <p>
    433     * This method is useful when you may have nested {@code DelegatingResultSet}s, and you want to make sure to obtain
    434     * a "genuine" {@link ResultSet}.
    435     * </p>
    436     *
    437     * @return the innermost database meta data.
    438     */
    439    public DatabaseMetaData getInnermostDelegate() {
    440        DatabaseMetaData m = databaseMetaData;
    441        while (m instanceof DelegatingDatabaseMetaData) {
    442            m = ((DelegatingDatabaseMetaData) m).getDelegate();
    443            if (this == m) {
    444                return null;
    445            }
    446        }
    447        return m;
    448    }
    449
    450    @Override
    451    public int getJDBCMajorVersion() throws SQLException {
    452        try {
    453            return databaseMetaData.getJDBCMajorVersion();
    454        } catch (final SQLException e) {
    455            handleException(e);
    456            return 0;
    457        }
    458    }
    459
    460    @Override
    461    public int getJDBCMinorVersion() throws SQLException {
    462        try {
    463            return databaseMetaData.getJDBCMinorVersion();
    464        } catch (final SQLException e) {
    465            handleException(e);
    466            return 0;
    467        }
    468    }
    469
    470    @Override
    471    public int getMaxBinaryLiteralLength() throws SQLException {
    472        try {
    473            return databaseMetaData.getMaxBinaryLiteralLength();
    474        } catch (final SQLException e) {
    475            handleException(e);
    476            return 0;
    477        }
    478    }
    479
    480    @Override
    481    public int getMaxCatalogNameLength() throws SQLException {
    482        try {
    483            return databaseMetaData.getMaxCatalogNameLength();
    484        } catch (final SQLException e) {
    485            handleException(e);
    486            return 0;
    487        }
    488    }
    489
    490    @Override
    491    public int getMaxCharLiteralLength() throws SQLException {
    492        try {
    493            return databaseMetaData.getMaxCharLiteralLength();
    494        } catch (final SQLException e) {
    495            handleException(e);
    496            return 0;
    497        }
    498    }
    499
    500    @Override
    501    public int getMaxColumnNameLength() throws SQLException {
    502        try {
    503            return databaseMetaData.getMaxColumnNameLength();
    504        } catch (final SQLException e) {
    505            handleException(e);
    506            return 0;
    507        }
    508    }
    509
    510    @Override
    511    public int getMaxColumnsInGroupBy() throws SQLException {
    512        try {
    513            return databaseMetaData.getMaxColumnsInGroupBy();
    514        } catch (final SQLException e) {
    515            handleException(e);
    516            return 0;
    517        }
    518    }
    519
    520    @Override
    521    public int getMaxColumnsInIndex() throws SQLException {
    522        try {
    523            return databaseMetaData.getMaxColumnsInIndex();
    524        } catch (final SQLException e) {
    525            handleException(e);
    526            return 0;
    527        }
    528    }
    529
    530    @Override
    531    public int getMaxColumnsInOrderBy() throws SQLException {
    532        try {
    533            return databaseMetaData.getMaxColumnsInOrderBy();
    534        } catch (final SQLException e) {
    535            handleException(e);
    536            return 0;
    537        }
    538    }
    539
    540    @Override
    541    public int getMaxColumnsInSelect() throws SQLException {
    542        try {
    543            return databaseMetaData.getMaxColumnsInSelect();
    544        } catch (final SQLException e) {
    545            handleException(e);
    546            return 0;
    547        }
    548    }
    549
    550    @Override
    551    public int getMaxColumnsInTable() throws SQLException {
    552        try {
    553            return databaseMetaData.getMaxColumnsInTable();
    554        } catch (final SQLException e) {
    555            handleException(e);
    556            return 0;
    557        }
    558    }
    559
    560    @Override
    561    public int getMaxConnections() throws SQLException {
    562        try {
    563            return databaseMetaData.getMaxConnections();
    564        } catch (final SQLException e) {
    565            handleException(e);
    566            return 0;
    567        }
    568    }
    569
    570    @Override
    571    public int getMaxCursorNameLength() throws SQLException {
    572        try {
    573            return databaseMetaData.getMaxCursorNameLength();
    574        } catch (final SQLException e) {
    575            handleException(e);
    576            return 0;
    577        }
    578    }
    579
    580    @Override
    581    public int getMaxIndexLength() throws SQLException {
    582        try {
    583            return databaseMetaData.getMaxIndexLength();
    584        } catch (final SQLException e) {
    585            handleException(e);
    586            return 0;
    587        }
    588    }
    589
    590    /**
    591     * @since 2.5.0
    592     */
    593    @Override
    594    public long getMaxLogicalLobSize() throws SQLException {
    595        try {
    596            return databaseMetaData.getMaxLogicalLobSize();
    597        } catch (final SQLException e) {
    598            handleException(e);
    599            return 0;
    600        }
    601    }
    602
    603    @Override
    604    public int getMaxProcedureNameLength() throws SQLException {
    605        try {
    606            return databaseMetaData.getMaxProcedureNameLength();
    607        } catch (final SQLException e) {
    608            handleException(e);
    609            return 0;
    610        }
    611    }
    612
    613    @Override
    614    public int getMaxRowSize() throws SQLException {
    615        try {
    616            return databaseMetaData.getMaxRowSize();
    617        } catch (final SQLException e) {
    618            handleException(e);
    619            return 0;
    620        }
    621    }
    622
    623    @Override
    624    public int getMaxSchemaNameLength() throws SQLException {
    625        try {
    626            return databaseMetaData.getMaxSchemaNameLength();
    627        } catch (final SQLException e) {
    628            handleException(e);
    629            return 0;
    630        }
    631    }
    632
    633    @Override
    634    public int getMaxStatementLength() throws SQLException {
    635        try {
    636            return databaseMetaData.getMaxStatementLength();
    637        } catch (final SQLException e) {
    638            handleException(e);
    639            return 0;
    640        }
    641    }
    642
    643    @Override
    644    public int getMaxStatements() throws SQLException {
    645        try {
    646            return databaseMetaData.getMaxStatements();
    647        } catch (final SQLException e) {
    648            handleException(e);
    649            return 0;
    650        }
    651    }
    652
    653    @Override
    654    public int getMaxTableNameLength() throws SQLException {
    655        try {
    656            return databaseMetaData.getMaxTableNameLength();
    657        } catch (final SQLException e) {
    658            handleException(e);
    659            return 0;
    660        }
    661    }
    662
    663    @Override
    664    public int getMaxTablesInSelect() throws SQLException {
    665        try {
    666            return databaseMetaData.getMaxTablesInSelect();
    667        } catch (final SQLException e) {
    668            handleException(e);
    669            return 0;
    670        }
    671    }
    672
    673    @Override
    674    public int getMaxUserNameLength() throws SQLException {
    675        try {
    676            return databaseMetaData.getMaxUserNameLength();
    677        } catch (final SQLException e) {
    678            handleException(e);
    679            return 0;
    680        }
    681    }
    682
    683    @Override
    684    public String getNumericFunctions() throws SQLException {
    685        try {
    686            return databaseMetaData.getNumericFunctions();
    687        } catch (final SQLException e) {
    688            handleException(e);
    689            throw new AssertionError();
    690        }
    691    }
    692
    693    @Override
    694    public ResultSet getPrimaryKeys(final String catalog, final String schema, final String table) throws SQLException {
    695        connection.checkOpen();
    696        try {
    697            return DelegatingResultSet.wrapResultSet(connection,
    698                    databaseMetaData.getPrimaryKeys(catalog, schema, table));
    699        } catch (final SQLException e) {
    700            handleException(e);
    701            throw new AssertionError();
    702        }
    703    }
    704
    705    @Override
    706    public ResultSet getProcedureColumns(final String catalog, final String schemaPattern,
    707            final String procedureNamePattern, final String columnNamePattern) throws SQLException {
    708        connection.checkOpen();
    709        try {
    710            return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getProcedureColumns(catalog,
    711                    schemaPattern, procedureNamePattern, columnNamePattern));
    712        } catch (final SQLException e) {
    713            handleException(e);
    714            throw new AssertionError();
    715        }
    716    }
    717
    718    @Override
    719    public ResultSet getProcedures(final String catalog, final String schemaPattern, final String procedureNamePattern)
    720            throws SQLException {
    721        connection.checkOpen();
    722        try {
    723            return DelegatingResultSet.wrapResultSet(connection,
    724                    databaseMetaData.getProcedures(catalog, schemaPattern, procedureNamePattern));
    725        } catch (final SQLException e) {
    726            handleException(e);
    727            throw new AssertionError();
    728        }
    729    }
    730
    731    @Override
    732    public String getProcedureTerm() throws SQLException {
    733        try {
    734            return databaseMetaData.getProcedureTerm();
    735        } catch (final SQLException e) {
    736            handleException(e);
    737            throw new AssertionError();
    738        }
    739    }
    740
    741    @Override
    742    public ResultSet getPseudoColumns(final String catalog, final String schemaPattern, final String tableNamePattern,
    743            final String columnNamePattern) throws SQLException {
    744        connection.checkOpen();
    745        try {
    746            return DelegatingResultSet.wrapResultSet(connection, Jdbc41Bridge.getPseudoColumns(databaseMetaData,
    747                    catalog, schemaPattern, tableNamePattern, columnNamePattern));
    748        } catch (final SQLException e) {
    749            handleException(e);
    750            throw new AssertionError();
    751        }
    752    }
    753
    754    @Override
    755    public int getResultSetHoldability() throws SQLException {
    756        try {
    757            return databaseMetaData.getResultSetHoldability();
    758        } catch (final SQLException e) {
    759            handleException(e);
    760            return 0;
    761        }
    762    }
    763
    764    @Override
    765    public RowIdLifetime getRowIdLifetime() throws SQLException {
    766        try {
    767            return databaseMetaData.getRowIdLifetime();
    768        } catch (final SQLException e) {
    769            handleException(e);
    770            throw new AssertionError();
    771        }
    772    }
    773
    774    @Override
    775    public ResultSet getSchemas() throws SQLException {
    776        connection.checkOpen();
    777        try {
    778            return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getSchemas());
    779        } catch (final SQLException e) {
    780            handleException(e);
    781            throw new AssertionError();
    782        }
    783    }
    784
    785    @Override
    786    public ResultSet getSchemas(final String catalog, final String schemaPattern) throws SQLException {
    787        connection.checkOpen();
    788        try {
    789            return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getSchemas(catalog, schemaPattern));
    790        } catch (final SQLException e) {
    791            handleException(e);
    792            throw new AssertionError();
    793        }
    794    }
    795
    796    @Override
    797    public String getSchemaTerm() throws SQLException {
    798        try {
    799            return databaseMetaData.getSchemaTerm();
    800        } catch (final SQLException e) {
    801            handleException(e);
    802            throw new AssertionError();
    803        }
    804    }
    805
    806    @Override
    807    public String getSearchStringEscape() throws SQLException {
    808        try {
    809            return databaseMetaData.getSearchStringEscape();
    810        } catch (final SQLException e) {
    811            handleException(e);
    812            throw new AssertionError();
    813        }
    814    }
    815
    816    @Override
    817    public String getSQLKeywords() throws SQLException {
    818        try {
    819            return databaseMetaData.getSQLKeywords();
    820        } catch (final SQLException e) {
    821            handleException(e);
    822            throw new AssertionError();
    823        }
    824    }
    825
    826    @Override
    827    public int getSQLStateType() throws SQLException {
    828        try {
    829            return databaseMetaData.getSQLStateType();
    830        } catch (final SQLException e) {
    831            handleException(e);
    832            return 0;
    833        }
    834    }
    835
    836    @Override
    837    public String getStringFunctions() throws SQLException {
    838        try {
    839            return databaseMetaData.getStringFunctions();
    840        } catch (final SQLException e) {
    841            handleException(e);
    842            throw new AssertionError();
    843        }
    844    }
    845
    846    @Override
    847    public ResultSet getSuperTables(final String catalog, final String schemaPattern, final String tableNamePattern)
    848            throws SQLException {
    849        connection.checkOpen();
    850        try {
    851            return DelegatingResultSet.wrapResultSet(connection,
    852                    databaseMetaData.getSuperTables(catalog, schemaPattern, tableNamePattern));
    853        } catch (final SQLException e) {
    854            handleException(e);
    855            throw new AssertionError();
    856        }
    857    }
    858
    859    @Override
    860    public ResultSet getSuperTypes(final String catalog, final String schemaPattern, final String typeNamePattern)
    861            throws SQLException {
    862        connection.checkOpen();
    863        try {
    864            return DelegatingResultSet.wrapResultSet(connection,
    865                    databaseMetaData.getSuperTypes(catalog, schemaPattern, typeNamePattern));
    866        } catch (final SQLException e) {
    867            handleException(e);
    868            throw new AssertionError();
    869        }
    870    }
    871
    872    @Override
    873    public String getSystemFunctions() throws SQLException {
    874        try {
    875            return databaseMetaData.getSystemFunctions();
    876        } catch (final SQLException e) {
    877            handleException(e);
    878            throw new AssertionError();
    879        }
    880    }
    881
    882    @Override
    883    public ResultSet getTablePrivileges(final String catalog, final String schemaPattern, final String tableNamePattern)
    884            throws SQLException {
    885        connection.checkOpen();
    886        try {
    887            return DelegatingResultSet.wrapResultSet(connection,
    888                    databaseMetaData.getTablePrivileges(catalog, schemaPattern, tableNamePattern));
    889        } catch (final SQLException e) {
    890            handleException(e);
    891            throw new AssertionError();
    892        }
    893    }
    894
    895    @Override
    896    public ResultSet getTables(final String catalog, final String schemaPattern, final String tableNamePattern,
    897            final String[] types) throws SQLException {
    898        connection.checkOpen();
    899        try {
    900            return DelegatingResultSet.wrapResultSet(connection,
    901                    databaseMetaData.getTables(catalog, schemaPattern, tableNamePattern, types));
    902        } catch (final SQLException e) {
    903            handleException(e);
    904            throw new AssertionError();
    905        }
    906    }
    907
    908    @Override
    909    public ResultSet getTableTypes() throws SQLException {
    910        connection.checkOpen();
    911        try {
    912            return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getTableTypes());
    913        } catch (final SQLException e) {
    914            handleException(e);
    915            throw new AssertionError();
    916        }
    917    }
    918
    919    @Override
    920    public String getTimeDateFunctions() throws SQLException {
    921        try {
    922            return databaseMetaData.getTimeDateFunctions();
    923        } catch (final SQLException e) {
    924            handleException(e);
    925            throw new AssertionError();
    926        }
    927    }
    928
    929    @Override
    930    public ResultSet getTypeInfo() throws SQLException {
    931        connection.checkOpen();
    932        try {
    933            return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getTypeInfo());
    934        } catch (final SQLException e) {
    935            handleException(e);
    936            throw new AssertionError();
    937        }
    938    }
    939
    940    @Override
    941    public ResultSet getUDTs(final String catalog, final String schemaPattern, final String typeNamePattern,
    942            final int[] types) throws SQLException {
    943        connection.checkOpen();
    944        try {
    945            return DelegatingResultSet.wrapResultSet(connection,
    946                    databaseMetaData.getUDTs(catalog, schemaPattern, typeNamePattern, types));
    947        } catch (final SQLException e) {
    948            handleException(e);
    949            throw new AssertionError();
    950        }
    951    }
    952
    953    @Override
    954    public String getURL() throws SQLException {
    955        try {
    956            return databaseMetaData.getURL();
    957        } catch (final SQLException e) {
    958            handleException(e);
    959            throw new AssertionError();
    960        }
    961    }
    962
    963    @Override
    964    public String getUserName() throws SQLException {
    965        try {
    966            return databaseMetaData.getUserName();
    967        } catch (final SQLException e) {
    968            handleException(e);
    969            throw new AssertionError();
    970        }
    971    }
    972
    973    @Override
    974    public ResultSet getVersionColumns(final String catalog, final String schema, final String table)
    975            throws SQLException {
    976        connection.checkOpen();
    977        try {
    978            return DelegatingResultSet.wrapResultSet(connection,
    979                    databaseMetaData.getVersionColumns(catalog, schema, table));
    980        } catch (final SQLException e) {
    981            handleException(e);
    982            throw new AssertionError();
    983        }
    984    }
    985
    986    protected void handleException(final SQLException e) throws SQLException {
    987        if (connection == null) {
    988            throw e;
    989        }
    990        connection.handleException(e);
    991    }
    992
    993    @Override
    994    public boolean insertsAreDetected(final int type) throws SQLException {
    995        try {
    996            return databaseMetaData.insertsAreDetected(type);
    997        } catch (final SQLException e) {
    998            handleException(e);
    999            return false;
    1000        }
    1001    }
    1002
    1003    @Override
    1004    public boolean isCatalogAtStart() throws SQLException {
    1005        try {
    1006            return databaseMetaData.isCatalogAtStart();
    1007        } catch (final SQLException e) {
    1008            handleException(e);
    1009            return false;
    1010        }
    1011    }
    1012
    1013    @Override
    1014    public boolean isReadOnly() throws SQLException {
    1015        try {
    1016            return databaseMetaData.isReadOnly();
    1017        } catch (final SQLException e) {
    1018            handleException(e);
    1019            return false;
    1020        }
    1021    }
    1022
    1023    @Override
    1024    public boolean isWrapperFor(final Class<?> iface) throws SQLException {
    1025        if (iface.isAssignableFrom(getClass())) {
    1026            return true;
    1027        }
    1028        if (iface.isAssignableFrom(databaseMetaData.getClass())) {
    1029            return true;
    1030        }
    1031        return databaseMetaData.isWrapperFor(iface);
    1032    }
    1033
    1034    @Override
    1035    public boolean locatorsUpdateCopy() throws SQLException {
    1036        try {
    1037            return databaseMetaData.locatorsUpdateCopy();
    1038        } catch (final SQLException e) {
    1039            handleException(e);
    1040            return false;
    1041        }
    1042    }
    1043
    1044    @Override
    1045    public boolean nullPlusNonNullIsNull() throws SQLException {
    1046        try {
    1047            return databaseMetaData.nullPlusNonNullIsNull();
    1048        } catch (final SQLException e) {
    1049            handleException(e);
    1050            return false;
    1051        }
    1052    }
    1053
    1054    @Override
    1055    public boolean nullsAreSortedAtEnd() throws SQLException {
    1056        try {
    1057            return databaseMetaData.nullsAreSortedAtEnd();
    1058        } catch (final SQLException e) {
    1059            handleException(e);
    1060            return false;
    1061        }
    1062    }
    1063
    1064    @Override
    1065    public boolean nullsAreSortedAtStart() throws SQLException {
    1066        try {
    1067            return databaseMetaData.nullsAreSortedAtStart();
    1068        } catch (final SQLException e) {
    1069            handleException(e);
    1070            return false;
    1071        }
    1072    }
    1073
    1074    @Override
    1075    public boolean nullsAreSortedHigh() throws SQLException {
    1076        try {
    1077            return databaseMetaData.nullsAreSortedHigh();
    1078        } catch (final SQLException e) {
    1079            handleException(e);
    1080            return false;
    1081        }
    1082    }
    1083
    1084    @Override
    1085    public boolean nullsAreSortedLow() throws SQLException {
    1086        try {
    1087            return databaseMetaData.nullsAreSortedLow();
    1088        } catch (final SQLException e) {
    1089            handleException(e);
    1090            return false;
    1091        }
    1092    }
    1093
    1094    @Override
    1095    public boolean othersDeletesAreVisible(final int type) throws SQLException {
    1096        try {
    1097            return databaseMetaData.othersDeletesAreVisible(type);
    1098        } catch (final SQLException e) {
    1099            handleException(e);
    1100            return false;
    1101        }
    1102    }
    1103
    1104    @Override
    1105    public boolean othersInsertsAreVisible(final int type) throws SQLException {
    1106        try {
    1107            return databaseMetaData.othersInsertsAreVisible(type);
    1108        } catch (final SQLException e) {
    1109            handleException(e);
    1110            return false;
    1111        }
    1112    }
    1113
    1114    @Override
    1115    public boolean othersUpdatesAreVisible(final int type) throws SQLException {
    1116        try {
    1117            return databaseMetaData.othersUpdatesAreVisible(type);
    1118        } catch (final SQLException e) {
    1119            handleException(e);
    1120            return false;
    1121        }
    1122    }
    1123
    1124    @Override
    1125    public boolean ownDeletesAreVisible(final int type) throws SQLException {
    1126        try {
    1127            return databaseMetaData.ownDeletesAreVisible(type);
    1128        } catch (final SQLException e) {
    1129            handleException(e);
    1130            return false;
    1131        }
    1132    }
    1133
    1134    @Override
    1135    public boolean ownInsertsAreVisible(final int type) throws SQLException {
    1136        try {
    1137            return databaseMetaData.ownInsertsAreVisible(type);
    1138        } catch (final SQLException e) {
    1139            handleException(e);
    1140            return false;
    1141        }
    1142    }
    1143
    1144    @Override
    1145    public boolean ownUpdatesAreVisible(final int type) throws SQLException {
    1146        try {
    1147            return databaseMetaData.ownUpdatesAreVisible(type);
    1148        } catch (final SQLException e) {
    1149            handleException(e);
    1150            return false;
    1151        }
    1152    }
    1153
    1154    @Override
    1155    public boolean storesLowerCaseIdentifiers() throws SQLException {
    1156        try {
    1157            return databaseMetaData.storesLowerCaseIdentifiers();
    1158        } catch (final SQLException e) {
    1159            handleException(e);
    1160            return false;
    1161        }
    1162    }
    1163
    1164    @Override
    1165    public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
    1166        try {
    1167            return databaseMetaData.storesLowerCaseQuotedIdentifiers();
    1168        } catch (final SQLException e) {
    1169            handleException(e);
    1170            return false;
    1171        }
    1172    }
    1173
    1174    @Override
    1175    public boolean storesMixedCaseIdentifiers() throws SQLException {
    1176        try {
    1177            return databaseMetaData.storesMixedCaseIdentifiers();
    1178        } catch (final SQLException e) {
    1179            handleException(e);
    1180            return false;
    1181        }
    1182    }
    1183
    1184    @Override
    1185    public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
    1186        try {
    1187            return databaseMetaData.storesMixedCaseQuotedIdentifiers();
    1188        } catch (final SQLException e) {
    1189            handleException(e);
    1190            return false;
    1191        }
    1192    }
    1193
    1194    @Override
    1195    public boolean storesUpperCaseIdentifiers() throws SQLException {
    1196        try {
    1197            return databaseMetaData.storesUpperCaseIdentifiers();
    1198        } catch (final SQLException e) {
    1199            handleException(e);
    1200            return false;
    1201        }
    1202    }
    1203
    1204    @Override
    1205    public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
    1206        try {
    1207            return databaseMetaData.storesUpperCaseQuotedIdentifiers();
    1208        } catch (final SQLException e) {
    1209            handleException(e);
    1210            return false;
    1211        }
    1212    }
    1213
    1214    @Override
    1215    public boolean supportsAlterTableWithAddColumn() throws SQLException {
    1216        try {
    1217            return databaseMetaData.supportsAlterTableWithAddColumn();
    1218        } catch (final SQLException e) {
    1219            handleException(e);
    1220            return false;
    1221        }
    1222    }
    1223
    1224    @Override
    1225    public boolean supportsAlterTableWithDropColumn() throws SQLException {
    1226        try {
    1227            return databaseMetaData.supportsAlterTableWithDropColumn();
    1228        } catch (final SQLException e) {
    1229            handleException(e);
    1230            return false;
    1231        }
    1232    }
    1233
    1234    @Override
    1235    public boolean supportsANSI92EntryLevelSQL() throws SQLException {
    1236        try {
    1237            return databaseMetaData.supportsANSI92EntryLevelSQL();
    1238        } catch (final SQLException e) {
    1239            handleException(e);
    1240            return false;
    1241        }
    1242    }
    1243
    1244    @Override
    1245    public boolean supportsANSI92FullSQL() throws SQLException {
    1246        try {
    1247            return databaseMetaData.supportsANSI92FullSQL();
    1248        } catch (final SQLException e) {
    1249            handleException(e);
    1250            return false;
    1251        }
    1252    }
    1253
    1254    @Override
    1255    public boolean supportsANSI92IntermediateSQL() throws SQLException {
    1256        try {
    1257            return databaseMetaData.supportsANSI92IntermediateSQL();
    1258        } catch (final SQLException e) {
    1259            handleException(e);
    1260            return false;
    1261        }
    1262    }
    1263
    1264    @Override
    1265    public boolean supportsBatchUpdates() throws SQLException {
    1266        try {
    1267            return databaseMetaData.supportsBatchUpdates();
    1268        } catch (final SQLException e) {
    1269            handleException(e);
    1270            return false;
    1271        }
    1272    }
    1273
    1274    @Override
    1275    public boolean supportsCatalogsInDataManipulation() throws SQLException {
    1276        try {
    1277            return databaseMetaData.supportsCatalogsInDataManipulation();
    1278        } catch (final SQLException e) {
    1279            handleException(e);
    1280            return false;
    1281        }
    1282    }
    1283
    1284    @Override
    1285    public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
    1286        try {
    1287            return databaseMetaData.supportsCatalogsInIndexDefinitions();
    1288        } catch (final SQLException e) {
    1289            handleException(e);
    1290            return false;
    1291        }
    1292    }
    1293
    1294    @Override
    1295    public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
    1296        try {
    1297            return databaseMetaData.supportsCatalogsInPrivilegeDefinitions();
    1298        } catch (final SQLException e) {
    1299            handleException(e);
    1300            return false;
    1301        }
    1302    }
    1303
    1304    @Override
    1305    public boolean supportsCatalogsInProcedureCalls() throws SQLException {
    1306        try {
    1307            return databaseMetaData.supportsCatalogsInProcedureCalls();
    1308        } catch (final SQLException e) {
    1309            handleException(e);
    1310            return false;
    1311        }
    1312    }
    1313
    1314    @Override
    1315    public boolean supportsCatalogsInTableDefinitions() throws SQLException {
    1316        try {
    1317            return databaseMetaData.supportsCatalogsInTableDefinitions();
    1318        } catch (final SQLException e) {
    1319            handleException(e);
    1320            return false;
    1321        }
    1322    }
    1323
    1324    @Override
    1325    public boolean supportsColumnAliasing() throws SQLException {
    1326        try {
    1327            return databaseMetaData.supportsColumnAliasing();
    1328        } catch (final SQLException e) {
    1329            handleException(e);
    1330            return false;
    1331        }
    1332    }
    1333
    1334    @Override
    1335    public boolean supportsConvert() throws SQLException {
    1336        try {
    1337            return databaseMetaData.supportsConvert();
    1338        } catch (final SQLException e) {
    1339            handleException(e);
    1340            return false;
    1341        }
    1342    }
    1343
    1344    @Override
    1345    public boolean supportsConvert(final int fromType, final int toType) throws SQLException {
    1346        try {
    1347            return databaseMetaData.supportsConvert(fromType, toType);
    1348        } catch (final SQLException e) {
    1349            handleException(e);
    1350            return false;
    1351        }
    1352    }
    1353
    1354    @Override
    1355    public boolean supportsCoreSQLGrammar() throws SQLException {
    1356        try {
    1357            return databaseMetaData.supportsCoreSQLGrammar();
    1358        } catch (final SQLException e) {
    1359            handleException(e);
    1360            return false;
    1361        }
    1362    }
    1363
    1364    @Override
    1365    public boolean supportsCorrelatedSubqueries() throws SQLException {
    1366        try {
    1367            return databaseMetaData.supportsCorrelatedSubqueries();
    1368        } catch (final SQLException e) {
    1369            handleException(e);
    1370            return false;
    1371        }
    1372    }
    1373
    1374    @Override
    1375    public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
    1376        try {
    1377            return databaseMetaData.supportsDataDefinitionAndDataManipulationTransactions();
    1378        } catch (final SQLException e) {
    1379            handleException(e);
    1380            return false;
    1381        }
    1382    }
    1383
    1384    @Override
    1385    public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
    1386        try {
    1387            return databaseMetaData.supportsDataManipulationTransactionsOnly();
    1388        } catch (final SQLException e) {
    1389            handleException(e);
    1390            return false;
    1391        }
    1392    }
    1393
    1394    @Override
    1395    public boolean supportsDifferentTableCorrelationNames() throws SQLException {
    1396        try {
    1397            return databaseMetaData.supportsDifferentTableCorrelationNames();
    1398        } catch (final SQLException e) {
    1399            handleException(e);
    1400            return false;
    1401        }
    1402    }
    1403
    1404    @Override
    1405    public boolean supportsExpressionsInOrderBy() throws SQLException {
    1406        try {
    1407            return databaseMetaData.supportsExpressionsInOrderBy();
    1408        } catch (final SQLException e) {
    1409            handleException(e);
    1410            return false;
    1411        }
    1412    }
    1413
    1414    @Override
    1415    public boolean supportsExtendedSQLGrammar() throws SQLException {
    1416        try {
    1417            return databaseMetaData.supportsExtendedSQLGrammar();
    1418        } catch (final SQLException e) {
    1419            handleException(e);
    1420            return false;
    1421        }
    1422    }
    1423
    1424    @Override
    1425    public boolean supportsFullOuterJoins() throws SQLException {
    1426        try {
    1427            return databaseMetaData.supportsFullOuterJoins();
    1428        } catch (final SQLException e) {
    1429            handleException(e);
    1430            return false;
    1431        }
    1432    }
    1433
    1434    @Override
    1435    public boolean supportsGetGeneratedKeys() throws SQLException {
    1436        try {
    1437            return databaseMetaData.supportsGetGeneratedKeys();
    1438        } catch (final SQLException e) {
    1439            handleException(e);
    1440            return false;
    1441        }
    1442    }
    1443
    1444    @Override
    1445    public boolean supportsGroupBy() throws SQLException {
    1446        try {
    1447            return databaseMetaData.supportsGroupBy();
    1448        } catch (final SQLException e) {
    1449            handleException(e);
    1450            return false;
    1451        }
    1452    }
    1453
    1454    @Override
    1455    public boolean supportsGroupByBeyondSelect() throws SQLException {
    1456        try {
    1457            return databaseMetaData.supportsGroupByBeyondSelect();
    1458        } catch (final SQLException e) {
    1459            handleException(e);
    1460            return false;
    1461        }
    1462    }
    1463
    1464    @Override
    1465    public boolean supportsGroupByUnrelated() throws SQLException {
    1466        try {
    1467            return databaseMetaData.supportsGroupByUnrelated();
    1468        } catch (final SQLException e) {
    1469            handleException(e);
    1470            return false;
    1471        }
    1472    }
    1473
    1474    @Override
    1475    public boolean supportsIntegrityEnhancementFacility() throws SQLException {
    1476        try {
    1477            return databaseMetaData.supportsIntegrityEnhancementFacility();
    1478        } catch (final SQLException e) {
    1479            handleException(e);
    1480            return false;
    1481        }
    1482    }
    1483
    1484    @Override
    1485    public boolean supportsLikeEscapeClause() throws SQLException {
    1486        try {
    1487            return databaseMetaData.supportsLikeEscapeClause();
    1488        } catch (final SQLException e) {
    1489            handleException(e);
    1490            return false;
    1491        }
    1492    }
    1493
    1494    @Override
    1495    public boolean supportsLimitedOuterJoins() throws SQLException {
    1496        try {
    1497            return databaseMetaData.supportsLimitedOuterJoins();
    1498        } catch (final SQLException e) {
    1499            handleException(e);
    1500            return false;
    1501        }
    1502    }
    1503
    1504    @Override
    1505    public boolean supportsMinimumSQLGrammar() throws SQLException {
    1506        try {
    1507            return databaseMetaData.supportsMinimumSQLGrammar();
    1508        } catch (final SQLException e) {
    1509            handleException(e);
    1510            return false;
    1511        }
    1512    }
    1513
    1514    @Override
    1515    public boolean supportsMixedCaseIdentifiers() throws SQLException {
    1516        try {
    1517            return databaseMetaData.supportsMixedCaseIdentifiers();
    1518        } catch (final SQLException e) {
    1519            handleException(e);
    1520            return false;
    1521        }
    1522    }
    1523
    1524    @Override
    1525    public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
    1526        try {
    1527            return databaseMetaData.supportsMixedCaseQuotedIdentifiers();
    1528        } catch (final SQLException e) {
    1529            handleException(e);
    1530            return false;
    1531        }
    1532    }
    1533
    1534    @Override
    1535    public boolean supportsMultipleOpenResults() throws SQLException {
    1536        try {
    1537            return databaseMetaData.supportsMultipleOpenResults();
    1538        } catch (final SQLException e) {
    1539            handleException(e);
    1540            return false;
    1541        }
    1542    }
    1543
    1544    @Override
    1545    public boolean supportsMultipleResultSets() throws SQLException {
    1546        try {
    1547            return databaseMetaData.supportsMultipleResultSets();
    1548        } catch (final SQLException e) {
    1549            handleException(e);
    1550            return false;
    1551        }
    1552    }
    1553
    1554    @Override
    1555    public boolean supportsMultipleTransactions() throws SQLException {
    1556        try {
    1557            return databaseMetaData.supportsMultipleTransactions();
    1558        } catch (final SQLException e) {
    1559            handleException(e);
    1560            return false;
    1561        }
    1562    }
    1563
    1564    @Override
    1565    public boolean supportsNamedParameters() throws SQLException {
    1566        try {
    1567            return databaseMetaData.supportsNamedParameters();
    1568        } catch (final SQLException e) {
    1569            handleException(e);
    1570            return false;
    1571        }
    1572    }
    1573
    1574    @Override
    1575    public boolean supportsNonNullableColumns() throws SQLException {
    1576        try {
    1577            return databaseMetaData.supportsNonNullableColumns();
    1578        } catch (final SQLException e) {
    1579            handleException(e);
    1580            return false;
    1581        }
    1582    }
    1583
    1584    @Override
    1585    public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
    1586        try {
    1587            return databaseMetaData.supportsOpenCursorsAcrossCommit();
    1588        } catch (final SQLException e) {
    1589            handleException(e);
    1590            return false;
    1591        }
    1592    }
    1593
    1594    @Override
    1595    public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
    1596        try {
    1597            return databaseMetaData.supportsOpenCursorsAcrossRollback();
    1598        } catch (final SQLException e) {
    1599            handleException(e);
    1600            return false;
    1601        }
    1602    }
    1603
    1604    @Override
    1605    public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
    1606        try {
    1607            return databaseMetaData.supportsOpenStatementsAcrossCommit();
    1608        } catch (final SQLException e) {
    1609            handleException(e);
    1610            return false;
    1611        }
    1612    }
    1613
    1614    @Override
    1615    public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
    1616        try {
    1617            return databaseMetaData.supportsOpenStatementsAcrossRollback();
    1618        } catch (final SQLException e) {
    1619            handleException(e);
    1620            return false;
    1621        }
    1622    }
    1623
    1624    @Override
    1625    public boolean supportsOrderByUnrelated() throws SQLException {
    1626        try {
    1627            return databaseMetaData.supportsOrderByUnrelated();
    1628        } catch (final SQLException e) {
    1629            handleException(e);
    1630            return false;
    1631        }
    1632    }
    1633
    1634    @Override
    1635    public boolean supportsOuterJoins() throws SQLException {
    1636        try {
    1637            return databaseMetaData.supportsOuterJoins();
    1638        } catch (final SQLException e) {
    1639            handleException(e);
    1640            return false;
    1641        }
    1642    }
    1643
    1644    @Override
    1645    public boolean supportsPositionedDelete() throws SQLException {
    1646        try {
    1647            return databaseMetaData.supportsPositionedDelete();
    1648        } catch (final SQLException e) {
    1649            handleException(e);
    1650            return false;
    1651        }
    1652    }
    1653
    1654    @Override
    1655    public boolean supportsPositionedUpdate() throws SQLException {
    1656        try {
    1657            return databaseMetaData.supportsPositionedUpdate();
    1658        } catch (final SQLException e) {
    1659            handleException(e);
    1660            return false;
    1661        }
    1662    }
    1663
    1664    /**
    1665     * @since 2.5.0
    1666     */
    1667    @Override
    1668    public boolean supportsRefCursors() throws SQLException {
    1669        try {
    1670            return databaseMetaData.supportsRefCursors();
    1671        } catch (final SQLException e) {
    1672            handleException(e);
    1673            return false;
    1674        }
    1675    }
    1676
    1677    @Override
    1678    public boolean supportsResultSetConcurrency(final int type, final int concurrency) throws SQLException {
    1679        try {
    1680            return databaseMetaData.supportsResultSetConcurrency(type, concurrency);
    1681        } catch (final SQLException e) {
    1682            handleException(e);
    1683            return false;
    1684        }
    1685    }
    1686
    1687    @Override
    1688    public boolean supportsResultSetHoldability(final int holdability) throws SQLException {
    1689        try {
    1690            return databaseMetaData.supportsResultSetHoldability(holdability);
    1691        } catch (final SQLException e) {
    1692            handleException(e);
    1693            return false;
    1694        }
    1695    }
    1696
    1697    @Override
    1698    public boolean supportsResultSetType(final int type) throws SQLException {
    1699        try {
    1700            return databaseMetaData.supportsResultSetType(type);
    1701        } catch (final SQLException e) {
    1702            handleException(e);
    1703            return false;
    1704        }
    1705    }
    1706
    1707    @Override
    1708    public boolean supportsSavepoints() throws SQLException {
    1709        try {
    1710            return databaseMetaData.supportsSavepoints();
    1711        } catch (final SQLException e) {
    1712            handleException(e);
    1713            return false;
    1714        }
    1715    }
    1716
    1717    @Override
    1718    public boolean supportsSchemasInDataManipulation() throws SQLException {
    1719        try {
    1720            return databaseMetaData.supportsSchemasInDataManipulation();
    1721        } catch (final SQLException e) {
    1722            handleException(e);
    1723            return false;
    1724        }
    1725    }
    1726
    1727    @Override
    1728    public boolean supportsSchemasInIndexDefinitions() throws SQLException {
    1729        try {
    1730            return databaseMetaData.supportsSchemasInIndexDefinitions();
    1731        } catch (final SQLException e) {
    1732            handleException(e);
    1733            return false;
    1734        }
    1735    }
    1736
    1737    @Override
    1738    public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
    1739        try {
    1740            return databaseMetaData.supportsSchemasInPrivilegeDefinitions();
    1741        } catch (final SQLException e) {
    1742            handleException(e);
    1743            return false;
    1744        }
    1745    }
    1746
    1747    @Override
    1748    public boolean supportsSchemasInProcedureCalls() throws SQLException {
    1749        try {
    1750            return databaseMetaData.supportsSchemasInProcedureCalls();
    1751        } catch (final SQLException e) {
    1752            handleException(e);
    1753            return false;
    1754        }
    1755    }
    1756
    1757    @Override
    1758    public boolean supportsSchemasInTableDefinitions() throws SQLException {
    1759        try {
    1760            return databaseMetaData.supportsSchemasInTableDefinitions();
    1761        } catch (final SQLException e) {
    1762            handleException(e);
    1763            return false;
    1764        }
    1765    }
    1766
    1767    @Override
    1768    public boolean supportsSelectForUpdate() throws SQLException {
    1769        try {
    1770            return databaseMetaData.supportsSelectForUpdate();
    1771        } catch (final SQLException e) {
    1772            handleException(e);
    1773            return false;
    1774        }
    1775    }
    1776
    1777    @Override
    1778    public boolean supportsStatementPooling() throws SQLException {
    1779        try {
    1780            return databaseMetaData.supportsStatementPooling();
    1781        } catch (final SQLException e) {
    1782            handleException(e);
    1783            return false;
    1784        }
    1785    }
    1786
    1787    @Override
    1788    public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
    1789        try {
    1790            return databaseMetaData.supportsStoredFunctionsUsingCallSyntax();
    1791        } catch (final SQLException e) {
    1792            handleException(e);
    1793            return false;
    1794        }
    1795    }
    1796
    1797    @Override
    1798    public boolean supportsStoredProcedures() throws SQLException {
    1799        try {
    1800            return databaseMetaData.supportsStoredProcedures();
    1801        } catch (final SQLException e) {
    1802            handleException(e);
    1803            return false;
    1804        }
    1805    }
    1806
    1807    @Override
    1808    public boolean supportsSubqueriesInComparisons() throws SQLException {
    1809        try {
    1810            return databaseMetaData.supportsSubqueriesInComparisons();
    1811        } catch (final SQLException e) {
    1812            handleException(e);
    1813            return false;
    1814        }
    1815    }
    1816
    1817    @Override
    1818    public boolean supportsSubqueriesInExists() throws SQLException {
    1819        try {
    1820            return databaseMetaData.supportsSubqueriesInExists();
    1821        } catch (final SQLException e) {
    1822            handleException(e);
    1823            return false;
    1824        }
    1825    }
    1826
    1827    @Override
    1828    public boolean supportsSubqueriesInIns() throws SQLException {
    1829        try {
    1830            return databaseMetaData.supportsSubqueriesInIns();
    1831        } catch (final SQLException e) {
    1832            handleException(e);
    1833            return false;
    1834        }
    1835    }
    1836
    1837    @Override
    1838    public boolean supportsSubqueriesInQuantifieds() throws SQLException {
    1839        try {
    1840            return databaseMetaData.supportsSubqueriesInQuantifieds();
    1841        } catch (final SQLException e) {
    1842            handleException(e);
    1843            return false;
    1844        }
    1845    }
    1846
    1847    @Override
    1848    public boolean supportsTableCorrelationNames() throws SQLException {
    1849        try {
    1850            return databaseMetaData.supportsTableCorrelationNames();
    1851        } catch (final SQLException e) {
    1852            handleException(e);
    1853            return false;
    1854        }
    1855    }
    1856
    1857    @Override
    1858    public boolean supportsTransactionIsolationLevel(final int level) throws SQLException {
    1859        try {
    1860            return databaseMetaData.supportsTransactionIsolationLevel(level);
    1861        } catch (final SQLException e) {
    1862            handleException(e);
    1863            return false;
    1864        }
    1865    }
    1866
    1867    @Override
    1868    public boolean supportsTransactions() throws SQLException {
    1869        try {
    1870            return databaseMetaData.supportsTransactions();
    1871        } catch (final SQLException e) {
    1872            handleException(e);
    1873            return false;
    1874        }
    1875    }
    1876
    1877    @Override
    1878    public boolean supportsUnion() throws SQLException {
    1879        try {
    1880            return databaseMetaData.supportsUnion();
    1881        } catch (final SQLException e) {
    1882            handleException(e);
    1883            return false;
    1884        }
    1885    }
    1886
    1887    @Override
    1888    public boolean supportsUnionAll() throws SQLException {
    1889        try {
    1890            return databaseMetaData.supportsUnionAll();
    1891        } catch (final SQLException e) {
    1892            handleException(e);
    1893            return false;
    1894        }
    1895    }
    1896
    1897
    1898    @Override
    1899    public <T> T unwrap(final Class<T> iface) throws SQLException {
    1900        if (iface.isAssignableFrom(getClass())) {
    1901            return iface.cast(this);
    1902        }
    1903        if (iface.isAssignableFrom(databaseMetaData.getClass())) {
    1904            return iface.cast(databaseMetaData);
    1905        }
    1906        return databaseMetaData.unwrap(iface);
    1907    }
    1908
    1909    @Override
    1910    public boolean updatesAreDetected(final int type) throws SQLException {
    1911        try {
    1912            return databaseMetaData.updatesAreDetected(type);
    1913        } catch (final SQLException e) {
    1914            handleException(e);
    1915            return false;
    1916        }
    1917    }
    1918
    1919    @Override
    1920    public boolean usesLocalFilePerTable() throws SQLException {
    1921        try {
    1922            return databaseMetaData.usesLocalFilePerTable();
    1923        } catch (final SQLException e) {
    1924            handleException(e);
    1925            return false;
    1926        }
    1927    }
    1928
    1929    @Override
    1930    public boolean usesLocalFiles() throws SQLException {
    1931        try {
    1932            return databaseMetaData.usesLocalFiles();
    1933        } catch (final SQLException e) {
    1934            handleException(e);
    1935            return false;
    1936        }
    1937    }
    1938}