0001: /*
0002: * The contents of this file are subject to the Mozilla Public License
0003: * Version 1.1 (the "License"); you may not use this file except in
0004: * compliance with the License. You may obtain a copy of the License at
0005: * http://www.mozilla.org/MPL/
0006: *
0007: * Software distributed under the License is distributed on an "AS IS"
0008: * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
0009: * License for the specific language governing rights and limitations
0010: * under the License.
0011: *
0012: * The Original Code is iSQL-Viewer, A Mutli-Platform Database Tool.
0013: *
0014: * The Initial Developer of the Original Code is iSQL-Viewer, A Mutli-Platform Database Tool.
0015: * Portions created by Mark A. Kobold are Copyright (C) 2000-2007. All Rights Reserved.
0016: *
0017: * Contributor(s):
0018: * Mark A. Kobold [mkobold <at> isqlviewer <dot> com].
0019: *
0020: * If you didn't download this code from the following link, you should check
0021: * if you aren't using an obsolete version: http://www.isqlviewer.com
0022: */
0023: package org.isqlviewer.sql;
0024:
0025: import java.sql.Connection;
0026: import java.sql.DatabaseMetaData;
0027: import java.sql.ResultSet;
0028: import java.sql.SQLException;
0029:
0030: import org.isqlviewer.util.LocalMessages;
0031:
0032: /**
0033: * TODO Add DatabaseMetadataWrapper Overview JavaDoc.
0034: * <p>
0035: *
0036: * @author Mark A. Kobold <mkobold at isqlviewer dot com>
0037: * @version 1.0
0038: */
0039: class DatabaseMetadataWrapper implements DatabaseMetaData {
0040:
0041: static final String BUNDLE_NAME = "org.isqlviewer.sql.ResourceBundle";
0042: private static final LocalMessages messages = new LocalMessages(
0043: BUNDLE_NAME);
0044: private DatabaseMetaData metaData = null;
0045: private ConnectionWrapper connection = null;
0046:
0047: public DatabaseMetadataWrapper(ConnectionWrapper connection,
0048: DatabaseMetaData metaData) {
0049:
0050: this .connection = connection;
0051: this .metaData = metaData;
0052: }
0053:
0054: public boolean allProceduresAreCallable() throws SQLException {
0055:
0056: connection.updateLastAccess();
0057: try {
0058: return metaData.allProceduresAreCallable();
0059: } catch (SQLException sqle) {
0060: error(messages.format("DataSource.GeneralMethodError",
0061: "allProceduresAreCallable()"), sqle);
0062: throw sqle;
0063: } catch (Throwable t) {
0064: SQLException sqle = connection.createWrappedSQLException(t,
0065: "allProceduresAreCallable()");
0066: throw sqle;
0067: }
0068: }
0069:
0070: public boolean allTablesAreSelectable() throws SQLException {
0071:
0072: connection.updateLastAccess();
0073: try {
0074: return metaData.allTablesAreSelectable();
0075: } catch (SQLException sqle) {
0076: error(messages.format("DataSource.GeneralMethodError",
0077: "allTablesAreSelectable()"), sqle);
0078: throw sqle;
0079: } catch (Throwable t) {
0080: SQLException sqle = connection.createWrappedSQLException(t,
0081: "allTablesAreSelectable()");
0082: throw sqle;
0083: }
0084: }
0085:
0086: public boolean dataDefinitionCausesTransactionCommit()
0087: throws SQLException {
0088:
0089: connection.updateLastAccess();
0090: try {
0091: return metaData.dataDefinitionCausesTransactionCommit();
0092: } catch (SQLException sqle) {
0093: error(messages.format("DataSource.GeneralMethodError",
0094: "dataDefinitionCausesTransactionCommit()"), sqle);
0095: throw sqle;
0096: } catch (Throwable t) {
0097: SQLException sqle = connection.createWrappedSQLException(t,
0098: "dataDefinitionCausesTransactionCommit()");
0099: throw sqle;
0100: }
0101: }
0102:
0103: public boolean dataDefinitionIgnoredInTransactions()
0104: throws SQLException {
0105:
0106: connection.updateLastAccess();
0107: try {
0108: return metaData.dataDefinitionIgnoredInTransactions();
0109: } catch (SQLException sqle) {
0110: error(messages.format("DataSource.GeneralMethodError",
0111: "dataDefinitionIgnoredInTransactions()"), sqle);
0112: throw sqle;
0113: } catch (Throwable t) {
0114: SQLException sqle = connection.createWrappedSQLException(t,
0115: "dataDefinitionIgnoredInTransactions()");
0116: throw sqle;
0117: }
0118: }
0119:
0120: public boolean deletesAreDetected(int type) throws SQLException {
0121:
0122: connection.updateLastAccess();
0123: try {
0124: return metaData.deletesAreDetected(type);
0125: } catch (SQLException sqle) {
0126: error(messages.format("DataSource.GeneralMethodError",
0127: "deletesAreDetected(int)"), sqle);
0128: throw sqle;
0129: } catch (Throwable t) {
0130: SQLException sqle = connection.createWrappedSQLException(t,
0131: "deletesAreDetected(int)");
0132: throw sqle;
0133: }
0134: }
0135:
0136: public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
0137:
0138: connection.updateLastAccess();
0139: try {
0140: return metaData.doesMaxRowSizeIncludeBlobs();
0141: } catch (SQLException sqle) {
0142: error(messages.format("DataSource.GeneralMethodError",
0143: "doesMaxRowSizeIncludeBlobs()"), sqle);
0144: throw sqle;
0145: } catch (Throwable t) {
0146: SQLException sqle = connection.createWrappedSQLException(t,
0147: "doesMaxRowSizeIncludeBlobs()");
0148: throw sqle;
0149: }
0150: }
0151:
0152: public ResultSet getAttributes(String catalog,
0153: String schemaPattern, String typeNamePattern,
0154: String attributeNamePattern) throws SQLException {
0155:
0156: connection.updateLastAccess();
0157: try {
0158: ResultSet set = metaData.getAttributes(catalog,
0159: schemaPattern, typeNamePattern,
0160: attributeNamePattern);
0161: StatementWrapper statement = new StatementWrapper(
0162: connection, set.getStatement(), "");
0163: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0164: return wrs;
0165: } catch (SQLException sqle) {
0166: error(messages.format("DataSource.GeneralMethodError",
0167: "getAttributes(String,String,String,String)"), sqle);
0168: throw sqle;
0169: } catch (Throwable t) {
0170: SQLException sqle = connection.createWrappedSQLException(t,
0171: "getAttributes(String,String,String,String)");
0172: throw sqle;
0173: }
0174: }
0175:
0176: public ResultSet getBestRowIdentifier(String catalog,
0177: String schema, String table, int scope, boolean nullable)
0178: throws SQLException {
0179:
0180: connection.updateLastAccess();
0181: try {
0182: ResultSet set = metaData.getBestRowIdentifier(catalog,
0183: schema, table, scope, nullable);
0184: StatementWrapper statement = new StatementWrapper(
0185: connection, set.getStatement(), "");
0186: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0187: return wrs;
0188: } catch (SQLException sqle) {
0189: error(
0190: messages
0191: .format("DataSource.GeneralMethodError",
0192: "getBestRowIdentifier(String,String,String,int,boolean)"),
0193: sqle);
0194: throw sqle;
0195: } catch (Throwable t) {
0196: SQLException sqle = connection
0197: .createWrappedSQLException(t,
0198: "getBestRowIdentifier(String,String,String,int,boolean)");
0199: throw sqle;
0200: }
0201: }
0202:
0203: public ResultSet getCatalogs() throws SQLException {
0204:
0205: connection.updateLastAccess();
0206: try {
0207: ResultSet set = metaData.getCatalogs();
0208: StatementWrapper statement = new StatementWrapper(
0209: connection, set.getStatement(), "");
0210: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0211: return wrs;
0212: } catch (SQLException sqle) {
0213: error(messages.format("DataSource.GeneralMethodError",
0214: "getCatalogs()"), sqle);
0215: throw sqle;
0216: } catch (Throwable t) {
0217: SQLException sqle = connection.createWrappedSQLException(t,
0218: "getCatalogs()");
0219: throw sqle;
0220: }
0221: }
0222:
0223: public String getCatalogSeparator() throws SQLException {
0224:
0225: connection.updateLastAccess();
0226: try {
0227: return metaData.getCatalogSeparator();
0228: } catch (SQLException sqle) {
0229: error(messages.format("DataSource.GeneralMethodError",
0230: "getCatalogSeparator()"), sqle);
0231: throw sqle;
0232: } catch (Throwable t) {
0233: SQLException sqle = connection.createWrappedSQLException(t,
0234: "getCatalogSeparator()");
0235: throw sqle;
0236: }
0237: }
0238:
0239: public String getCatalogTerm() throws SQLException {
0240:
0241: connection.updateLastAccess();
0242: try {
0243: return metaData.getCatalogTerm();
0244: } catch (SQLException sqle) {
0245: error(messages.format("DataSource.GeneralMethodError",
0246: "getCatalogTerm()"), sqle);
0247: throw sqle;
0248: } catch (Throwable t) {
0249: SQLException sqle = connection.createWrappedSQLException(t,
0250: "getCatalogTerm()");
0251: throw sqle;
0252: }
0253: }
0254:
0255: public ResultSet getColumnPrivileges(String catalog, String schema,
0256: String table, String columnNamePattern) throws SQLException {
0257:
0258: connection.updateLastAccess();
0259: try {
0260: ResultSet set = metaData.getColumnPrivileges(catalog,
0261: schema, table, columnNamePattern);
0262: StatementWrapper statement = new StatementWrapper(
0263: connection, set.getStatement(), "");
0264: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0265: return wrs;
0266: } catch (SQLException sqle) {
0267: error(
0268: messages
0269: .format("DataSource.GeneralMethodError",
0270: "getColumnPrivileges(String,String,String,String)"),
0271: sqle);
0272: throw sqle;
0273: } catch (Throwable t) {
0274: SQLException sqle = connection.createWrappedSQLException(t,
0275: "getColumnPrivileges(String,String,String,String)");
0276: throw sqle;
0277: }
0278: }
0279:
0280: public ResultSet getColumns(String catalog, String schemaPattern,
0281: String tableNamePattern, String columnNamePattern)
0282: throws SQLException {
0283:
0284: connection.updateLastAccess();
0285: try {
0286: ResultSet set = metaData.getColumns(catalog, schemaPattern,
0287: tableNamePattern, columnNamePattern);
0288: StatementWrapper statement = new StatementWrapper(
0289: connection, set.getStatement(), "");
0290: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0291: return wrs;
0292: } catch (SQLException sqle) {
0293: error(messages.format("DataSource.GeneralMethodError",
0294: "getColumns(String,String,String,String)"), sqle);
0295: throw sqle;
0296: } catch (Throwable t) {
0297: SQLException sqle = connection.createWrappedSQLException(t,
0298: "getColumns(String,String,String,String)");
0299: throw sqle;
0300: }
0301: }
0302:
0303: public Connection getConnection() throws SQLException {
0304:
0305: connection.updateLastAccess();
0306: try {
0307: return connection;
0308: } catch (Throwable t) {
0309: SQLException sqle = connection.createWrappedSQLException(t,
0310: "getConnection()");
0311: throw sqle;
0312: }
0313: }
0314:
0315: public ResultSet getCrossReference(String primaryCatalog,
0316: String primarySchema, String primaryTable,
0317: String foreignCatalog, String foreignSchema,
0318: String foreignTable) throws SQLException {
0319:
0320: connection.updateLastAccess();
0321: try {
0322: ResultSet set = metaData.getCrossReference(primaryCatalog,
0323: primarySchema, primaryTable, foreignCatalog,
0324: foreignSchema, foreignTable);
0325: StatementWrapper statement = new StatementWrapper(
0326: connection, set.getStatement(), "");
0327: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0328: return wrs;
0329: } catch (SQLException sqle) {
0330: error(
0331: messages
0332: .format("DataSource.GeneralMethodError",
0333: "getCrossReference(String,String,String,String,String,String)"),
0334: sqle);
0335: throw sqle;
0336: } catch (Throwable t) {
0337: SQLException sqle = connection
0338: .createWrappedSQLException(t,
0339: "getCrossReference(String,String,String,String,String,String)");
0340: throw sqle;
0341: }
0342: }
0343:
0344: public int getDatabaseMajorVersion() throws SQLException {
0345:
0346: connection.updateLastAccess();
0347: try {
0348: return metaData.getDatabaseMajorVersion();
0349: } catch (SQLException sqle) {
0350: error(messages.format("DataSource.GeneralMethodError",
0351: "getDatabaseMajorVersion()"), sqle);
0352: throw sqle;
0353: } catch (Throwable t) {
0354: SQLException sqle = connection.createWrappedSQLException(t,
0355: "getDatabaseMajorVersion()");
0356: throw sqle;
0357: }
0358: }
0359:
0360: public int getDatabaseMinorVersion() throws SQLException {
0361:
0362: connection.updateLastAccess();
0363: try {
0364: return metaData.getDatabaseMinorVersion();
0365: } catch (SQLException sqle) {
0366: error(messages.format("DataSource.GeneralMethodError",
0367: "getDatabaseMinorVersion()"), sqle);
0368: throw sqle;
0369: } catch (Throwable t) {
0370: SQLException sqle = connection.createWrappedSQLException(t,
0371: "getDatabaseMinorVersion()");
0372: throw sqle;
0373: }
0374: }
0375:
0376: public String getDatabaseProductName() throws SQLException {
0377:
0378: connection.updateLastAccess();
0379: try {
0380: return metaData.getDatabaseProductName();
0381: } catch (SQLException sqle) {
0382: error(messages.format("DataSource.GeneralMethodError",
0383: "getDatabaseProductName()"), sqle);
0384: throw sqle;
0385: } catch (Throwable t) {
0386: SQLException sqle = connection.createWrappedSQLException(t,
0387: "getDatabaseProductName()");
0388: throw sqle;
0389: }
0390: }
0391:
0392: public String getDatabaseProductVersion() throws SQLException {
0393:
0394: connection.updateLastAccess();
0395: try {
0396: return metaData.getDatabaseProductVersion();
0397: } catch (SQLException sqle) {
0398: error(messages.format("DataSource.GeneralMethodError",
0399: "getDatabaseProductVersion()"), sqle);
0400: throw sqle;
0401: } catch (Throwable t) {
0402: SQLException sqle = connection.createWrappedSQLException(t,
0403: "getDatabaseProductVersion()");
0404: throw sqle;
0405: }
0406: }
0407:
0408: public int getDefaultTransactionIsolation() throws SQLException {
0409:
0410: connection.updateLastAccess();
0411: try {
0412: return metaData.getDefaultTransactionIsolation();
0413: } catch (SQLException sqle) {
0414: error(messages.format("DataSource.GeneralMethodError",
0415: "getDefaultTransactionIsolation()"), sqle);
0416: throw sqle;
0417: } catch (Throwable t) {
0418: SQLException sqle = connection.createWrappedSQLException(t,
0419: "getDefaultTransactionIsolation()");
0420: throw sqle;
0421: }
0422: }
0423:
0424: public int getDriverMajorVersion() {
0425:
0426: return metaData.getDriverMajorVersion();
0427: }
0428:
0429: public int getDriverMinorVersion() {
0430:
0431: return metaData.getDriverMinorVersion();
0432: }
0433:
0434: public String getDriverName() throws SQLException {
0435:
0436: connection.updateLastAccess();
0437: try {
0438: return metaData.getDriverName();
0439: } catch (SQLException sqle) {
0440: error(messages.format("DataSource.GeneralMethodError",
0441: "getDriverName()"), sqle);
0442: throw sqle;
0443: } catch (Throwable t) {
0444: SQLException sqle = connection.createWrappedSQLException(t,
0445: "getDriverName()");
0446: throw sqle;
0447: }
0448: }
0449:
0450: public String getDriverVersion() throws SQLException {
0451:
0452: connection.updateLastAccess();
0453: try {
0454: return metaData.getDriverVersion();
0455: } catch (SQLException sqle) {
0456: error(messages.format("DataSource.GeneralMethodError",
0457: "getDriverVersion()"), sqle);
0458: throw sqle;
0459: } catch (Throwable t) {
0460: SQLException sqle = connection.createWrappedSQLException(t,
0461: "getDriverVersion()");
0462: throw sqle;
0463: }
0464: }
0465:
0466: public ResultSet getExportedKeys(String catalog, String schema,
0467: String table) throws SQLException {
0468:
0469: connection.updateLastAccess();
0470: try {
0471: ResultSet set = metaData.getExportedKeys(catalog, schema,
0472: table);
0473: StatementWrapper statement = new StatementWrapper(
0474: connection, set.getStatement(), "");
0475: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0476: return wrs;
0477: } catch (SQLException sqle) {
0478: error(messages.format("DataSource.GeneralMethodError",
0479: "getExportedKeys(String,String,String)"), sqle);
0480: throw sqle;
0481: } catch (Throwable t) {
0482: SQLException sqle = connection.createWrappedSQLException(t,
0483: "getExportedKeys(String,String,String)");
0484: throw sqle;
0485: }
0486: }
0487:
0488: public String getExtraNameCharacters() throws SQLException {
0489:
0490: connection.updateLastAccess();
0491: try {
0492: return metaData.getExtraNameCharacters();
0493: } catch (SQLException sqle) {
0494: error(messages.format("DataSource.GeneralMethodError",
0495: "getExtraNameCharacters()"), sqle);
0496: throw sqle;
0497: } catch (Throwable t) {
0498: SQLException sqle = connection.createWrappedSQLException(t,
0499: "getExtraNameCharacters()");
0500: throw sqle;
0501: }
0502: }
0503:
0504: public String getIdentifierQuoteString() throws SQLException {
0505:
0506: connection.updateLastAccess();
0507: try {
0508: return metaData.getIdentifierQuoteString();
0509: } catch (SQLException sqle) {
0510: error(messages.format("DataSource.GeneralMethodError",
0511: "getIdentifierQuoteString()"), sqle);
0512: throw sqle;
0513: } catch (Throwable t) {
0514: SQLException sqle = connection.createWrappedSQLException(t,
0515: "getIdentifierQuoteString()");
0516: throw sqle;
0517: }
0518: }
0519:
0520: public ResultSet getImportedKeys(String catalog, String schema,
0521: String table) throws SQLException {
0522:
0523: connection.updateLastAccess();
0524: try {
0525: ResultSet set = metaData.getImportedKeys(catalog, schema,
0526: table);
0527: StatementWrapper statement = new StatementWrapper(
0528: connection, set.getStatement(), "");
0529: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0530: return wrs;
0531: } catch (SQLException sqle) {
0532: error(messages.format("DataSource.GeneralMethodError",
0533: "getImportedKeys(String,String,String)"), sqle);
0534: throw sqle;
0535: } catch (Throwable t) {
0536: SQLException sqle = connection.createWrappedSQLException(t,
0537: "getImportedKeys(String,String,String)");
0538: throw sqle;
0539: }
0540: }
0541:
0542: public ResultSet getIndexInfo(String catalog, String schema,
0543: String table, boolean unique, boolean approximate)
0544: throws SQLException {
0545:
0546: connection.updateLastAccess();
0547: try {
0548: ResultSet set = metaData.getIndexInfo(catalog, schema,
0549: table, unique, approximate);
0550: StatementWrapper statement = new StatementWrapper(
0551: connection, set.getStatement(), "");
0552: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0553: return wrs;
0554: } catch (SQLException sqle) {
0555: error(
0556: messages
0557: .format("DataSource.GeneralMethodError",
0558: "getIndexInfo(String,String,String,boolean,boolean)"),
0559: sqle);
0560: throw sqle;
0561: } catch (Throwable t) {
0562: SQLException sqle = connection
0563: .createWrappedSQLException(t,
0564: "getIndexInfo(String,String,String,boolean,boolean)");
0565: throw sqle;
0566: }
0567: }
0568:
0569: public int getJDBCMajorVersion() throws SQLException {
0570:
0571: connection.updateLastAccess();
0572: try {
0573: return metaData.getJDBCMajorVersion();
0574: } catch (SQLException sqle) {
0575: error(messages.format("DataSource.GeneralMethodError",
0576: "getJDBCMajorVersion()"), sqle);
0577: throw sqle;
0578: } catch (Throwable t) {
0579: SQLException sqle = connection.createWrappedSQLException(t,
0580: "getJDBCMajorVersion()");
0581: throw sqle;
0582: }
0583: }
0584:
0585: public int getJDBCMinorVersion() throws SQLException {
0586:
0587: connection.updateLastAccess();
0588: try {
0589: return metaData.getJDBCMinorVersion();
0590: } catch (SQLException sqle) {
0591: error(messages.format("DataSource.GeneralMethodError",
0592: "getJDBCMinorVersion()"), sqle);
0593: throw sqle;
0594: } catch (Throwable t) {
0595: SQLException sqle = connection.createWrappedSQLException(t,
0596: "getJDBCMinorVersion()");
0597: throw sqle;
0598: }
0599: }
0600:
0601: public int getMaxBinaryLiteralLength() throws SQLException {
0602:
0603: connection.updateLastAccess();
0604: try {
0605: return metaData.getMaxBinaryLiteralLength();
0606: } catch (SQLException sqle) {
0607: error(messages.format("DataSource.GeneralMethodError",
0608: "getMaxBinaryLiteralLength()"), sqle);
0609: throw sqle;
0610: } catch (Throwable t) {
0611: SQLException sqle = connection.createWrappedSQLException(t,
0612: "getMaxBinaryLiteralLength()");
0613: throw sqle;
0614: }
0615: }
0616:
0617: public int getMaxCatalogNameLength() throws SQLException {
0618:
0619: connection.updateLastAccess();
0620: try {
0621: return metaData.getMaxCatalogNameLength();
0622: } catch (SQLException sqle) {
0623: error(messages.format("DataSource.GeneralMethodError",
0624: "getMaxCatalogNameLength()"), sqle);
0625: throw sqle;
0626: } catch (Throwable t) {
0627: SQLException sqle = connection.createWrappedSQLException(t,
0628: "getMaxCatalogNameLength()");
0629: throw sqle;
0630: }
0631: }
0632:
0633: public int getMaxCharLiteralLength() throws SQLException {
0634:
0635: connection.updateLastAccess();
0636: try {
0637: return metaData.getMaxCharLiteralLength();
0638: } catch (SQLException sqle) {
0639: error(messages.format("DataSource.GeneralMethodError",
0640: "getMaxCharLiteralLength()"), sqle);
0641: throw sqle;
0642: } catch (Throwable t) {
0643: SQLException sqle = connection.createWrappedSQLException(t,
0644: "getMaxCharLiteralLength()");
0645: throw sqle;
0646: }
0647: }
0648:
0649: public int getMaxColumnNameLength() throws SQLException {
0650:
0651: connection.updateLastAccess();
0652: try {
0653: return metaData.getMaxColumnNameLength();
0654: } catch (SQLException sqle) {
0655: error(messages.format("DataSource.GeneralMethodError",
0656: "getMaxColumnNameLength()"), sqle);
0657: throw sqle;
0658: } catch (Throwable t) {
0659: SQLException sqle = connection.createWrappedSQLException(t,
0660: "getMaxColumnNameLength()");
0661: throw sqle;
0662: }
0663: }
0664:
0665: public int getMaxColumnsInGroupBy() throws SQLException {
0666:
0667: connection.updateLastAccess();
0668: try {
0669: return metaData.getMaxColumnsInGroupBy();
0670: } catch (SQLException sqle) {
0671: error(messages.format("DataSource.GeneralMethodError",
0672: "getMaxColumnsInGroupBy()"), sqle);
0673: throw sqle;
0674: } catch (Throwable t) {
0675: SQLException sqle = connection.createWrappedSQLException(t,
0676: "getMaxColumnsInGroupBy()");
0677: throw sqle;
0678: }
0679: }
0680:
0681: public int getMaxColumnsInIndex() throws SQLException {
0682:
0683: connection.updateLastAccess();
0684: try {
0685: return metaData.getMaxColumnsInIndex();
0686: } catch (SQLException sqle) {
0687: error(messages.format("DataSource.GeneralMethodError",
0688: "getMaxColumnsInIndex()"), sqle);
0689: throw sqle;
0690: } catch (Throwable t) {
0691: SQLException sqle = connection.createWrappedSQLException(t,
0692: "getMaxColumnsInIndex()");
0693: throw sqle;
0694: }
0695: }
0696:
0697: public int getMaxColumnsInOrderBy() throws SQLException {
0698:
0699: connection.updateLastAccess();
0700: try {
0701: return metaData.getMaxColumnsInOrderBy();
0702: } catch (SQLException sqle) {
0703: error(messages.format("DataSource.GeneralMethodError",
0704: "getMaxColumnsInOrderBy()"), sqle);
0705: throw sqle;
0706: } catch (Throwable t) {
0707: SQLException sqle = connection.createWrappedSQLException(t,
0708: "getMaxColumnsInOrderBy()");
0709: throw sqle;
0710: }
0711: }
0712:
0713: public int getMaxColumnsInSelect() throws SQLException {
0714:
0715: connection.updateLastAccess();
0716: try {
0717: return metaData.getMaxColumnsInSelect();
0718: } catch (SQLException sqle) {
0719: error(messages.format("DataSource.GeneralMethodError",
0720: "getMaxColumnsInSelect()"), sqle);
0721: throw sqle;
0722: } catch (Throwable t) {
0723: SQLException sqle = connection.createWrappedSQLException(t,
0724: "getMaxColumnsInSelect()");
0725: throw sqle;
0726: }
0727: }
0728:
0729: public int getMaxColumnsInTable() throws SQLException {
0730:
0731: connection.updateLastAccess();
0732: try {
0733: return metaData.getMaxColumnsInTable();
0734: } catch (SQLException sqle) {
0735: error(messages.format("DataSource.GeneralMethodError",
0736: "getMaxColumnsInTable()"), sqle);
0737: throw sqle;
0738: } catch (Throwable t) {
0739: SQLException sqle = connection.createWrappedSQLException(t,
0740: "getMaxColumnsInTable()");
0741: throw sqle;
0742: }
0743: }
0744:
0745: public int getMaxConnections() throws SQLException {
0746:
0747: connection.updateLastAccess();
0748: try {
0749: return metaData.getMaxConnections();
0750: } catch (SQLException sqle) {
0751: error(messages.format("DataSource.GeneralMethodError",
0752: "getMaxConnections()"), sqle);
0753: throw sqle;
0754: } catch (Throwable t) {
0755: SQLException sqle = connection.createWrappedSQLException(t,
0756: "getMaxConnections()");
0757: throw sqle;
0758: }
0759: }
0760:
0761: public int getMaxCursorNameLength() throws SQLException {
0762:
0763: connection.updateLastAccess();
0764: try {
0765: return metaData.getMaxCursorNameLength();
0766: } catch (SQLException sqle) {
0767: error(messages.format("DataSource.GeneralMethodError",
0768: "getMaxCursorNameLength()"), sqle);
0769: throw sqle;
0770: } catch (Throwable t) {
0771: SQLException sqle = connection.createWrappedSQLException(t,
0772: "getMaxCursorNameLength()");
0773: throw sqle;
0774: }
0775: }
0776:
0777: public int getMaxIndexLength() throws SQLException {
0778:
0779: connection.updateLastAccess();
0780: try {
0781: return metaData.getMaxIndexLength();
0782: } catch (SQLException sqle) {
0783: error(messages.format("DataSource.GeneralMethodError",
0784: "getProcedureTerm()"), sqle);
0785: throw sqle;
0786: } catch (Throwable t) {
0787: SQLException sqle = connection.createWrappedSQLException(t,
0788: "getProcedureTerm()");
0789: throw sqle;
0790: }
0791: }
0792:
0793: public int getMaxProcedureNameLength() throws SQLException {
0794:
0795: connection.updateLastAccess();
0796: try {
0797: return metaData.getMaxProcedureNameLength();
0798: } catch (SQLException sqle) {
0799: error(messages.format("DataSource.GeneralMethodError",
0800: "getMaxProcedureNameLength()"), sqle);
0801: throw sqle;
0802: } catch (Throwable t) {
0803: SQLException sqle = connection.createWrappedSQLException(t,
0804: "getMaxProcedureNameLength()");
0805: throw sqle;
0806: }
0807: }
0808:
0809: public int getMaxRowSize() throws SQLException {
0810:
0811: connection.updateLastAccess();
0812: try {
0813: return metaData.getMaxRowSize();
0814: } catch (SQLException sqle) {
0815: error(messages.format("DataSource.GeneralMethodError",
0816: "getMaxRowSize()"), sqle);
0817: throw sqle;
0818: } catch (Throwable t) {
0819: SQLException sqle = connection.createWrappedSQLException(t,
0820: "getMaxRowSize()");
0821: throw sqle;
0822: }
0823: }
0824:
0825: public int getMaxSchemaNameLength() throws SQLException {
0826:
0827: connection.updateLastAccess();
0828: try {
0829: return metaData.getMaxSchemaNameLength();
0830: } catch (SQLException sqle) {
0831: error(messages.format("DataSource.GeneralMethodError",
0832: "getMaxSchemaNameLength()"), sqle);
0833: throw sqle;
0834: } catch (Throwable t) {
0835: SQLException sqle = connection.createWrappedSQLException(t,
0836: "getMaxSchemaNameLength()");
0837: throw sqle;
0838: }
0839: }
0840:
0841: public int getMaxStatementLength() throws SQLException {
0842:
0843: connection.updateLastAccess();
0844: try {
0845: return metaData.getMaxStatementLength();
0846: } catch (SQLException sqle) {
0847: error(messages.format("DataSource.GeneralMethodError",
0848: "getMaxStatementLength()"), sqle);
0849: throw sqle;
0850: } catch (Throwable t) {
0851: SQLException sqle = connection.createWrappedSQLException(t,
0852: "getMaxStatementLength()");
0853: throw sqle;
0854: }
0855: }
0856:
0857: public int getMaxStatements() throws SQLException {
0858:
0859: connection.updateLastAccess();
0860: try {
0861: return metaData.getMaxStatements();
0862: } catch (SQLException sqle) {
0863: error(messages.format("DataSource.GeneralMethodError",
0864: "getMaxStatements()"), sqle);
0865: throw sqle;
0866: } catch (Throwable t) {
0867: SQLException sqle = connection.createWrappedSQLException(t,
0868: "getMaxStatements()");
0869: throw sqle;
0870: }
0871: }
0872:
0873: public int getMaxTableNameLength() throws SQLException {
0874:
0875: connection.updateLastAccess();
0876: try {
0877: return metaData.getMaxTableNameLength();
0878: } catch (SQLException sqle) {
0879: error(messages.format("DataSource.GeneralMethodError",
0880: "getMaxTableNameLength()"), sqle);
0881: throw sqle;
0882: } catch (Throwable t) {
0883: SQLException sqle = connection.createWrappedSQLException(t,
0884: "getMaxTableNameLength()");
0885: throw sqle;
0886: }
0887: }
0888:
0889: public int getMaxTablesInSelect() throws SQLException {
0890:
0891: connection.updateLastAccess();
0892: try {
0893: return metaData.getMaxTablesInSelect();
0894: } catch (SQLException sqle) {
0895: error(messages.format("DataSource.GeneralMethodError",
0896: "getMaxTablesInSelect()"), sqle);
0897: throw sqle;
0898: } catch (Throwable t) {
0899: SQLException sqle = connection.createWrappedSQLException(t,
0900: "getMaxTablesInSelect()");
0901: throw sqle;
0902: }
0903: }
0904:
0905: public int getMaxUserNameLength() throws SQLException {
0906:
0907: connection.updateLastAccess();
0908: try {
0909: return metaData.getMaxUserNameLength();
0910: } catch (SQLException sqle) {
0911: error(messages.format("DataSource.GeneralMethodError",
0912: "getMaxUserNameLength()"), sqle);
0913: throw sqle;
0914: } catch (Throwable t) {
0915: SQLException sqle = connection.createWrappedSQLException(t,
0916: "getMaxUserNameLength()");
0917: throw sqle;
0918: }
0919: }
0920:
0921: public String getNumericFunctions() throws SQLException {
0922:
0923: connection.updateLastAccess();
0924: try {
0925: return metaData.getNumericFunctions();
0926: } catch (SQLException sqle) {
0927: error(messages.format("DataSource.GeneralMethodError",
0928: "getNumericFunctions()"), sqle);
0929: throw sqle;
0930: } catch (Throwable t) {
0931: SQLException sqle = connection.createWrappedSQLException(t,
0932: "getNumericFunctions()");
0933: throw sqle;
0934: }
0935: }
0936:
0937: public ResultSet getPrimaryKeys(String catalog, String schema,
0938: String table) throws SQLException {
0939:
0940: connection.updateLastAccess();
0941: try {
0942: ResultSet set = metaData.getPrimaryKeys(catalog, schema,
0943: table);
0944: StatementWrapper statement = new StatementWrapper(
0945: connection, set.getStatement(), "");
0946: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0947: return wrs;
0948: } catch (SQLException sqle) {
0949: error(messages.format("DataSource.GeneralMethodError",
0950: "getPrimaryKeys(String,String,String)"), sqle);
0951: throw sqle;
0952: } catch (Throwable t) {
0953: SQLException sqle = connection.createWrappedSQLException(t,
0954: "getPrimaryKeys(String,String,String)");
0955: throw sqle;
0956: }
0957: }
0958:
0959: public ResultSet getProcedureColumns(String catalog,
0960: String schemaPattern, String procedureNamePattern,
0961: String columnNamePattern) throws SQLException {
0962:
0963: connection.updateLastAccess();
0964: try {
0965: ResultSet set = metaData.getProcedureColumns(catalog,
0966: schemaPattern, procedureNamePattern,
0967: columnNamePattern);
0968: StatementWrapper statement = new StatementWrapper(
0969: connection, set.getStatement(), "");
0970: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0971: return wrs;
0972: } catch (SQLException sqle) {
0973: error(
0974: messages
0975: .format("DataSource.GeneralMethodError",
0976: "getProcedureColumns(String,String,String,String)"),
0977: sqle);
0978: throw sqle;
0979: } catch (Throwable t) {
0980: SQLException sqle = connection.createWrappedSQLException(t,
0981: "getProcedureColumns(String,String,String,String)");
0982: throw sqle;
0983: }
0984: }
0985:
0986: public ResultSet getProcedures(String catalog,
0987: String schemaPattern, String procedureNamePattern)
0988: throws SQLException {
0989:
0990: connection.updateLastAccess();
0991: try {
0992: ResultSet set = metaData.getProcedures(catalog,
0993: schemaPattern, procedureNamePattern);
0994: StatementWrapper statement = new StatementWrapper(
0995: connection, set.getStatement(), "");
0996: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
0997: return wrs;
0998: } catch (SQLException sqle) {
0999: error(messages.format("DataSource.GeneralMethodError",
1000: "getProcedures(String,String,String)"), sqle);
1001: throw sqle;
1002: } catch (Throwable t) {
1003: SQLException sqle = connection.createWrappedSQLException(t,
1004: "getProcedures(String,String,String)");
1005: throw sqle;
1006: }
1007: }
1008:
1009: public String getProcedureTerm() throws SQLException {
1010:
1011: connection.updateLastAccess();
1012: try {
1013: return metaData.getProcedureTerm();
1014: } catch (SQLException sqle) {
1015: error(messages.format("DataSource.GeneralMethodError",
1016: "getProcedureTerm()"), sqle);
1017: throw sqle;
1018: } catch (Throwable t) {
1019: SQLException sqle = connection.createWrappedSQLException(t,
1020: "getProcedureTerm()");
1021: throw sqle;
1022: }
1023: }
1024:
1025: public int getResultSetHoldability() throws SQLException {
1026:
1027: connection.updateLastAccess();
1028: try {
1029: return metaData.getResultSetHoldability();
1030: } catch (SQLException sqle) {
1031: error(messages.format("DataSource.GeneralMethodError",
1032: "getResultSetHoldability()"), sqle);
1033: throw sqle;
1034: } catch (Throwable t) {
1035: SQLException sqle = connection.createWrappedSQLException(t,
1036: "getResultSetHoldability()");
1037: throw sqle;
1038: }
1039: }
1040:
1041: public ResultSet getSchemas() throws SQLException {
1042:
1043: connection.updateLastAccess();
1044: try {
1045: ResultSet set = metaData.getSchemas();
1046: StatementWrapper statement = new StatementWrapper(
1047: connection, set.getStatement(), "");
1048: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
1049: return wrs;
1050: } catch (SQLException sqle) {
1051: error(messages.format("DataSource.GeneralMethodError",
1052: "getSchemas()"), sqle);
1053: throw sqle;
1054: } catch (Throwable t) {
1055: SQLException sqle = connection.createWrappedSQLException(t,
1056: "getSchemas()");
1057: throw sqle;
1058: }
1059: }
1060:
1061: public String getSchemaTerm() throws SQLException {
1062:
1063: connection.updateLastAccess();
1064: try {
1065: return metaData.getSchemaTerm();
1066: } catch (SQLException sqle) {
1067: error(messages.format("DataSource.GeneralMethodError",
1068: "getSchemaTerm()"), sqle);
1069: throw sqle;
1070: } catch (Throwable t) {
1071: SQLException sqle = connection.createWrappedSQLException(t,
1072: "getSchemaTerm()");
1073: throw sqle;
1074: }
1075: }
1076:
1077: public String getSearchStringEscape() throws SQLException {
1078:
1079: connection.updateLastAccess();
1080: try {
1081: return metaData.getSearchStringEscape();
1082: } catch (SQLException sqle) {
1083: error(messages.format("DataSource.GeneralMethodError",
1084: "getSearchStringEscape()"), sqle);
1085: throw sqle;
1086: } catch (Throwable t) {
1087: SQLException sqle = connection.createWrappedSQLException(t,
1088: "getSearchStringEscape()");
1089: throw sqle;
1090: }
1091: }
1092:
1093: public String getSQLKeywords() throws SQLException {
1094:
1095: connection.updateLastAccess();
1096: try {
1097: return metaData.getSQLKeywords();
1098: } catch (SQLException sqle) {
1099: error(messages.format("DataSource.GeneralMethodError",
1100: "getSQLKeywords()"), sqle);
1101: throw sqle;
1102: } catch (Throwable t) {
1103: SQLException sqle = connection.createWrappedSQLException(t,
1104: "getSQLKeywords()");
1105: throw sqle;
1106: }
1107: }
1108:
1109: public int getSQLStateType() throws SQLException {
1110:
1111: connection.updateLastAccess();
1112: try {
1113: return metaData.getSQLStateType();
1114: } catch (SQLException sqle) {
1115: error(messages.format("DataSource.GeneralMethodError",
1116: "getSQLStateType()"), sqle);
1117: throw sqle;
1118: } catch (Throwable t) {
1119: SQLException sqle = connection.createWrappedSQLException(t,
1120: "getSQLStateType()");
1121: throw sqle;
1122: }
1123: }
1124:
1125: public String getStringFunctions() throws SQLException {
1126:
1127: connection.updateLastAccess();
1128: try {
1129: return metaData.getStringFunctions();
1130: } catch (SQLException sqle) {
1131: error(messages.format("DataSource.GeneralMethodError",
1132: "getStringFunctions()"), sqle);
1133: throw sqle;
1134: } catch (Throwable t) {
1135: SQLException sqle = connection.createWrappedSQLException(t,
1136: "getStringFunctions()");
1137: throw sqle;
1138: }
1139: }
1140:
1141: public ResultSet getSuperTables(String catalog,
1142: String schemaPattern, String tableNamePattern)
1143: throws SQLException {
1144:
1145: connection.updateLastAccess();
1146: try {
1147: ResultSet set = metaData.getSuperTables(catalog,
1148: schemaPattern, tableNamePattern);
1149: StatementWrapper statement = new StatementWrapper(
1150: connection, set.getStatement(), "");
1151: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
1152: return wrs;
1153: } catch (SQLException sqle) {
1154: error(messages.format("DataSource.GeneralMethodError",
1155: "getSuperTables(String,String,String)"), sqle);
1156: throw sqle;
1157: } catch (Throwable t) {
1158: SQLException sqle = connection.createWrappedSQLException(t,
1159: "getSuperTables(String,String,String)");
1160: throw sqle;
1161: }
1162: }
1163:
1164: public ResultSet getSuperTypes(String catalog,
1165: String schemaPattern, String typeNamePattern)
1166: throws SQLException {
1167:
1168: connection.updateLastAccess();
1169: try {
1170: ResultSet set = metaData.getSuperTypes(catalog,
1171: schemaPattern, typeNamePattern);
1172: StatementWrapper statement = new StatementWrapper(
1173: connection, set.getStatement(), "");
1174: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
1175: return wrs;
1176: } catch (SQLException sqle) {
1177: error(messages.format("DataSource.GeneralMethodError",
1178: "getSuperTypes(String,String,String)"), sqle);
1179: throw sqle;
1180: } catch (Throwable t) {
1181: SQLException sqle = connection.createWrappedSQLException(t,
1182: "getSuperTypes(String,String,String)");
1183: throw sqle;
1184: }
1185: }
1186:
1187: public String getSystemFunctions() throws SQLException {
1188:
1189: connection.updateLastAccess();
1190: try {
1191: return metaData.getSystemFunctions();
1192: } catch (SQLException sqle) {
1193: error(messages.format("DataSource.GeneralMethodError",
1194: "getSystemFunctions()"), sqle);
1195: throw sqle;
1196: } catch (Throwable t) {
1197: SQLException sqle = connection.createWrappedSQLException(t,
1198: "getSystemFunctions()");
1199: throw sqle;
1200: }
1201: }
1202:
1203: public ResultSet getTablePrivileges(String catalog,
1204: String schemaPattern, String tableNamePattern)
1205: throws SQLException {
1206:
1207: connection.updateLastAccess();
1208: try {
1209: ResultSet set = metaData.getTablePrivileges(catalog,
1210: schemaPattern, tableNamePattern);
1211: StatementWrapper statement = new StatementWrapper(
1212: connection, set.getStatement(), "");
1213: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
1214: return wrs;
1215: } catch (SQLException sqle) {
1216: error(messages.format("DataSource.GeneralMethodError",
1217: "getTablePrivileges(String,String,String)"), sqle);
1218: throw sqle;
1219: } catch (Throwable t) {
1220: SQLException sqle = connection.createWrappedSQLException(t,
1221: "getTablePrivileges(String,String,String)");
1222: throw sqle;
1223: }
1224: }
1225:
1226: public ResultSet getTables(String catalog, String schemaPattern,
1227: String tableNamePattern, String[] types)
1228: throws SQLException {
1229:
1230: connection.updateLastAccess();
1231: try {
1232: ResultSet set = metaData.getTables(catalog, schemaPattern,
1233: tableNamePattern, types);
1234: StatementWrapper statement = new StatementWrapper(
1235: connection, set.getStatement(), "");
1236: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
1237: return wrs;
1238: } catch (SQLException sqle) {
1239: error(messages.format("DataSource.GeneralMethodError",
1240: "getTables(String,String,String,String[])"), sqle);
1241: throw sqle;
1242: } catch (Throwable t) {
1243: SQLException sqle = connection.createWrappedSQLException(t,
1244: "getTables(String,String,String,String[])");
1245: throw sqle;
1246: }
1247: }
1248:
1249: public ResultSet getTableTypes() throws SQLException {
1250:
1251: connection.updateLastAccess();
1252: try {
1253: ResultSet set = metaData.getTableTypes();
1254: StatementWrapper statement = new StatementWrapper(
1255: connection, set.getStatement(), "");
1256: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
1257: return wrs;
1258: } catch (SQLException sqle) {
1259: error(messages.format("DataSource.GeneralMethodError",
1260: "getTableTypes()"), sqle);
1261: throw sqle;
1262: } catch (Throwable t) {
1263: SQLException sqle = connection.createWrappedSQLException(t,
1264: "getTableTypes()");
1265: throw sqle;
1266: }
1267: }
1268:
1269: public String getTimeDateFunctions() throws SQLException {
1270:
1271: connection.updateLastAccess();
1272: try {
1273: return metaData.getTimeDateFunctions();
1274: } catch (SQLException sqle) {
1275: error(messages.format("DataSource.GeneralMethodError",
1276: "getTimeDateFunctions()"), sqle);
1277: throw sqle;
1278: } catch (Throwable t) {
1279: SQLException sqle = connection.createWrappedSQLException(t,
1280: "getTimeDateFunctions()");
1281: throw sqle;
1282: }
1283: }
1284:
1285: public ResultSet getTypeInfo() throws SQLException {
1286:
1287: connection.updateLastAccess();
1288: try {
1289: ResultSet set = metaData.getTypeInfo();
1290: StatementWrapper statement = new StatementWrapper(
1291: connection, set.getStatement(), "");
1292: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
1293: return wrs;
1294: } catch (SQLException sqle) {
1295: error(messages.format("DataSource.GeneralMethodError",
1296: "getTypeInfo()"), sqle);
1297: throw sqle;
1298: } catch (Throwable t) {
1299: SQLException sqle = connection.createWrappedSQLException(t,
1300: "getTypeInfo()");
1301: throw sqle;
1302: }
1303: }
1304:
1305: public ResultSet getUDTs(String catalog, String schemaPattern,
1306: String typeNamePattern, int[] types) throws SQLException {
1307:
1308: connection.updateLastAccess();
1309: try {
1310: ResultSet set = metaData.getUDTs(catalog, schemaPattern,
1311: typeNamePattern, types);
1312: StatementWrapper statement = new StatementWrapper(
1313: connection, set.getStatement(), "");
1314: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
1315: return wrs;
1316: } catch (SQLException sqle) {
1317: error(messages.format("DataSource.GeneralMethodError",
1318: "getUDTs(Strin,String,String,int[])"), sqle);
1319: throw sqle;
1320: } catch (Throwable t) {
1321: SQLException sqle = connection.createWrappedSQLException(t,
1322: "getUDTs(Strin,String,String,int[])");
1323: throw sqle;
1324: }
1325: }
1326:
1327: public String getURL() throws SQLException {
1328:
1329: connection.updateLastAccess();
1330: try {
1331: return metaData.getURL();
1332: } catch (SQLException sqle) {
1333: error(messages.format("DataSource.GeneralMethodError",
1334: "getURL()"), sqle);
1335: throw sqle;
1336: } catch (Throwable t) {
1337: SQLException sqle = connection.createWrappedSQLException(t,
1338: "getURL()");
1339: throw sqle;
1340: }
1341: }
1342:
1343: public String getUserName() throws SQLException {
1344:
1345: connection.updateLastAccess();
1346: try {
1347: return metaData.getUserName();
1348: } catch (SQLException sqle) {
1349: error(messages.format("DataSource.GeneralMethodError",
1350: "getUserName()"), sqle);
1351: throw sqle;
1352: } catch (Throwable t) {
1353: SQLException sqle = connection.createWrappedSQLException(t,
1354: "getUserName()");
1355: throw sqle;
1356: }
1357: }
1358:
1359: public ResultSet getVersionColumns(String catalog, String schema,
1360: String table) throws SQLException {
1361:
1362: connection.updateLastAccess();
1363: try {
1364: ResultSet set = metaData.getVersionColumns(catalog, schema,
1365: table);
1366: StatementWrapper statement = new StatementWrapper(
1367: connection, set.getStatement(), "");
1368: ResultSetWrapper wrs = new ResultSetWrapper(statement, set);
1369: return wrs;
1370: } catch (SQLException sqle) {
1371: error(messages.format("DataSource.GeneralMethodError",
1372: "getVersionColumns(String,String,String)"), sqle);
1373: throw sqle;
1374: } catch (Throwable t) {
1375: SQLException sqle = connection.createWrappedSQLException(t,
1376: "getVersionColumns(String,String,String)");
1377: throw sqle;
1378: }
1379: }
1380:
1381: public boolean insertsAreDetected(int type) throws SQLException {
1382:
1383: connection.updateLastAccess();
1384: try {
1385: return metaData.insertsAreDetected(type);
1386: } catch (SQLException sqle) {
1387: error(messages.format("DataSource.GeneralMethodError",
1388: "insertsAreDetected(int)"), sqle);
1389: throw sqle;
1390: } catch (Throwable t) {
1391: SQLException sqle = connection.createWrappedSQLException(t,
1392: "insertsAreDetected(int)");
1393: throw sqle;
1394: }
1395: }
1396:
1397: public boolean isCatalogAtStart() throws SQLException {
1398:
1399: connection.updateLastAccess();
1400: try {
1401: return metaData.isCatalogAtStart();
1402: } catch (SQLException sqle) {
1403: error(messages.format("DataSource.GeneralMethodError",
1404: "isCatalogAtStart()"), sqle);
1405: throw sqle;
1406: } catch (Throwable t) {
1407: SQLException sqle = connection.createWrappedSQLException(t,
1408: "isCatalogAtStart()");
1409: throw sqle;
1410: }
1411: }
1412:
1413: public boolean isReadOnly() throws SQLException {
1414:
1415: connection.updateLastAccess();
1416: try {
1417: return metaData.isReadOnly();
1418: } catch (SQLException sqle) {
1419: error(messages.format("DataSource.GeneralMethodError",
1420: "isReadOnly()"), sqle);
1421: throw sqle;
1422: } catch (Throwable t) {
1423: SQLException sqle = connection.createWrappedSQLException(t,
1424: "isReadOnly()");
1425: throw sqle;
1426: }
1427: }
1428:
1429: public boolean locatorsUpdateCopy() throws SQLException {
1430:
1431: connection.updateLastAccess();
1432: try {
1433: return metaData.locatorsUpdateCopy();
1434: } catch (SQLException sqle) {
1435: error(messages.format("DataSource.GeneralMethodError",
1436: "locatorsUpdateCopy()"), sqle);
1437: throw sqle;
1438: } catch (Throwable t) {
1439: SQLException sqle = connection.createWrappedSQLException(t,
1440: "locatorsUpdateCopy()");
1441: throw sqle;
1442: }
1443: }
1444:
1445: public boolean nullPlusNonNullIsNull() throws SQLException {
1446:
1447: connection.updateLastAccess();
1448: try {
1449: return metaData.nullPlusNonNullIsNull();
1450: } catch (SQLException sqle) {
1451: error(messages.format("DataSource.GeneralMethodError",
1452: "nullPlusNonNullIsNull()"), sqle);
1453: throw sqle;
1454: } catch (Throwable t) {
1455: SQLException sqle = connection.createWrappedSQLException(t,
1456: "nullPlusNonNullIsNull()");
1457: throw sqle;
1458: }
1459: }
1460:
1461: public boolean nullsAreSortedAtEnd() throws SQLException {
1462:
1463: connection.updateLastAccess();
1464: try {
1465: return metaData.nullsAreSortedAtEnd();
1466: } catch (SQLException sqle) {
1467: error(messages.format("DataSource.GeneralMethodError",
1468: "nullsAreSortedAtEnd()"), sqle);
1469: throw sqle;
1470: } catch (Throwable t) {
1471: SQLException sqle = connection.createWrappedSQLException(t,
1472: "nullsAreSortedAtEnd()");
1473: throw sqle;
1474: }
1475: }
1476:
1477: public boolean nullsAreSortedAtStart() throws SQLException {
1478:
1479: connection.updateLastAccess();
1480: try {
1481: return metaData.nullsAreSortedAtStart();
1482: } catch (SQLException sqle) {
1483: error(messages.format("DataSource.GeneralMethodError",
1484: "nullsAreSortedAtStart()"), sqle);
1485: throw sqle;
1486: } catch (Throwable t) {
1487: SQLException sqle = connection.createWrappedSQLException(t,
1488: "nullsAreSortedAtStart()");
1489: throw sqle;
1490: }
1491: }
1492:
1493: public boolean nullsAreSortedHigh() throws SQLException {
1494:
1495: connection.updateLastAccess();
1496: try {
1497: return metaData.nullsAreSortedHigh();
1498: } catch (SQLException sqle) {
1499: error(messages.format("DataSource.GeneralMethodError",
1500: "nullsAreSortedHigh()"), sqle);
1501: throw sqle;
1502: } catch (Throwable t) {
1503: SQLException sqle = connection.createWrappedSQLException(t,
1504: "nullsAreSortedHigh()");
1505: throw sqle;
1506: }
1507: }
1508:
1509: public boolean nullsAreSortedLow() throws SQLException {
1510:
1511: connection.updateLastAccess();
1512: try {
1513: return metaData.nullsAreSortedLow();
1514: } catch (SQLException sqle) {
1515: error(messages.format("DataSource.GeneralMethodError",
1516: "nullsAreSortedLow()"), sqle);
1517: throw sqle;
1518: } catch (Throwable t) {
1519: SQLException sqle = connection.createWrappedSQLException(t,
1520: "nullsAreSortedLow()");
1521: throw sqle;
1522: }
1523: }
1524:
1525: public boolean othersDeletesAreVisible(int type)
1526: throws SQLException {
1527:
1528: connection.updateLastAccess();
1529: try {
1530: return metaData.othersDeletesAreVisible(type);
1531: } catch (SQLException sqle) {
1532: error(messages.format("DataSource.GeneralMethodError",
1533: "othersDeletesAreVisible(int)"), sqle);
1534: throw sqle;
1535: } catch (Throwable t) {
1536: SQLException sqle = connection.createWrappedSQLException(t,
1537: "othersDeletesAreVisible(int)");
1538: throw sqle;
1539: }
1540: }
1541:
1542: public boolean othersInsertsAreVisible(int type)
1543: throws SQLException {
1544:
1545: connection.updateLastAccess();
1546: try {
1547: return metaData.othersInsertsAreVisible(type);
1548: } catch (SQLException sqle) {
1549: error(messages.format("DataSource.GeneralMethodError",
1550: "othersInsertsAreVisible(int)"), sqle);
1551: throw sqle;
1552: } catch (Throwable t) {
1553: SQLException sqle = connection.createWrappedSQLException(t,
1554: "othersInsertsAreVisible(int)");
1555: throw sqle;
1556: }
1557: }
1558:
1559: public boolean othersUpdatesAreVisible(int type)
1560: throws SQLException {
1561:
1562: connection.updateLastAccess();
1563: try {
1564: return metaData.othersUpdatesAreVisible(type);
1565: } catch (SQLException sqle) {
1566: error(messages.format("DataSource.GeneralMethodError",
1567: "othersUpdatesAreVisible(int)"), sqle);
1568: throw sqle;
1569: } catch (Throwable t) {
1570: SQLException sqle = connection.createWrappedSQLException(t,
1571: "othersUpdatesAreVisible(int)");
1572: throw sqle;
1573: }
1574: }
1575:
1576: public boolean ownDeletesAreVisible(int type) throws SQLException {
1577:
1578: connection.updateLastAccess();
1579: try {
1580: return metaData.ownDeletesAreVisible(type);
1581: } catch (SQLException sqle) {
1582: error(messages.format("DataSource.GeneralMethodError",
1583: "ownDeletesAreVisible(int)"), sqle);
1584: throw sqle;
1585: } catch (Throwable t) {
1586: SQLException sqle = connection.createWrappedSQLException(t,
1587: "ownDeletesAreVisible(int)");
1588: throw sqle;
1589: }
1590: }
1591:
1592: public boolean ownInsertsAreVisible(int type) throws SQLException {
1593:
1594: connection.updateLastAccess();
1595: try {
1596: return metaData.ownInsertsAreVisible(type);
1597: } catch (SQLException sqle) {
1598: error(messages.format("DataSource.GeneralMethodError",
1599: "ownInsertsAreVisible(int)"), sqle);
1600: throw sqle;
1601: } catch (Throwable t) {
1602: SQLException sqle = connection.createWrappedSQLException(t,
1603: "ownInsertsAreVisible(int)");
1604: throw sqle;
1605: }
1606: }
1607:
1608: public boolean ownUpdatesAreVisible(int type) throws SQLException {
1609:
1610: connection.updateLastAccess();
1611: try {
1612: return metaData.ownUpdatesAreVisible(type);
1613: } catch (SQLException sqle) {
1614: error(messages.format("DataSource.GeneralMethodError",
1615: "ownUpdatesAreVisible(int)"), sqle);
1616: throw sqle;
1617: } catch (Throwable t) {
1618: SQLException sqle = connection.createWrappedSQLException(t,
1619: "ownUpdatesAreVisible(int)");
1620: throw sqle;
1621: }
1622: }
1623:
1624: public boolean storesLowerCaseIdentifiers() throws SQLException {
1625:
1626: connection.updateLastAccess();
1627: try {
1628: return metaData.storesLowerCaseIdentifiers();
1629: } catch (SQLException sqle) {
1630: error(messages.format("DataSource.GeneralMethodError",
1631: "storesLowerCaseIdentifiers()"), sqle);
1632: throw sqle;
1633: } catch (Throwable t) {
1634: SQLException sqle = connection.createWrappedSQLException(t,
1635: "storesLowerCaseIdentifiers()");
1636: throw sqle;
1637: }
1638: }
1639:
1640: public boolean storesLowerCaseQuotedIdentifiers()
1641: throws SQLException {
1642:
1643: connection.updateLastAccess();
1644: try {
1645: return metaData.storesLowerCaseQuotedIdentifiers();
1646: } catch (SQLException sqle) {
1647: error(messages.format("DataSource.GeneralMethodError",
1648: "storesLowerCaseQuotedIdentifiers()"), sqle);
1649: throw sqle;
1650: } catch (Throwable t) {
1651: SQLException sqle = connection.createWrappedSQLException(t,
1652: "storesLowerCaseQuotedIdentifiers()");
1653: throw sqle;
1654: }
1655: }
1656:
1657: public boolean storesMixedCaseIdentifiers() throws SQLException {
1658:
1659: connection.updateLastAccess();
1660: try {
1661: return metaData.storesMixedCaseIdentifiers();
1662: } catch (SQLException sqle) {
1663: error(messages.format("DataSource.GeneralMethodError",
1664: "storesMixedCaseIdentifiers()"), sqle);
1665: throw sqle;
1666: } catch (Throwable t) {
1667: SQLException sqle = connection.createWrappedSQLException(t,
1668: "storesMixedCaseIdentifiers()");
1669: throw sqle;
1670: }
1671: }
1672:
1673: public boolean storesMixedCaseQuotedIdentifiers()
1674: throws SQLException {
1675:
1676: connection.updateLastAccess();
1677: try {
1678: return metaData.storesMixedCaseQuotedIdentifiers();
1679: } catch (SQLException sqle) {
1680: error(messages.format("DataSource.GeneralMethodError",
1681: "storesMixedCaseQuotedIdentifiers()"), sqle);
1682: throw sqle;
1683: } catch (Throwable t) {
1684: SQLException sqle = connection.createWrappedSQLException(t,
1685: "storesMixedCaseQuotedIdentifiers()");
1686: throw sqle;
1687: }
1688: }
1689:
1690: public boolean storesUpperCaseIdentifiers() throws SQLException {
1691:
1692: connection.updateLastAccess();
1693: try {
1694: return metaData.storesUpperCaseIdentifiers();
1695: } catch (SQLException sqle) {
1696: error(messages.format("DataSource.GeneralMethodError",
1697: "storesUpperCaseIdentifiers()"), sqle);
1698: throw sqle;
1699: } catch (Throwable t) {
1700: SQLException sqle = connection.createWrappedSQLException(t,
1701: "storesUpperCaseIdentifiers()");
1702: throw sqle;
1703: }
1704: }
1705:
1706: public boolean storesUpperCaseQuotedIdentifiers()
1707: throws SQLException {
1708:
1709: connection.updateLastAccess();
1710: try {
1711: return metaData.storesUpperCaseQuotedIdentifiers();
1712: } catch (SQLException sqle) {
1713: error(messages.format("DataSource.GeneralMethodError",
1714: "storesUpperCaseQuotedIdentifiers()"), sqle);
1715: throw sqle;
1716: } catch (Throwable t) {
1717: SQLException sqle = connection.createWrappedSQLException(t,
1718: "storesUpperCaseQuotedIdentifiers()");
1719: throw sqle;
1720: }
1721: }
1722:
1723: public boolean supportsAlterTableWithAddColumn()
1724: throws SQLException {
1725:
1726: connection.updateLastAccess();
1727: try {
1728: return metaData.supportsAlterTableWithAddColumn();
1729: } catch (SQLException sqle) {
1730: error(messages.format("DataSource.GeneralMethodError",
1731: "supportsAlterTableWithAddColumn()"), sqle);
1732: throw sqle;
1733: } catch (Throwable t) {
1734: SQLException sqle = connection.createWrappedSQLException(t,
1735: "supportsAlterTableWithAddColumn()");
1736: throw sqle;
1737: }
1738: }
1739:
1740: public boolean supportsAlterTableWithDropColumn()
1741: throws SQLException {
1742:
1743: connection.updateLastAccess();
1744: try {
1745: return metaData.supportsAlterTableWithDropColumn();
1746: } catch (SQLException sqle) {
1747: error(messages.format("DataSource.GeneralMethodError",
1748: "supportsAlterTableWithDropColumn()"), sqle);
1749: throw sqle;
1750: } catch (Throwable t) {
1751: SQLException sqle = connection.createWrappedSQLException(t,
1752: "supportsAlterTableWithDropColumn()");
1753: throw sqle;
1754: }
1755: }
1756:
1757: public boolean supportsANSI92EntryLevelSQL() throws SQLException {
1758:
1759: connection.updateLastAccess();
1760: try {
1761: return metaData.supportsANSI92EntryLevelSQL();
1762: } catch (SQLException sqle) {
1763: error(messages.format("DataSource.GeneralMethodError",
1764: "supportsANSI92EntryLevelSQL()"), sqle);
1765: throw sqle;
1766: } catch (Throwable t) {
1767: SQLException sqle = connection.createWrappedSQLException(t,
1768: "supportsANSI92EntryLevelSQL()");
1769: throw sqle;
1770: }
1771: }
1772:
1773: public boolean supportsANSI92FullSQL() throws SQLException {
1774:
1775: connection.updateLastAccess();
1776: try {
1777: return metaData.supportsANSI92FullSQL();
1778: } catch (SQLException sqle) {
1779: error(messages.format("DataSource.GeneralMethodError",
1780: "supportsANSI92FullSQL()"), sqle);
1781: throw sqle;
1782: } catch (Throwable t) {
1783: SQLException sqle = connection.createWrappedSQLException(t,
1784: "supportsANSI92FullSQL()");
1785: throw sqle;
1786: }
1787: }
1788:
1789: public boolean supportsANSI92IntermediateSQL() throws SQLException {
1790:
1791: connection.updateLastAccess();
1792: try {
1793: return metaData.supportsANSI92IntermediateSQL();
1794: } catch (SQLException sqle) {
1795: error(messages.format("DataSource.GeneralMethodError",
1796: "supportsANSI92IntermediateSQL()"), sqle);
1797: throw sqle;
1798: } catch (Throwable t) {
1799: SQLException sqle = connection.createWrappedSQLException(t,
1800: "supportsANSI92IntermediateSQL()");
1801: throw sqle;
1802: }
1803: }
1804:
1805: public boolean supportsBatchUpdates() throws SQLException {
1806:
1807: connection.updateLastAccess();
1808: try {
1809: return metaData.supportsBatchUpdates();
1810: } catch (SQLException sqle) {
1811: error(messages.format("DataSource.GeneralMethodError",
1812: "supportsBatchUpdates()"), sqle);
1813: throw sqle;
1814: } catch (Throwable t) {
1815: SQLException sqle = connection.createWrappedSQLException(t,
1816: "supportsBatchUpdates()");
1817: throw sqle;
1818: }
1819: }
1820:
1821: public boolean supportsCatalogsInDataManipulation()
1822: throws SQLException {
1823:
1824: connection.updateLastAccess();
1825: try {
1826: return metaData.supportsCatalogsInDataManipulation();
1827: } catch (SQLException sqle) {
1828: error(messages.format("DataSource.GeneralMethodError",
1829: "supportsCatalogsInDataManipulation()"), sqle);
1830: throw sqle;
1831: } catch (Throwable t) {
1832: SQLException sqle = connection.createWrappedSQLException(t,
1833: "supportsCatalogsInDataManipulation()");
1834: throw sqle;
1835: }
1836: }
1837:
1838: public boolean supportsCatalogsInIndexDefinitions()
1839: throws SQLException {
1840:
1841: connection.updateLastAccess();
1842: try {
1843: return metaData.supportsCatalogsInIndexDefinitions();
1844: } catch (SQLException sqle) {
1845: error(messages.format("DataSource.GeneralMethodError",
1846: "supportsCatalogsInIndexDefinitions()"), sqle);
1847: throw sqle;
1848: } catch (Throwable t) {
1849: SQLException sqle = connection.createWrappedSQLException(t,
1850: "supportsCatalogsInIndexDefinitions()");
1851: throw sqle;
1852: }
1853: }
1854:
1855: public boolean supportsCatalogsInPrivilegeDefinitions()
1856: throws SQLException {
1857:
1858: connection.updateLastAccess();
1859: try {
1860: return metaData.supportsCatalogsInPrivilegeDefinitions();
1861: } catch (SQLException sqle) {
1862: error(messages.format("DataSource.GeneralMethodError",
1863: "supportsCatalogsInPrivilegeDefinitions()"), sqle);
1864: throw sqle;
1865: } catch (Throwable t) {
1866: SQLException sqle = connection.createWrappedSQLException(t,
1867: "supportsCatalogsInPrivilegeDefinitions()");
1868: throw sqle;
1869: }
1870: }
1871:
1872: public boolean supportsCatalogsInProcedureCalls()
1873: throws SQLException {
1874:
1875: connection.updateLastAccess();
1876: try {
1877: return metaData.supportsCatalogsInProcedureCalls();
1878: } catch (SQLException sqle) {
1879: error(messages.format("DataSource.GeneralMethodError",
1880: "supportsCatalogsInProcedureCalls()"), sqle);
1881: throw sqle;
1882: } catch (Throwable t) {
1883: SQLException sqle = connection.createWrappedSQLException(t,
1884: "supportsCatalogsInProcedureCalls()");
1885: throw sqle;
1886: }
1887: }
1888:
1889: public boolean supportsCatalogsInTableDefinitions()
1890: throws SQLException {
1891:
1892: connection.updateLastAccess();
1893: try {
1894: return metaData.supportsCatalogsInTableDefinitions();
1895: } catch (SQLException sqle) {
1896: error(messages.format("DataSource.GeneralMethodError",
1897: "supportsCatalogsInTableDefinitions()"), sqle);
1898: throw sqle;
1899: } catch (Throwable t) {
1900: SQLException sqle = connection.createWrappedSQLException(t,
1901: "supportsCatalogsInTableDefinitions()");
1902: throw sqle;
1903: }
1904: }
1905:
1906: public boolean supportsColumnAliasing() throws SQLException {
1907:
1908: connection.updateLastAccess();
1909: try {
1910: return metaData.supportsColumnAliasing();
1911: } catch (SQLException sqle) {
1912: error(messages.format("DataSource.GeneralMethodError",
1913: "supportsColumnAliasing()"), sqle);
1914: throw sqle;
1915: } catch (Throwable t) {
1916: SQLException sqle = connection.createWrappedSQLException(t,
1917: "supportsColumnAliasing()");
1918: throw sqle;
1919: }
1920: }
1921:
1922: public boolean supportsConvert() throws SQLException {
1923:
1924: connection.updateLastAccess();
1925: try {
1926: return metaData.supportsConvert();
1927: } catch (SQLException sqle) {
1928: error(messages.format("DataSource.GeneralMethodError",
1929: "supportsConvert()"), sqle);
1930: throw sqle;
1931: } catch (Throwable t) {
1932: SQLException sqle = connection.createWrappedSQLException(t,
1933: "supportsConvert()");
1934: throw sqle;
1935: }
1936: }
1937:
1938: public boolean supportsConvert(int fromType, int toType)
1939: throws SQLException {
1940:
1941: connection.updateLastAccess();
1942: try {
1943: return metaData.supportsConvert(fromType, toType);
1944: } catch (SQLException sqle) {
1945: error(messages.format("DataSource.GeneralMethodError",
1946: "supportsConvert(int,int)"), sqle);
1947: throw sqle;
1948: } catch (Throwable t) {
1949: SQLException sqle = connection.createWrappedSQLException(t,
1950: "supportsConvert(int,int)");
1951: throw sqle;
1952: }
1953: }
1954:
1955: public boolean supportsCoreSQLGrammar() throws SQLException {
1956:
1957: connection.updateLastAccess();
1958: try {
1959: return metaData.supportsCoreSQLGrammar();
1960: } catch (SQLException sqle) {
1961: error(messages.format("DataSource.GeneralMethodError",
1962: "supportsCoreSQLGrammar()"), sqle);
1963: throw sqle;
1964: } catch (Throwable t) {
1965: SQLException sqle = connection.createWrappedSQLException(t,
1966: "supportsCoreSQLGrammar()");
1967: throw sqle;
1968: }
1969: }
1970:
1971: public boolean supportsCorrelatedSubqueries() throws SQLException {
1972:
1973: connection.updateLastAccess();
1974: try {
1975: return metaData.supportsCorrelatedSubqueries();
1976: } catch (SQLException sqle) {
1977: error(messages.format("DataSource.GeneralMethodError",
1978: "supportsCorrelatedSubqueries()"), sqle);
1979: throw sqle;
1980: } catch (Throwable t) {
1981: SQLException sqle = connection.createWrappedSQLException(t,
1982: "supportsCorrelatedSubqueries()");
1983: throw sqle;
1984: }
1985: }
1986:
1987: public boolean supportsDataDefinitionAndDataManipulationTransactions()
1988: throws SQLException {
1989:
1990: connection.updateLastAccess();
1991: try {
1992: return metaData
1993: .supportsDataDefinitionAndDataManipulationTransactions();
1994: } catch (SQLException sqle) {
1995: error(
1996: messages
1997: .format("DataSource.GeneralMethodError",
1998: "supportsDataDefinitionAndDataManipulationTransactions()"),
1999: sqle);
2000: throw sqle;
2001: } catch (Throwable t) {
2002: SQLException sqle = connection
2003: .createWrappedSQLException(t,
2004: "supportsDataDefinitionAndDataManipulationTransactions()");
2005: throw sqle;
2006: }
2007: }
2008:
2009: public boolean supportsDataManipulationTransactionsOnly()
2010: throws SQLException {
2011:
2012: connection.updateLastAccess();
2013: try {
2014: return metaData.supportsDataManipulationTransactionsOnly();
2015: } catch (SQLException sqle) {
2016: error(messages.format("DataSource.GeneralMethodError",
2017: "supportsDataManipulationTransactionsOnly()"), sqle);
2018: throw sqle;
2019: } catch (Throwable t) {
2020: SQLException sqle = connection.createWrappedSQLException(t,
2021: "supportsDataManipulationTransactionsOnly()");
2022: throw sqle;
2023: }
2024: }
2025:
2026: public boolean supportsDifferentTableCorrelationNames()
2027: throws SQLException {
2028:
2029: connection.updateLastAccess();
2030: try {
2031: return metaData.supportsDifferentTableCorrelationNames();
2032: } catch (SQLException sqle) {
2033: error(messages.format("DataSource.GeneralMethodError",
2034: "supportsDifferentTableCorrelationNames()"), sqle);
2035: throw sqle;
2036: } catch (Throwable t) {
2037: SQLException sqle = connection.createWrappedSQLException(t,
2038: "supportsDifferentTableCorrelationNames()");
2039: throw sqle;
2040: }
2041: }
2042:
2043: public boolean supportsExpressionsInOrderBy() throws SQLException {
2044:
2045: connection.updateLastAccess();
2046: try {
2047: return metaData.supportsExpressionsInOrderBy();
2048: } catch (SQLException sqle) {
2049: error(messages.format("DataSource.GeneralMethodError",
2050: "supportsExpressionsInOrderBy()"), sqle);
2051: throw sqle;
2052: } catch (Throwable t) {
2053: SQLException sqle = connection.createWrappedSQLException(t,
2054: "supportsExpressionsInOrderBy()");
2055: throw sqle;
2056: }
2057: }
2058:
2059: public boolean supportsExtendedSQLGrammar() throws SQLException {
2060:
2061: connection.updateLastAccess();
2062: try {
2063: return metaData.supportsExtendedSQLGrammar();
2064: } catch (SQLException sqle) {
2065: error(messages.format("DataSource.GeneralMethodError",
2066: "supportsExtendedSQLGrammar()"), sqle);
2067: throw sqle;
2068: } catch (Throwable t) {
2069: SQLException sqle = connection.createWrappedSQLException(t,
2070: "supportsExtendedSQLGrammar()");
2071: throw sqle;
2072: }
2073: }
2074:
2075: public boolean supportsFullOuterJoins() throws SQLException {
2076:
2077: connection.updateLastAccess();
2078: try {
2079: return metaData.supportsFullOuterJoins();
2080: } catch (SQLException sqle) {
2081: error(messages.format("DataSource.GeneralMethodError",
2082: "supportsFullOuterJoins()"), sqle);
2083: throw sqle;
2084: } catch (Throwable t) {
2085: SQLException sqle = connection.createWrappedSQLException(t,
2086: "supportsFullOuterJoins()");
2087: throw sqle;
2088: }
2089: }
2090:
2091: public boolean supportsGetGeneratedKeys() throws SQLException {
2092:
2093: connection.updateLastAccess();
2094: try {
2095: return metaData.supportsGetGeneratedKeys();
2096: } catch (SQLException sqle) {
2097: error(messages.format("DataSource.GeneralMethodError",
2098: "supportsGetGeneratedKeys()"), sqle);
2099: throw sqle;
2100: } catch (Throwable t) {
2101: SQLException sqle = connection.createWrappedSQLException(t,
2102: "supportsGetGeneratedKeys()");
2103: throw sqle;
2104: }
2105: }
2106:
2107: public boolean supportsGroupBy() throws SQLException {
2108:
2109: connection.updateLastAccess();
2110: try {
2111: return metaData.supportsGroupBy();
2112: } catch (SQLException sqle) {
2113: error(messages.format("DataSource.GeneralMethodError",
2114: "supportsGroupBy()"), sqle);
2115: throw sqle;
2116: } catch (Throwable t) {
2117: SQLException sqle = connection.createWrappedSQLException(t,
2118: "supportsGroupBy()");
2119: throw sqle;
2120: }
2121: }
2122:
2123: public boolean supportsGroupByBeyondSelect() throws SQLException {
2124:
2125: connection.updateLastAccess();
2126: try {
2127: return metaData.supportsGroupByBeyondSelect();
2128: } catch (SQLException sqle) {
2129: error(messages.format("DataSource.GeneralMethodError",
2130: "supportsGroupByBeyondSelect()"), sqle);
2131: throw sqle;
2132: } catch (Throwable t) {
2133: SQLException sqle = connection.createWrappedSQLException(t,
2134: "supportsGroupByBeyondSelect()");
2135: throw sqle;
2136: }
2137: }
2138:
2139: public boolean supportsGroupByUnrelated() throws SQLException {
2140:
2141: connection.updateLastAccess();
2142: try {
2143: return metaData.supportsGroupByUnrelated();
2144: } catch (SQLException sqle) {
2145: error(messages.format("DataSource.GeneralMethodError",
2146: "supportsGroupByUnrelated()"), sqle);
2147: throw sqle;
2148: } catch (Throwable t) {
2149: SQLException sqle = connection.createWrappedSQLException(t,
2150: "supportsGroupByUnrelated()");
2151: throw sqle;
2152: }
2153: }
2154:
2155: public boolean supportsIntegrityEnhancementFacility()
2156: throws SQLException {
2157:
2158: connection.updateLastAccess();
2159: try {
2160: return metaData.supportsIntegrityEnhancementFacility();
2161: } catch (SQLException sqle) {
2162: error(messages.format("DataSource.GeneralMethodError",
2163: "supportsIntegrityEnhancementFacility()"), sqle);
2164: throw sqle;
2165: } catch (Throwable t) {
2166: SQLException sqle = connection.createWrappedSQLException(t,
2167: "supportsIntegrityEnhancementFacility()");
2168: throw sqle;
2169: }
2170: }
2171:
2172: public boolean supportsLikeEscapeClause() throws SQLException {
2173:
2174: connection.updateLastAccess();
2175: try {
2176: return metaData.supportsLikeEscapeClause();
2177: } catch (SQLException sqle) {
2178: error(messages.format("DataSource.GeneralMethodError",
2179: "supportsLikeEscapeClause()"), sqle);
2180: throw sqle;
2181: } catch (Throwable t) {
2182: SQLException sqle = connection.createWrappedSQLException(t,
2183: "supportsLikeEscapeClause()");
2184: throw sqle;
2185: }
2186: }
2187:
2188: public boolean supportsLimitedOuterJoins() throws SQLException {
2189:
2190: connection.updateLastAccess();
2191: try {
2192: return metaData.supportsLimitedOuterJoins();
2193: } catch (SQLException sqle) {
2194: error(messages.format("DataSource.GeneralMethodError",
2195: "supportsLimitedOuterJoins()"), sqle);
2196: throw sqle;
2197: } catch (Throwable t) {
2198: SQLException sqle = connection.createWrappedSQLException(t,
2199: "supportsLimitedOuterJoins()");
2200: throw sqle;
2201: }
2202: }
2203:
2204: public boolean supportsMinimumSQLGrammar() throws SQLException {
2205:
2206: connection.updateLastAccess();
2207: try {
2208: return metaData.supportsMinimumSQLGrammar();
2209: } catch (SQLException sqle) {
2210: error(messages.format("DataSource.GeneralMethodError",
2211: "supportsMinimumSQLGrammar()"), sqle);
2212: throw sqle;
2213: } catch (Throwable t) {
2214: SQLException sqle = connection.createWrappedSQLException(t,
2215: "supportsMinimumSQLGrammar()");
2216: throw sqle;
2217: }
2218: }
2219:
2220: public boolean supportsMixedCaseIdentifiers() throws SQLException {
2221:
2222: connection.updateLastAccess();
2223: try {
2224: return metaData.supportsMixedCaseIdentifiers();
2225: } catch (SQLException sqle) {
2226: error(messages.format("DataSource.GeneralMethodError",
2227: "supportsMixedCaseIdentifiers()"), sqle);
2228: throw sqle;
2229: } catch (Throwable t) {
2230: SQLException sqle = connection.createWrappedSQLException(t,
2231: "supportsMixedCaseIdentifiers()");
2232: throw sqle;
2233: }
2234: }
2235:
2236: public boolean supportsMixedCaseQuotedIdentifiers()
2237: throws SQLException {
2238:
2239: connection.updateLastAccess();
2240: try {
2241: return metaData.supportsMixedCaseQuotedIdentifiers();
2242: } catch (SQLException sqle) {
2243: error(messages.format("DataSource.GeneralMethodError",
2244: "supportsMixedCaseQuotedIdentifiers()"), sqle);
2245: throw sqle;
2246: } catch (Throwable t) {
2247: SQLException sqle = connection.createWrappedSQLException(t,
2248: "supportsMixedCaseQuotedIdentifiers()");
2249: throw sqle;
2250: }
2251: }
2252:
2253: public boolean supportsMultipleOpenResults() throws SQLException {
2254:
2255: connection.updateLastAccess();
2256: try {
2257: return metaData.supportsMultipleOpenResults();
2258: } catch (SQLException sqle) {
2259: error(messages.format("DataSource.GeneralMethodError",
2260: "supportsMultipleOpenResults()"), sqle);
2261: throw sqle;
2262: } catch (Throwable t) {
2263: SQLException sqle = connection.createWrappedSQLException(t,
2264: "supportsMultipleOpenResults()");
2265: throw sqle;
2266: }
2267: }
2268:
2269: public boolean supportsMultipleResultSets() throws SQLException {
2270:
2271: connection.updateLastAccess();
2272: try {
2273: return metaData.supportsMultipleResultSets();
2274: } catch (SQLException sqle) {
2275: error(messages.format("DataSource.GeneralMethodError",
2276: "supportsMultipleResultSets()"), sqle);
2277: throw sqle;
2278: } catch (Throwable t) {
2279: SQLException sqle = connection.createWrappedSQLException(t,
2280: "supportsMultipleResultSets()");
2281: throw sqle;
2282: }
2283: }
2284:
2285: public boolean supportsMultipleTransactions() throws SQLException {
2286:
2287: connection.updateLastAccess();
2288: try {
2289: return metaData.supportsMultipleTransactions();
2290: } catch (SQLException sqle) {
2291: error(messages.format("DataSource.GeneralMethodError",
2292: "supportsMultipleTransactions()"), sqle);
2293: throw sqle;
2294: } catch (Throwable t) {
2295: SQLException sqle = connection.createWrappedSQLException(t,
2296: "supportsMultipleTransactions()");
2297: throw sqle;
2298: }
2299: }
2300:
2301: public boolean supportsNamedParameters() throws SQLException {
2302:
2303: connection.updateLastAccess();
2304: try {
2305: return metaData.supportsNamedParameters();
2306: } catch (SQLException sqle) {
2307: error(messages.format("DataSource.GeneralMethodError",
2308: "supportsNamedParameters()"), sqle);
2309: throw sqle;
2310: } catch (Throwable t) {
2311: SQLException sqle = connection.createWrappedSQLException(t,
2312: "supportsNamedParameters()");
2313: throw sqle;
2314: }
2315: }
2316:
2317: public boolean supportsNonNullableColumns() throws SQLException {
2318:
2319: connection.updateLastAccess();
2320: try {
2321: return metaData.supportsNonNullableColumns();
2322: } catch (SQLException sqle) {
2323: error(messages.format("DataSource.GeneralMethodError",
2324: "supportsNonNullableColumns()"), sqle);
2325: throw sqle;
2326: } catch (Throwable t) {
2327: SQLException sqle = connection.createWrappedSQLException(t,
2328: "supportsNonNullableColumns()");
2329: throw sqle;
2330: }
2331: }
2332:
2333: public boolean supportsOpenCursorsAcrossCommit()
2334: throws SQLException {
2335:
2336: connection.updateLastAccess();
2337: try {
2338: return metaData.supportsOpenCursorsAcrossCommit();
2339: } catch (SQLException sqle) {
2340: error(messages.format("DataSource.GeneralMethodError",
2341: "supportsOpenCursorsAcrossCommit()"), sqle);
2342: throw sqle;
2343: } catch (Throwable t) {
2344: SQLException sqle = connection.createWrappedSQLException(t,
2345: "supportsOpenCursorsAcrossCommit()");
2346: throw sqle;
2347: }
2348: }
2349:
2350: public boolean supportsOpenCursorsAcrossRollback()
2351: throws SQLException {
2352:
2353: connection.updateLastAccess();
2354: try {
2355: return metaData.supportsOpenCursorsAcrossRollback();
2356: } catch (SQLException sqle) {
2357: error(messages.format("DataSource.GeneralMethodError",
2358: "supportsOpenCursorsAcrossRollback()"), sqle);
2359: throw sqle;
2360: } catch (Throwable t) {
2361: SQLException sqle = connection.createWrappedSQLException(t,
2362: "supportsOpenCursorsAcrossRollback()");
2363: throw sqle;
2364: }
2365: }
2366:
2367: public boolean supportsOpenStatementsAcrossCommit()
2368: throws SQLException {
2369:
2370: connection.updateLastAccess();
2371: try {
2372: return metaData.supportsOpenStatementsAcrossCommit();
2373: } catch (SQLException sqle) {
2374: error(messages.format("DataSource.GeneralMethodError",
2375: "supportsOpenStatementsAcrossCommit()"), sqle);
2376: throw sqle;
2377: } catch (Throwable t) {
2378: SQLException sqle = connection.createWrappedSQLException(t,
2379: "supportsOpenStatementsAcrossCommit()");
2380: throw sqle;
2381: }
2382: }
2383:
2384: public boolean supportsOpenStatementsAcrossRollback()
2385: throws SQLException {
2386:
2387: connection.updateLastAccess();
2388: try {
2389: return metaData.supportsOpenStatementsAcrossRollback();
2390: } catch (SQLException sqle) {
2391: error(messages.format("DataSource.GeneralMethodError",
2392: "supportsOpenStatementsAcrossRollback()"), sqle);
2393: throw sqle;
2394: } catch (Throwable t) {
2395: SQLException sqle = connection.createWrappedSQLException(t,
2396: "supportsOpenStatementsAcrossRollback()");
2397: throw sqle;
2398: }
2399: }
2400:
2401: public boolean supportsOrderByUnrelated() throws SQLException {
2402:
2403: connection.updateLastAccess();
2404: try {
2405: return metaData.supportsOrderByUnrelated();
2406: } catch (SQLException sqle) {
2407: error(messages.format("DataSource.GeneralMethodError",
2408: "supportsOrderByUnrelated()"), sqle);
2409: throw sqle;
2410: } catch (Throwable t) {
2411: SQLException sqle = connection.createWrappedSQLException(t,
2412: "supportsOrderByUnrelated()");
2413: throw sqle;
2414: }
2415: }
2416:
2417: public boolean supportsOuterJoins() throws SQLException {
2418:
2419: connection.updateLastAccess();
2420: try {
2421: return metaData.supportsOuterJoins();
2422: } catch (SQLException sqle) {
2423: error(messages.format("DataSource.GeneralMethodError",
2424: "supportsOuterJoins()"), sqle);
2425: throw sqle;
2426: } catch (Throwable t) {
2427: SQLException sqle = connection.createWrappedSQLException(t,
2428: "supportsOuterJoins()");
2429: throw sqle;
2430: }
2431: }
2432:
2433: public boolean supportsPositionedDelete() throws SQLException {
2434:
2435: connection.updateLastAccess();
2436: try {
2437: return metaData.supportsPositionedDelete();
2438: } catch (SQLException sqle) {
2439: error(messages.format("DataSource.GeneralMethodError",
2440: "supportsPositionedDelete()"), sqle);
2441: throw sqle;
2442: } catch (Throwable t) {
2443: SQLException sqle = connection.createWrappedSQLException(t,
2444: "supportsPositionedDelete()");
2445: throw sqle;
2446: }
2447: }
2448:
2449: public boolean supportsPositionedUpdate() throws SQLException {
2450:
2451: connection.updateLastAccess();
2452: try {
2453: return metaData.supportsPositionedUpdate();
2454: } catch (SQLException sqle) {
2455: error(messages.format("DataSource.GeneralMethodError",
2456: "supportsPositionedUpdate()"), sqle);
2457: throw sqle;
2458: } catch (Throwable t) {
2459: SQLException sqle = connection.createWrappedSQLException(t,
2460: "supportsPositionedUpdate()");
2461: throw sqle;
2462: }
2463: }
2464:
2465: public boolean supportsResultSetConcurrency(int type,
2466: int concurrency) throws SQLException {
2467:
2468: connection.updateLastAccess();
2469: try {
2470: return metaData.supportsResultSetConcurrency(type,
2471: concurrency);
2472: } catch (SQLException sqle) {
2473: error(messages.format("DataSource.GeneralMethodError",
2474: "supportsResultSetConcurrency(int)"), sqle);
2475: throw sqle;
2476: } catch (Throwable t) {
2477: SQLException sqle = connection.createWrappedSQLException(t,
2478: "supportsResultSetConcurrency(int)");
2479: throw sqle;
2480: }
2481: }
2482:
2483: public boolean supportsResultSetHoldability(int holdability)
2484: throws SQLException {
2485:
2486: connection.updateLastAccess();
2487: try {
2488: return metaData.supportsResultSetHoldability(holdability);
2489: } catch (SQLException sqle) {
2490: error(messages.format("DataSource.GeneralMethodError",
2491: "supportsResultSetHoldability(int)"), sqle);
2492: throw sqle;
2493: } catch (Throwable t) {
2494: SQLException sqle = connection.createWrappedSQLException(t,
2495: "supportsResultSetHoldability(int)");
2496: throw sqle;
2497: }
2498: }
2499:
2500: public boolean supportsResultSetType(int type) throws SQLException {
2501:
2502: connection.updateLastAccess();
2503: try {
2504: return metaData.supportsResultSetType(type);
2505: } catch (SQLException sqle) {
2506: error(messages.format("DataSource.GeneralMethodError",
2507: "supportsResultSetType(int)"), sqle);
2508: throw sqle;
2509: } catch (Throwable t) {
2510: SQLException sqle = connection.createWrappedSQLException(t,
2511: "supportsResultSetType(int)");
2512: throw sqle;
2513: }
2514: }
2515:
2516: public boolean supportsSavepoints() throws SQLException {
2517:
2518: connection.updateLastAccess();
2519: try {
2520: return metaData.supportsSavepoints();
2521: } catch (SQLException sqle) {
2522: error(messages.format("DataSource.GeneralMethodError",
2523: "supportsSavepoints()"), sqle);
2524: throw sqle;
2525: } catch (Throwable t) {
2526: SQLException sqle = connection.createWrappedSQLException(t,
2527: "supportsSavepoints()");
2528: throw sqle;
2529: }
2530: }
2531:
2532: public boolean supportsSchemasInDataManipulation()
2533: throws SQLException {
2534:
2535: connection.updateLastAccess();
2536: try {
2537: return metaData.supportsSchemasInDataManipulation();
2538: } catch (SQLException sqle) {
2539: error(messages.format("DataSource.GeneralMethodError",
2540: "supportsSchemasInDataManipulation()"), sqle);
2541: throw sqle;
2542: } catch (Throwable t) {
2543: SQLException sqle = connection.createWrappedSQLException(t,
2544: "supportsSchemasInDataManipulation()");
2545: throw sqle;
2546: }
2547: }
2548:
2549: public boolean supportsSchemasInIndexDefinitions()
2550: throws SQLException {
2551:
2552: connection.updateLastAccess();
2553: try {
2554: return metaData.supportsSchemasInIndexDefinitions();
2555: } catch (SQLException sqle) {
2556: error(messages.format("DataSource.GeneralMethodError",
2557: "supportsSchemasInIndexDefinitions()"), sqle);
2558: throw sqle;
2559: } catch (Throwable t) {
2560: SQLException sqle = connection.createWrappedSQLException(t,
2561: "supportsSchemasInIndexDefinitions()");
2562: throw sqle;
2563: }
2564: }
2565:
2566: public boolean supportsSchemasInPrivilegeDefinitions()
2567: throws SQLException {
2568:
2569: connection.updateLastAccess();
2570: try {
2571: return metaData.supportsSchemasInPrivilegeDefinitions();
2572: } catch (SQLException sqle) {
2573: error(messages.format("DataSource.GeneralMethodError",
2574: "supportsSchemasInPrivilegeDefinitions()"), sqle);
2575: throw sqle;
2576: } catch (Throwable t) {
2577: SQLException sqle = connection.createWrappedSQLException(t,
2578: "supportsSchemasInPrivilegeDefinitions()");
2579: throw sqle;
2580: }
2581: }
2582:
2583: public boolean supportsSchemasInProcedureCalls()
2584: throws SQLException {
2585:
2586: connection.updateLastAccess();
2587: try {
2588: return metaData.supportsSchemasInProcedureCalls();
2589: } catch (SQLException sqle) {
2590: error(messages.format("DataSource.GeneralMethodError",
2591: "supportsSchemasInProcedureCalls()"), sqle);
2592: throw sqle;
2593: } catch (Throwable t) {
2594: SQLException sqle = connection.createWrappedSQLException(t,
2595: "supportsSchemasInProcedureCalls()");
2596: throw sqle;
2597: }
2598: }
2599:
2600: public boolean supportsSchemasInTableDefinitions()
2601: throws SQLException {
2602:
2603: connection.updateLastAccess();
2604: try {
2605: return metaData.supportsSchemasInTableDefinitions();
2606: } catch (SQLException sqle) {
2607: error(messages.format("DataSource.GeneralMethodError",
2608: "supportsSchemasInTableDefinitions()"), sqle);
2609: throw sqle;
2610: } catch (Throwable t) {
2611: SQLException sqle = connection.createWrappedSQLException(t,
2612: "supportsSchemasInTableDefinitions()");
2613: throw sqle;
2614: }
2615: }
2616:
2617: public boolean supportsSelectForUpdate() throws SQLException {
2618:
2619: connection.updateLastAccess();
2620: try {
2621: return metaData.supportsSelectForUpdate();
2622: } catch (SQLException sqle) {
2623: error(messages.format("DataSource.GeneralMethodError",
2624: "supportsSelectForUpdate()"), sqle);
2625: throw sqle;
2626: } catch (Throwable t) {
2627: SQLException sqle = connection.createWrappedSQLException(t,
2628: "supportsSelectForUpdate()");
2629: throw sqle;
2630: }
2631: }
2632:
2633: public boolean supportsStatementPooling() throws SQLException {
2634:
2635: connection.updateLastAccess();
2636: try {
2637: return metaData.supportsStatementPooling();
2638: } catch (SQLException sqle) {
2639: error(messages.format("DataSource.GeneralMethodError",
2640: "supportsStatementPooling()"), sqle);
2641: throw sqle;
2642: } catch (Throwable t) {
2643: SQLException sqle = connection.createWrappedSQLException(t,
2644: "supportsStatementPooling()");
2645: throw sqle;
2646: }
2647: }
2648:
2649: public boolean supportsStoredProcedures() throws SQLException {
2650:
2651: connection.updateLastAccess();
2652: try {
2653: return metaData.supportsStoredProcedures();
2654: } catch (SQLException sqle) {
2655: error(messages.format("DataSource.GeneralMethodError",
2656: "supportsStoredProcedures()"), sqle);
2657: throw sqle;
2658: } catch (Throwable t) {
2659: SQLException sqle = connection.createWrappedSQLException(t,
2660: "supportsStoredProcedures()");
2661: throw sqle;
2662: }
2663: }
2664:
2665: public boolean supportsSubqueriesInComparisons()
2666: throws SQLException {
2667:
2668: connection.updateLastAccess();
2669: try {
2670: return metaData.supportsSubqueriesInComparisons();
2671: } catch (SQLException sqle) {
2672: error(messages.format("DataSource.GeneralMethodError",
2673: "supportsSubqueriesInComparisons()"), sqle);
2674: throw sqle;
2675: } catch (Throwable t) {
2676: SQLException sqle = connection.createWrappedSQLException(t,
2677: "supportsSubqueriesInComparisons()");
2678: throw sqle;
2679: }
2680: }
2681:
2682: public boolean supportsSubqueriesInExists() throws SQLException {
2683:
2684: connection.updateLastAccess();
2685: try {
2686: return metaData.supportsSubqueriesInExists();
2687: } catch (SQLException sqle) {
2688: error(messages.format("DataSource.GeneralMethodError",
2689: "supportsSubqueriesInExists()"), sqle);
2690: throw sqle;
2691: } catch (Throwable t) {
2692: SQLException sqle = connection.createWrappedSQLException(t,
2693: "supportsSubqueriesInExists()");
2694: throw sqle;
2695: }
2696: }
2697:
2698: public boolean supportsSubqueriesInIns() throws SQLException {
2699:
2700: connection.updateLastAccess();
2701: try {
2702: return metaData.supportsSubqueriesInIns();
2703: } catch (SQLException sqle) {
2704: error(messages.format("DataSource.GeneralMethodError",
2705: "supportsSubqueriesInIns()"), sqle);
2706: throw sqle;
2707: } catch (Throwable t) {
2708: SQLException sqle = connection.createWrappedSQLException(t,
2709: "supportsSubqueriesInIns()");
2710: throw sqle;
2711: }
2712: }
2713:
2714: public boolean supportsSubqueriesInQuantifieds()
2715: throws SQLException {
2716:
2717: connection.updateLastAccess();
2718: try {
2719: return metaData.supportsSubqueriesInQuantifieds();
2720: } catch (SQLException sqle) {
2721: error(messages.format("DataSource.GeneralMethodError",
2722: "supportsSubqueriesInQuantifieds()"), sqle);
2723: throw sqle;
2724: } catch (Throwable t) {
2725: SQLException sqle = connection.createWrappedSQLException(t,
2726: "supportsSubqueriesInQuantifieds()");
2727: throw sqle;
2728: }
2729: }
2730:
2731: public boolean supportsTableCorrelationNames() throws SQLException {
2732:
2733: connection.updateLastAccess();
2734: try {
2735: return metaData.supportsTableCorrelationNames();
2736: } catch (SQLException sqle) {
2737: error(messages.format("DataSource.GeneralMethodError",
2738: "supportsTableCorrelationNames()"), sqle);
2739: throw sqle;
2740: } catch (Throwable t) {
2741: SQLException sqle = connection.createWrappedSQLException(t,
2742: "supportsTableCorrelationNames()");
2743: throw sqle;
2744: }
2745: }
2746:
2747: public boolean supportsTransactionIsolationLevel(int level)
2748: throws SQLException {
2749:
2750: connection.updateLastAccess();
2751: try {
2752: return metaData.supportsTransactionIsolationLevel(level);
2753: } catch (SQLException sqle) {
2754: error(messages.format("DataSource.GeneralMethodError",
2755: "supportsTransactionIsolationLevel(int)"), sqle);
2756: throw sqle;
2757: } catch (Throwable t) {
2758: SQLException sqle = connection.createWrappedSQLException(t,
2759: "supportsTransactionIsolationLevel(int)");
2760: throw sqle;
2761: }
2762: }
2763:
2764: public boolean supportsTransactions() throws SQLException {
2765:
2766: connection.updateLastAccess();
2767: try {
2768: return metaData.supportsTransactions();
2769: } catch (SQLException sqle) {
2770: error(messages.format("DataSource.GeneralMethodError",
2771: "supportsTransactions()"), sqle);
2772: throw sqle;
2773: } catch (Throwable t) {
2774: SQLException sqle = connection.createWrappedSQLException(t,
2775: "supportsTransactions()");
2776: throw sqle;
2777: }
2778: }
2779:
2780: public boolean supportsUnion() throws SQLException {
2781:
2782: connection.updateLastAccess();
2783: try {
2784: return metaData.supportsUnion();
2785: } catch (SQLException sqle) {
2786: error(messages.format("DataSource.GeneralMethodError",
2787: "supportsUnion()"), sqle);
2788: throw sqle;
2789: } catch (Throwable t) {
2790: SQLException sqle = connection.createWrappedSQLException(t,
2791: "supportsUnion()");
2792: throw sqle;
2793: }
2794: }
2795:
2796: public boolean supportsUnionAll() throws SQLException {
2797:
2798: connection.updateLastAccess();
2799: try {
2800: return metaData.supportsUnionAll();
2801: } catch (SQLException sqle) {
2802: error(messages.format("DataSource.GeneralMethodError",
2803: "supportsUnionAll()"), sqle);
2804: throw sqle;
2805: } catch (Throwable t) {
2806: SQLException sqle = connection.createWrappedSQLException(t,
2807: "supportsUnionAll()");
2808: throw sqle;
2809: }
2810: }
2811:
2812: public boolean updatesAreDetected(int type) throws SQLException {
2813:
2814: connection.updateLastAccess();
2815: try {
2816: return metaData.updatesAreDetected(type);
2817: } catch (SQLException sqle) {
2818: error(messages.format("DataSource.GeneralMethodError",
2819: "updatesAreDetected(int)"), sqle);
2820: throw sqle;
2821: } catch (Throwable t) {
2822: SQLException sqle = connection.createWrappedSQLException(t,
2823: "updatesAreDetected(int)");
2824: throw sqle;
2825: }
2826: }
2827:
2828: public boolean usesLocalFilePerTable() throws SQLException {
2829:
2830: connection.updateLastAccess();
2831: try {
2832: return metaData.usesLocalFilePerTable();
2833: } catch (SQLException sqle) {
2834: error(messages.format("DataSource.GeneralMethodError",
2835: "usesLocalFilePerTable()"), sqle);
2836: throw sqle;
2837: } catch (Throwable t) {
2838: SQLException sqle = connection.createWrappedSQLException(t,
2839: "usesLocalFilePerTable()");
2840: throw sqle;
2841: }
2842: }
2843:
2844: public boolean usesLocalFiles() throws SQLException {
2845:
2846: connection.updateLastAccess();
2847: try {
2848: return metaData.usesLocalFiles();
2849: } catch (SQLException sqle) {
2850: error(messages.format("DataSource.GeneralMethodError",
2851: "useLocalFiles()"), sqle);
2852: throw sqle;
2853: } catch (Throwable t) {
2854: SQLException sqle = connection.createWrappedSQLException(t,
2855: "useLocalFiles()");
2856: throw sqle;
2857: }
2858: }
2859:
2860: protected void info(Object message, Throwable error) {
2861:
2862: connection.info(message, error);
2863: }
2864:
2865: protected void info(Object message) {
2866:
2867: connection.info(message);
2868: }
2869:
2870: protected void debug(Object message, Throwable error) {
2871:
2872: connection.trace(message, error);
2873: }
2874:
2875: protected void debug(Object message) {
2876:
2877: connection.trace(message);
2878: }
2879:
2880: protected void error(Object message, Throwable error) {
2881:
2882: connection.error(message, error);
2883: }
2884:
2885: protected void error(Object message) {
2886:
2887: connection.error(message);
2888: }
2889:
2890: protected void warn(Object message, Throwable error) {
2891:
2892: connection.warn(message, error);
2893: }
2894:
2895: protected void warn(Object message) {
2896:
2897: connection.warn(message);
2898: }
2899: }
|