0001: package net.sourceforge.squirrel_sql.jdbcproxy;
0002:
0003: /*
0004: * Copyright (C) 2006 Rob Manning
0005: * manningr@users.sourceforge.net
0006: *
0007: * This library is free software; you can redistribute it and/or
0008: * modify it under the terms of the GNU Lesser General Public
0009: * License as published by the Free Software Foundation; either
0010: * version 2.1 of the License, or (at your option) any later version.
0011: *
0012: * This library is distributed in the hope that it will be useful,
0013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0015: * Lesser General Public License for more details.
0016: *
0017: * You should have received a copy of the GNU Lesser General Public
0018: * License along with this library; if not, write to the Free Software
0019: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0020: */
0021:
0022: import java.sql.Connection;
0023: import java.sql.DatabaseMetaData;
0024: import java.sql.ResultSet;
0025: import java.sql.SQLException;
0026:
0027: public class ProxyDatabaseMetaData implements DatabaseMetaData {
0028:
0029: private DatabaseMetaData _data = null;
0030:
0031: public ProxyDatabaseMetaData(DatabaseMetaData data) {
0032: _data = data;
0033: }
0034:
0035: public int getDatabaseMajorVersion() throws SQLException {
0036: ProxyMethodManager.check("ProxyDatabaseMetaData",
0037: "getDatabaseMajorVersion");
0038: return _data.getDatabaseMajorVersion();
0039: }
0040:
0041: public int getDatabaseMinorVersion() throws SQLException {
0042: ProxyMethodManager.check("ProxyDatabaseMetaData",
0043: "getDatabaseMinorVersion");
0044: return _data.getDatabaseMinorVersion();
0045: }
0046:
0047: public int getDefaultTransactionIsolation() throws SQLException {
0048: ProxyMethodManager.check("ProxyDatabaseMetaData",
0049: "getDefaultTransactionIsolation");
0050: return _data.getDefaultTransactionIsolation();
0051: }
0052:
0053: public int getDriverMajorVersion() {
0054: return _data.getDriverMajorVersion();
0055: }
0056:
0057: public int getDriverMinorVersion() {
0058: return _data.getDriverMinorVersion();
0059: }
0060:
0061: public int getJDBCMajorVersion() throws SQLException {
0062: ProxyMethodManager.check("ProxyDatabaseMetaData",
0063: "getJDBCMajorVersion");
0064: return _data.getJDBCMajorVersion();
0065: }
0066:
0067: public int getJDBCMinorVersion() throws SQLException {
0068: ProxyMethodManager.check("ProxyDatabaseMetaData",
0069: "getJDBCMinorVersion");
0070: return _data.getJDBCMinorVersion();
0071: }
0072:
0073: public int getMaxBinaryLiteralLength() throws SQLException {
0074: ProxyMethodManager.check("ProxyDatabaseMetaData",
0075: "getMaxBinaryLiteralLength");
0076: return _data.getMaxBinaryLiteralLength();
0077: }
0078:
0079: public int getMaxCatalogNameLength() throws SQLException {
0080: ProxyMethodManager.check("ProxyDatabaseMetaData",
0081: "getMaxCatalogNameLength");
0082: return _data.getMaxCatalogNameLength();
0083: }
0084:
0085: public int getMaxCharLiteralLength() throws SQLException {
0086: ProxyMethodManager.check("ProxyDatabaseMetaData",
0087: "getMaxCharLiteralLength");
0088: return _data.getMaxCharLiteralLength();
0089: }
0090:
0091: public int getMaxColumnNameLength() throws SQLException {
0092: ProxyMethodManager.check("ProxyDatabaseMetaData",
0093: "getMaxColumnNameLength");
0094: return _data.getMaxColumnNameLength();
0095: }
0096:
0097: public int getMaxColumnsInGroupBy() throws SQLException {
0098: ProxyMethodManager.check("ProxyDatabaseMetaData",
0099: "getMaxColumnsInGroupBy");
0100: return _data.getMaxColumnsInGroupBy();
0101: }
0102:
0103: public int getMaxColumnsInIndex() throws SQLException {
0104: ProxyMethodManager.check("ProxyDatabaseMetaData",
0105: "getMaxColumnsInIndex");
0106: return _data.getMaxColumnsInIndex();
0107: }
0108:
0109: public int getMaxColumnsInOrderBy() throws SQLException {
0110: ProxyMethodManager.check("ProxyDatabaseMetaData",
0111: "getMaxColumnsInOrderBy");
0112: return _data.getMaxColumnsInOrderBy();
0113: }
0114:
0115: public int getMaxColumnsInSelect() throws SQLException {
0116: ProxyMethodManager.check("ProxyDatabaseMetaData",
0117: "getMaxColumnsInSelect");
0118: return _data.getMaxColumnsInSelect();
0119: }
0120:
0121: public int getMaxColumnsInTable() throws SQLException {
0122: ProxyMethodManager.check("ProxyDatabaseMetaData",
0123: "getMaxColumnsInTable");
0124: return _data.getMaxColumnsInTable();
0125: }
0126:
0127: public int getMaxConnections() throws SQLException {
0128: ProxyMethodManager.check("ProxyDatabaseMetaData",
0129: "getMaxConnections");
0130: return _data.getMaxConnections();
0131: }
0132:
0133: public int getMaxCursorNameLength() throws SQLException {
0134: ProxyMethodManager.check("ProxyDatabaseMetaData",
0135: "getMaxCursorNameLength");
0136: return _data.getMaxCursorNameLength();
0137: }
0138:
0139: public int getMaxIndexLength() throws SQLException {
0140: ProxyMethodManager.check("ProxyDatabaseMetaData",
0141: "getMaxIndexLength");
0142: return _data.getMaxIndexLength();
0143: }
0144:
0145: public int getMaxProcedureNameLength() throws SQLException {
0146: ProxyMethodManager.check("ProxyDatabaseMetaData",
0147: "getMaxProcedureNameLength");
0148: return _data.getMaxProcedureNameLength();
0149: }
0150:
0151: public int getMaxRowSize() throws SQLException {
0152: ProxyMethodManager.check("ProxyDatabaseMetaData",
0153: "getMaxRowSize");
0154: return _data.getMaxRowSize();
0155: }
0156:
0157: public int getMaxSchemaNameLength() throws SQLException {
0158: ProxyMethodManager.check("ProxyDatabaseMetaData",
0159: "getMaxSchemaNameLength");
0160: return _data.getMaxSchemaNameLength();
0161: }
0162:
0163: public int getMaxStatementLength() throws SQLException {
0164: ProxyMethodManager.check("ProxyDatabaseMetaData",
0165: "getMaxStatementLength");
0166: return _data.getMaxStatementLength();
0167: }
0168:
0169: public int getMaxStatements() throws SQLException {
0170: ProxyMethodManager.check("ProxyDatabaseMetaData",
0171: "getMaxStatements");
0172: return _data.getMaxStatements();
0173: }
0174:
0175: public int getMaxTableNameLength() throws SQLException {
0176: ProxyMethodManager.check("ProxyDatabaseMetaData",
0177: "getMaxTableNameLength");
0178: return _data.getMaxTableNameLength();
0179: }
0180:
0181: public int getMaxTablesInSelect() throws SQLException {
0182: ProxyMethodManager.check("ProxyDatabaseMetaData",
0183: "getMaxTablesInSelect");
0184: return _data.getMaxTablesInSelect();
0185: }
0186:
0187: public int getMaxUserNameLength() throws SQLException {
0188: ProxyMethodManager.check("ProxyDatabaseMetaData",
0189: "getMaxUserNameLength");
0190: return _data.getMaxUserNameLength();
0191:
0192: }
0193:
0194: public int getResultSetHoldability() throws SQLException {
0195: ProxyMethodManager.check("ProxyDatabaseMetaData",
0196: "getResultSetHoldability");
0197: return _data.getResultSetHoldability();
0198: }
0199:
0200: public int getSQLStateType() throws SQLException {
0201: ProxyMethodManager.check("ProxyDatabaseMetaData",
0202: "getSQLStateType");
0203: return _data.getSQLStateType();
0204: }
0205:
0206: public boolean allProceduresAreCallable() throws SQLException {
0207: ProxyMethodManager.check("ProxyDatabaseMetaData",
0208: "allProceduresAreCallable");
0209: return _data.allProceduresAreCallable();
0210: }
0211:
0212: public boolean allTablesAreSelectable() throws SQLException {
0213: ProxyMethodManager.check("ProxyDatabaseMetaData",
0214: "allTablesAreSelectable");
0215: return _data.allTablesAreSelectable();
0216: }
0217:
0218: public boolean dataDefinitionCausesTransactionCommit()
0219: throws SQLException {
0220: ProxyMethodManager.check("ProxyDatabaseMetaData",
0221: "dataDefinitionCausesTransactionCommit");
0222: return _data.dataDefinitionCausesTransactionCommit();
0223: }
0224:
0225: public boolean dataDefinitionIgnoredInTransactions()
0226: throws SQLException {
0227: ProxyMethodManager.check("ProxyDatabaseMetaData",
0228: "dataDefinitionIgnoredInTransactions");
0229: return _data.dataDefinitionIgnoredInTransactions();
0230: }
0231:
0232: public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
0233: ProxyMethodManager.check("ProxyDatabaseMetaData",
0234: "doesMaxRowSizeIncludeBlobs");
0235: return _data.doesMaxRowSizeIncludeBlobs();
0236: }
0237:
0238: public boolean isCatalogAtStart() throws SQLException {
0239: ProxyMethodManager.check("ProxyDatabaseMetaData",
0240: "isCatalogAtStart");
0241: return _data.isCatalogAtStart();
0242: }
0243:
0244: public boolean isReadOnly() throws SQLException {
0245: ProxyMethodManager.check("ProxyDatabaseMetaData", "isReadOnly");
0246: return _data.isReadOnly();
0247: }
0248:
0249: public boolean locatorsUpdateCopy() throws SQLException {
0250: ProxyMethodManager.check("ProxyDatabaseMetaData",
0251: "locatorsUpdateCopy");
0252: return _data.locatorsUpdateCopy();
0253: }
0254:
0255: public boolean nullPlusNonNullIsNull() throws SQLException {
0256: ProxyMethodManager.check("ProxyDatabaseMetaData",
0257: "nullPlusNonNullIsNull");
0258: return _data.nullPlusNonNullIsNull();
0259: }
0260:
0261: public boolean nullsAreSortedAtEnd() throws SQLException {
0262: ProxyMethodManager.check("ProxyDatabaseMetaData",
0263: "nullsAreSortedAtEnd");
0264: return _data.nullsAreSortedAtEnd();
0265: }
0266:
0267: public boolean nullsAreSortedAtStart() throws SQLException {
0268: ProxyMethodManager.check("ProxyDatabaseMetaData",
0269: "nullsAreSortedAtStart");
0270: return _data.nullsAreSortedAtStart();
0271: }
0272:
0273: public boolean nullsAreSortedHigh() throws SQLException {
0274: ProxyMethodManager.check("ProxyDatabaseMetaData",
0275: "nullsAreSortedHigh");
0276: return _data.nullsAreSortedHigh();
0277: }
0278:
0279: public boolean nullsAreSortedLow() throws SQLException {
0280: ProxyMethodManager.check("ProxyDatabaseMetaData",
0281: "nullsAreSortedLow");
0282: return _data.nullsAreSortedLow();
0283: }
0284:
0285: public boolean storesLowerCaseIdentifiers() throws SQLException {
0286: ProxyMethodManager.check("ProxyDatabaseMetaData",
0287: "storesLowerCaseIdentifiers");
0288: return _data.storesLowerCaseIdentifiers();
0289: }
0290:
0291: public boolean storesLowerCaseQuotedIdentifiers()
0292: throws SQLException {
0293: ProxyMethodManager.check("ProxyDatabaseMetaData",
0294: "storesLowerCaseQuotedIdentifiers");
0295: return _data.storesLowerCaseQuotedIdentifiers();
0296: }
0297:
0298: public boolean storesMixedCaseIdentifiers() throws SQLException {
0299: ProxyMethodManager.check("ProxyDatabaseMetaData",
0300: "storesMixedCaseIdentifiers");
0301: return _data.storesMixedCaseIdentifiers();
0302: }
0303:
0304: public boolean storesMixedCaseQuotedIdentifiers()
0305: throws SQLException {
0306: ProxyMethodManager.check("ProxyDatabaseMetaData",
0307: "storesMixedCaseQuotedIdentifiers");
0308: return _data.storesMixedCaseQuotedIdentifiers();
0309: }
0310:
0311: public boolean storesUpperCaseIdentifiers() throws SQLException {
0312: ProxyMethodManager.check("ProxyDatabaseMetaData",
0313: "storesUpperCaseIdentifiers");
0314: return _data.storesUpperCaseIdentifiers();
0315: }
0316:
0317: public boolean storesUpperCaseQuotedIdentifiers()
0318: throws SQLException {
0319: ProxyMethodManager.check("ProxyDatabaseMetaData",
0320: "storesUpperCaseQuotedIdentifiers");
0321: return _data.storesUpperCaseQuotedIdentifiers();
0322: }
0323:
0324: public boolean supportsANSI92EntryLevelSQL() throws SQLException {
0325: ProxyMethodManager.check("ProxyDatabaseMetaData",
0326: "supportsANSI92EntryLevelSQL");
0327: return _data.supportsANSI92EntryLevelSQL();
0328: }
0329:
0330: public boolean supportsANSI92FullSQL() throws SQLException {
0331: ProxyMethodManager.check("ProxyDatabaseMetaData",
0332: "supportsANSI92FullSQL");
0333: return _data.supportsANSI92FullSQL();
0334: }
0335:
0336: public boolean supportsANSI92IntermediateSQL() throws SQLException {
0337: ProxyMethodManager.check("ProxyDatabaseMetaData",
0338: "supportsANSI92IntermediateSQL");
0339: return _data.supportsANSI92IntermediateSQL();
0340: }
0341:
0342: public boolean supportsAlterTableWithAddColumn()
0343: throws SQLException {
0344: ProxyMethodManager.check("ProxyDatabaseMetaData",
0345: "supportsAlterTableWithAddColumn");
0346: return _data.supportsAlterTableWithAddColumn();
0347: }
0348:
0349: public boolean supportsAlterTableWithDropColumn()
0350: throws SQLException {
0351: ProxyMethodManager.check("ProxyDatabaseMetaData",
0352: "supportsAlterTableWithDropColumn");
0353: return _data.supportsAlterTableWithDropColumn();
0354: }
0355:
0356: public boolean supportsBatchUpdates() throws SQLException {
0357: ProxyMethodManager.check("ProxyDatabaseMetaData",
0358: "supportsBatchUpdates");
0359: return _data.supportsBatchUpdates();
0360: }
0361:
0362: public boolean supportsCatalogsInDataManipulation()
0363: throws SQLException {
0364: ProxyMethodManager.check("ProxyDatabaseMetaData",
0365: "supportsCatalogsInDataManipulation");
0366: return _data.supportsCatalogsInDataManipulation();
0367: }
0368:
0369: public boolean supportsCatalogsInIndexDefinitions()
0370: throws SQLException {
0371: ProxyMethodManager.check("ProxyDatabaseMetaData",
0372: "supportsCatalogsInIndexDefinitions");
0373: return _data.supportsCatalogsInIndexDefinitions();
0374: }
0375:
0376: public boolean supportsCatalogsInPrivilegeDefinitions()
0377: throws SQLException {
0378: ProxyMethodManager.check("ProxyDatabaseMetaData",
0379: "supportsCatalogsInPrivilegeDefinitions");
0380: return _data.supportsCatalogsInPrivilegeDefinitions();
0381: }
0382:
0383: public boolean supportsCatalogsInProcedureCalls()
0384: throws SQLException {
0385: ProxyMethodManager.check("ProxyDatabaseMetaData",
0386: "supportsCatalogsInProcedureCalls");
0387: return _data.supportsCatalogsInProcedureCalls();
0388: }
0389:
0390: public boolean supportsCatalogsInTableDefinitions()
0391: throws SQLException {
0392: ProxyMethodManager.check("ProxyDatabaseMetaData",
0393: "supportsCatalogsInTableDefinitions");
0394: return _data.supportsCatalogsInTableDefinitions();
0395: }
0396:
0397: public boolean supportsColumnAliasing() throws SQLException {
0398: ProxyMethodManager.check("ProxyDatabaseMetaData",
0399: "supportsColumnAliasing");
0400: return _data.supportsColumnAliasing();
0401: }
0402:
0403: public boolean supportsConvert() throws SQLException {
0404: ProxyMethodManager.check("ProxyDatabaseMetaData",
0405: "supportsConvert");
0406: return _data.supportsConvert();
0407: }
0408:
0409: public boolean supportsCoreSQLGrammar() throws SQLException {
0410: ProxyMethodManager.check("ProxyDatabaseMetaData",
0411: "supportsCoreSQLGrammar");
0412: return _data.supportsCoreSQLGrammar();
0413: }
0414:
0415: public boolean supportsCorrelatedSubqueries() throws SQLException {
0416: ProxyMethodManager.check("ProxyDatabaseMetaData",
0417: "supportsCorrelatedSubqueries");
0418: return _data.supportsCorrelatedSubqueries();
0419: }
0420:
0421: public boolean supportsDataDefinitionAndDataManipulationTransactions()
0422: throws SQLException {
0423: ProxyMethodManager
0424: .check("ProxyDatabaseMetaData",
0425: "supportsDataDefinitionAndDataManipulationTransactions");
0426: return _data
0427: .supportsDataDefinitionAndDataManipulationTransactions();
0428: }
0429:
0430: public boolean supportsDataManipulationTransactionsOnly()
0431: throws SQLException {
0432: ProxyMethodManager.check("ProxyDatabaseMetaData",
0433: "supportsDataManipulationTransactionsOnly");
0434: return _data.supportsDataManipulationTransactionsOnly();
0435: }
0436:
0437: public boolean supportsDifferentTableCorrelationNames()
0438: throws SQLException {
0439: ProxyMethodManager.check("ProxyDatabaseMetaData",
0440: "supportsDifferentTableCorrelationNames");
0441: return _data.supportsDifferentTableCorrelationNames();
0442: }
0443:
0444: public boolean supportsExpressionsInOrderBy() throws SQLException {
0445: ProxyMethodManager.check("ProxyDatabaseMetaData",
0446: "supportsExpressionsInOrderBy");
0447: return _data.supportsExpressionsInOrderBy();
0448: }
0449:
0450: public boolean supportsExtendedSQLGrammar() throws SQLException {
0451: ProxyMethodManager.check("ProxyDatabaseMetaData",
0452: "supportsExtendedSQLGrammar");
0453: return _data.supportsExtendedSQLGrammar();
0454: }
0455:
0456: public boolean supportsFullOuterJoins() throws SQLException {
0457: ProxyMethodManager.check("ProxyDatabaseMetaData",
0458: "supportsFullOuterJoins");
0459: return _data.supportsFullOuterJoins();
0460: }
0461:
0462: public boolean supportsGetGeneratedKeys() throws SQLException {
0463: ProxyMethodManager.check("ProxyDatabaseMetaData",
0464: "supportsGetGeneratedKeys");
0465: return _data.supportsGetGeneratedKeys();
0466: }
0467:
0468: public boolean supportsGroupBy() throws SQLException {
0469: ProxyMethodManager.check("ProxyDatabaseMetaData",
0470: "supportsGroupBy");
0471: return _data.supportsGroupBy();
0472: }
0473:
0474: public boolean supportsGroupByBeyondSelect() throws SQLException {
0475: ProxyMethodManager.check("ProxyDatabaseMetaData",
0476: "supportsGroupByBeyondSelect");
0477: return _data.supportsGroupByBeyondSelect();
0478: }
0479:
0480: public boolean supportsGroupByUnrelated() throws SQLException {
0481: ProxyMethodManager.check("ProxyDatabaseMetaData",
0482: "supportsGroupByUnrelated");
0483: return _data.supportsGroupByUnrelated();
0484: }
0485:
0486: public boolean supportsIntegrityEnhancementFacility()
0487: throws SQLException {
0488: ProxyMethodManager.check("ProxyDatabaseMetaData",
0489: "supportsIntegrityEnhancementFacility");
0490: return _data.supportsIntegrityEnhancementFacility();
0491: }
0492:
0493: public boolean supportsLikeEscapeClause() throws SQLException {
0494: ProxyMethodManager.check("ProxyDatabaseMetaData",
0495: "supportsLikeEscapeClause");
0496: return _data.supportsLikeEscapeClause();
0497: }
0498:
0499: public boolean supportsLimitedOuterJoins() throws SQLException {
0500: ProxyMethodManager.check("ProxyDatabaseMetaData",
0501: "supportsLimitedOuterJoins");
0502: return _data.supportsLimitedOuterJoins();
0503: }
0504:
0505: public boolean supportsMinimumSQLGrammar() throws SQLException {
0506: ProxyMethodManager.check("ProxyDatabaseMetaData",
0507: "supportsMinimumSQLGrammar");
0508: return _data.supportsMinimumSQLGrammar();
0509: }
0510:
0511: public boolean supportsMixedCaseIdentifiers() throws SQLException {
0512: ProxyMethodManager.check("ProxyDatabaseMetaData",
0513: "supportsMixedCaseIdentifiers");
0514: return _data.supportsMixedCaseIdentifiers();
0515: }
0516:
0517: public boolean supportsMixedCaseQuotedIdentifiers()
0518: throws SQLException {
0519: ProxyMethodManager.check("ProxyDatabaseMetaData",
0520: "supportsMixedCaseQuotedIdentifiers");
0521: return _data.supportsMixedCaseQuotedIdentifiers();
0522: }
0523:
0524: public boolean supportsMultipleOpenResults() throws SQLException {
0525: ProxyMethodManager.check("ProxyDatabaseMetaData",
0526: "supportsMultipleOpenResults");
0527: return _data.supportsMultipleOpenResults();
0528: }
0529:
0530: public boolean supportsMultipleResultSets() throws SQLException {
0531: ProxyMethodManager.check("ProxyDatabaseMetaData",
0532: "supportsMultipleResultSets");
0533: return _data.supportsMultipleResultSets();
0534: }
0535:
0536: public boolean supportsMultipleTransactions() throws SQLException {
0537: ProxyMethodManager.check("ProxyDatabaseMetaData",
0538: "supportsMultipleTransactions");
0539: return _data.supportsMultipleTransactions();
0540: }
0541:
0542: public boolean supportsNamedParameters() throws SQLException {
0543: ProxyMethodManager.check("ProxyDatabaseMetaData",
0544: "supportsNamedParameters");
0545: return _data.supportsNamedParameters();
0546: }
0547:
0548: public boolean supportsNonNullableColumns() throws SQLException {
0549: ProxyMethodManager.check("ProxyDatabaseMetaData",
0550: "supportsNonNullableColumns");
0551: return _data.supportsNonNullableColumns();
0552: }
0553:
0554: public boolean supportsOpenCursorsAcrossCommit()
0555: throws SQLException {
0556: ProxyMethodManager.check("ProxyDatabaseMetaData",
0557: "supportsOpenCursorsAcrossCommit");
0558: return _data.supportsOpenCursorsAcrossCommit();
0559: }
0560:
0561: public boolean supportsOpenCursorsAcrossRollback()
0562: throws SQLException {
0563: ProxyMethodManager.check("ProxyDatabaseMetaData",
0564: "supportsOpenCursorsAcrossRollback");
0565: return _data.supportsOpenCursorsAcrossRollback();
0566: }
0567:
0568: public boolean supportsOpenStatementsAcrossCommit()
0569: throws SQLException {
0570: ProxyMethodManager.check("ProxyDatabaseMetaData",
0571: "supportsOpenStatementsAcrossCommit");
0572: return _data.supportsOpenStatementsAcrossCommit();
0573: }
0574:
0575: public boolean supportsOpenStatementsAcrossRollback()
0576: throws SQLException {
0577: ProxyMethodManager.check("ProxyDatabaseMetaData",
0578: "supportsOpenStatementsAcrossRollback");
0579: return _data.supportsOpenStatementsAcrossRollback();
0580: }
0581:
0582: public boolean supportsOrderByUnrelated() throws SQLException {
0583: ProxyMethodManager.check("ProxyDatabaseMetaData",
0584: "supportsOrderByUnrelated");
0585: return _data.supportsOrderByUnrelated();
0586: }
0587:
0588: public boolean supportsOuterJoins() throws SQLException {
0589: ProxyMethodManager.check("ProxyDatabaseMetaData",
0590: "supportsOuterJoins");
0591: return _data.supportsOuterJoins();
0592: }
0593:
0594: public boolean supportsPositionedDelete() throws SQLException {
0595: ProxyMethodManager.check("ProxyDatabaseMetaData",
0596: "supportsPositionedDelete");
0597: return _data.supportsPositionedDelete();
0598: }
0599:
0600: public boolean supportsPositionedUpdate() throws SQLException {
0601: ProxyMethodManager.check("ProxyDatabaseMetaData",
0602: "supportsPositionedUpdate");
0603: return _data.supportsPositionedUpdate();
0604: }
0605:
0606: public boolean supportsSavepoints() throws SQLException {
0607: ProxyMethodManager.check("ProxyDatabaseMetaData",
0608: "supportsSavepoints");
0609: return _data.supportsSavepoints();
0610: }
0611:
0612: public boolean supportsSchemasInDataManipulation()
0613: throws SQLException {
0614: ProxyMethodManager.check("ProxyDatabaseMetaData",
0615: "supportsSchemasInDataManipulation");
0616: return _data.supportsSchemasInDataManipulation();
0617: }
0618:
0619: public boolean supportsSchemasInIndexDefinitions()
0620: throws SQLException {
0621: ProxyMethodManager.check("ProxyDatabaseMetaData",
0622: "supportsSchemasInIndexDefinitions");
0623: return _data.supportsSchemasInIndexDefinitions();
0624: }
0625:
0626: public boolean supportsSchemasInPrivilegeDefinitions()
0627: throws SQLException {
0628: ProxyMethodManager.check("ProxyDatabaseMetaData",
0629: "supportsSchemasInPrivilegeDefinitions");
0630: return _data.supportsSchemasInPrivilegeDefinitions();
0631: }
0632:
0633: public boolean supportsSchemasInProcedureCalls()
0634: throws SQLException {
0635: ProxyMethodManager.check("ProxyDatabaseMetaData",
0636: "supportsSchemasInProcedureCalls");
0637: return _data.supportsSchemasInProcedureCalls();
0638: }
0639:
0640: public boolean supportsSchemasInTableDefinitions()
0641: throws SQLException {
0642: ProxyMethodManager.check("ProxyDatabaseMetaData",
0643: "supportsSchemasInTableDefinitions");
0644: return _data.supportsSchemasInTableDefinitions();
0645: }
0646:
0647: public boolean supportsSelectForUpdate() throws SQLException {
0648: ProxyMethodManager.check("ProxyDatabaseMetaData",
0649: "supportsSelectForUpdate");
0650: return _data.supportsSelectForUpdate();
0651: }
0652:
0653: public boolean supportsStatementPooling() throws SQLException {
0654: ProxyMethodManager.check("ProxyDatabaseMetaData",
0655: "supportsStatementPooling");
0656: return _data.supportsStatementPooling();
0657: }
0658:
0659: public boolean supportsStoredProcedures() throws SQLException {
0660: ProxyMethodManager.check("ProxyDatabaseMetaData",
0661: "supportsStoredProcedures");
0662: return _data.supportsStoredProcedures();
0663: }
0664:
0665: public boolean supportsSubqueriesInComparisons()
0666: throws SQLException {
0667: ProxyMethodManager.check("ProxyDatabaseMetaData",
0668: "supportsSubqueriesInComparisons");
0669: return _data.supportsSubqueriesInComparisons();
0670: }
0671:
0672: public boolean supportsSubqueriesInExists() throws SQLException {
0673: ProxyMethodManager.check("ProxyDatabaseMetaData",
0674: "supportsSubqueriesInExists");
0675: return _data.supportsSubqueriesInExists();
0676: }
0677:
0678: public boolean supportsSubqueriesInIns() throws SQLException {
0679: ProxyMethodManager.check("ProxyDatabaseMetaData",
0680: "supportsSubqueriesInIns");
0681: return _data.supportsSubqueriesInIns();
0682: }
0683:
0684: public boolean supportsSubqueriesInQuantifieds()
0685: throws SQLException {
0686: ProxyMethodManager.check("ProxyDatabaseMetaData",
0687: "supportsSubqueriesInQuantifieds");
0688: return _data.supportsSubqueriesInQuantifieds();
0689: }
0690:
0691: public boolean supportsTableCorrelationNames() throws SQLException {
0692: ProxyMethodManager.check("ProxyDatabaseMetaData",
0693: "supportsTableCorrelationNames");
0694: return _data.supportsTableCorrelationNames();
0695: }
0696:
0697: public boolean supportsTransactions() throws SQLException {
0698: ProxyMethodManager.check("ProxyDatabaseMetaData",
0699: "supportsTransactions");
0700: return _data.supportsTransactions();
0701: }
0702:
0703: public boolean supportsUnion() throws SQLException {
0704: ProxyMethodManager.check("ProxyDatabaseMetaData",
0705: "supportsUnion");
0706: return _data.supportsUnion();
0707: }
0708:
0709: public boolean supportsUnionAll() throws SQLException {
0710: ProxyMethodManager.check("ProxyDatabaseMetaData",
0711: "supportsUnionAll");
0712: return _data.supportsUnionAll();
0713: }
0714:
0715: public boolean usesLocalFilePerTable() throws SQLException {
0716: ProxyMethodManager.check("ProxyDatabaseMetaData",
0717: "usesLocalFilePerTable");
0718: return _data.usesLocalFilePerTable();
0719: }
0720:
0721: public boolean usesLocalFiles() throws SQLException {
0722: ProxyMethodManager.check("ProxyDatabaseMetaData",
0723: "usesLocalFiles");
0724: return _data.usesLocalFiles();
0725: }
0726:
0727: public boolean deletesAreDetected(int type) throws SQLException {
0728: ProxyMethodManager.check("ProxyDatabaseMetaData",
0729: "deletesAreDetected");
0730: return _data.deletesAreDetected(type);
0731: }
0732:
0733: public boolean insertsAreDetected(int type) throws SQLException {
0734: ProxyMethodManager.check("ProxyDatabaseMetaData",
0735: "insertsAreDetected");
0736: return _data.insertsAreDetected(type);
0737: }
0738:
0739: public boolean othersDeletesAreVisible(int type)
0740: throws SQLException {
0741: ProxyMethodManager.check("ProxyDatabaseMetaData",
0742: "othersDeletesAreVisible");
0743: return _data.othersDeletesAreVisible(type);
0744: }
0745:
0746: public boolean othersInsertsAreVisible(int type)
0747: throws SQLException {
0748: ProxyMethodManager.check("ProxyDatabaseMetaData",
0749: "othersInsertsAreVisible");
0750: return _data.othersInsertsAreVisible(type);
0751: }
0752:
0753: public boolean othersUpdatesAreVisible(int type)
0754: throws SQLException {
0755: ProxyMethodManager.check("ProxyDatabaseMetaData",
0756: "othersUpdatesAreVisible");
0757: return _data.othersUpdatesAreVisible(type);
0758: }
0759:
0760: public boolean ownDeletesAreVisible(int type) throws SQLException {
0761: ProxyMethodManager.check("ProxyDatabaseMetaData",
0762: "ownDeletesAreVisible");
0763: return _data.ownDeletesAreVisible(type);
0764: }
0765:
0766: public boolean ownInsertsAreVisible(int type) throws SQLException {
0767: ProxyMethodManager.check("ProxyDatabaseMetaData",
0768: "ownInsertsAreVisible");
0769: return _data.ownInsertsAreVisible(type);
0770: }
0771:
0772: public boolean ownUpdatesAreVisible(int type) throws SQLException {
0773: ProxyMethodManager.check("ProxyDatabaseMetaData",
0774: "ownUpdatesAreVisible");
0775: return _data.ownUpdatesAreVisible(type);
0776: }
0777:
0778: public boolean supportsResultSetHoldability(int holdability)
0779: throws SQLException {
0780: ProxyMethodManager.check("ProxyDatabaseMetaData",
0781: "supportsResultSetHoldability");
0782: return _data.supportsResultSetHoldability(holdability);
0783: }
0784:
0785: public boolean supportsResultSetType(int type) throws SQLException {
0786: ProxyMethodManager.check("ProxyDatabaseMetaData",
0787: "supportsResultSetType");
0788: return _data.supportsResultSetType(type);
0789: }
0790:
0791: public boolean supportsTransactionIsolationLevel(int level)
0792: throws SQLException {
0793: ProxyMethodManager.check("ProxyDatabaseMetaData",
0794: "supportsTransactionIsolationLevel");
0795: return _data.supportsTransactionIsolationLevel(level);
0796: }
0797:
0798: public boolean updatesAreDetected(int type) throws SQLException {
0799: ProxyMethodManager.check("ProxyDatabaseMetaData",
0800: "updatesAreDetected");
0801: return _data.updatesAreDetected(type);
0802: }
0803:
0804: public boolean supportsConvert(int fromType, int toType)
0805: throws SQLException {
0806: ProxyMethodManager.check("ProxyDatabaseMetaData",
0807: "supportsConvert");
0808: return _data.supportsConvert(fromType, toType);
0809: }
0810:
0811: public boolean supportsResultSetConcurrency(int type,
0812: int concurrency) throws SQLException {
0813: ProxyMethodManager.check("ProxyDatabaseMetaData",
0814: "supportsResultSetConcurrency");
0815: return _data.supportsResultSetConcurrency(type, concurrency);
0816: }
0817:
0818: public String getCatalogSeparator() throws SQLException {
0819: ProxyMethodManager.check("ProxyDatabaseMetaData",
0820: "getCatalogSeparator");
0821: return _data.getCatalogSeparator();
0822: }
0823:
0824: public String getCatalogTerm() throws SQLException {
0825: ProxyMethodManager.check("ProxyDatabaseMetaData",
0826: "getCatalogTerm");
0827: return _data.getCatalogTerm();
0828:
0829: }
0830:
0831: public String getDatabaseProductName() throws SQLException {
0832: ProxyMethodManager.check("ProxyDatabaseMetaData",
0833: "getDatabaseProductName");
0834: return _data.getDatabaseProductName();
0835: }
0836:
0837: public String getDatabaseProductVersion() throws SQLException {
0838: ProxyMethodManager.check("ProxyDatabaseMetaData",
0839: "getDatabaseProductVersion");
0840: return _data.getDatabaseProductVersion();
0841: }
0842:
0843: public String getDriverName() throws SQLException {
0844: ProxyMethodManager.check("ProxyDatabaseMetaData",
0845: "getDriverName");
0846: return _data.getDriverName();
0847: }
0848:
0849: public String getDriverVersion() throws SQLException {
0850: ProxyMethodManager.check("ProxyDatabaseMetaData",
0851: "getDriverVersion");
0852: return _data.getDriverVersion();
0853: }
0854:
0855: public String getExtraNameCharacters() throws SQLException {
0856: ProxyMethodManager.check("ProxyDatabaseMetaData",
0857: "getExtraNameCharacters");
0858: return _data.getExtraNameCharacters();
0859: }
0860:
0861: public String getIdentifierQuoteString() throws SQLException {
0862: ProxyMethodManager.check("ProxyDatabaseMetaData",
0863: "getIdentifierQuoteString");
0864: return _data.getIdentifierQuoteString();
0865: }
0866:
0867: public String getNumericFunctions() throws SQLException {
0868: ProxyMethodManager.check("ProxyDatabaseMetaData",
0869: "getNumericFunctions");
0870: return _data.getNumericFunctions();
0871: }
0872:
0873: public String getProcedureTerm() throws SQLException {
0874: ProxyMethodManager.check("ProxyDatabaseMetaData",
0875: "getProcedureTerm");
0876: return _data.getProcedureTerm();
0877: }
0878:
0879: public String getSQLKeywords() throws SQLException {
0880: ProxyMethodManager.check("ProxyDatabaseMetaData",
0881: "getSQLKeywords");
0882: return _data.getSQLKeywords();
0883: }
0884:
0885: public String getSchemaTerm() throws SQLException {
0886: ProxyMethodManager.check("ProxyDatabaseMetaData",
0887: "getSchemaTerm");
0888: return _data.getSchemaTerm();
0889: }
0890:
0891: public String getSearchStringEscape() throws SQLException {
0892: ProxyMethodManager.check("ProxyDatabaseMetaData",
0893: "getSearchStringEscape");
0894: return _data.getSearchStringEscape();
0895: }
0896:
0897: public String getStringFunctions() throws SQLException {
0898: ProxyMethodManager.check("ProxyDatabaseMetaData",
0899: "getStringFunctions");
0900: return _data.getStringFunctions();
0901: }
0902:
0903: public String getSystemFunctions() throws SQLException {
0904: ProxyMethodManager.check("ProxyDatabaseMetaData",
0905: "getSystemFunctions");
0906: return _data.getSystemFunctions();
0907: }
0908:
0909: public String getTimeDateFunctions() throws SQLException {
0910: ProxyMethodManager.check("ProxyDatabaseMetaData",
0911: "getTimeDateFunctions");
0912: return _data.getTimeDateFunctions();
0913: }
0914:
0915: public String getURL() throws SQLException {
0916: ProxyMethodManager.check("ProxyDatabaseMetaData", "getURL");
0917: return _data.getURL();
0918: }
0919:
0920: public String getUserName() throws SQLException {
0921: ProxyMethodManager
0922: .check("ProxyDatabaseMetaData", "getUserName");
0923: return _data.getUserName();
0924: }
0925:
0926: public Connection getConnection() throws SQLException {
0927: ProxyMethodManager.check("ProxyDatabaseMetaData",
0928: "getConnection");
0929: return _data.getConnection();
0930: }
0931:
0932: public ResultSet getCatalogs() throws SQLException {
0933: ProxyMethodManager
0934: .check("ProxyDatabaseMetaData", "getCatalogs");
0935: return _data.getCatalogs();
0936: }
0937:
0938: public ResultSet getSchemas() throws SQLException {
0939: ProxyMethodManager.check("ProxyDatabaseMetaData", "getSchemas");
0940: return _data.getSchemas();
0941: }
0942:
0943: public ResultSet getTableTypes() throws SQLException {
0944: ProxyMethodManager.check("ProxyDatabaseMetaData",
0945: "getTableTypes");
0946: return _data.getTableTypes();
0947: }
0948:
0949: public ResultSet getTypeInfo() throws SQLException {
0950: ProxyMethodManager
0951: .check("ProxyDatabaseMetaData", "getTypeInfo");
0952: return _data.getTypeInfo();
0953: }
0954:
0955: public ResultSet getExportedKeys(String catalog, String schema,
0956: String table) throws SQLException {
0957: ProxyMethodManager.check("ProxyDatabaseMetaData",
0958: "getExportedKeys");
0959: return _data.getExportedKeys(catalog, schema, table);
0960: }
0961:
0962: public ResultSet getImportedKeys(String catalog, String schema,
0963: String table) throws SQLException {
0964: ProxyMethodManager.check("ProxyDatabaseMetaData",
0965: "getImportedKeys");
0966: return _data.getImportedKeys(catalog, schema, table);
0967: }
0968:
0969: public ResultSet getPrimaryKeys(String catalog, String schema,
0970: String table) throws SQLException {
0971: ProxyMethodManager.check("ProxyDatabaseMetaData",
0972: "getPrimaryKeys");
0973: return _data.getPrimaryKeys(catalog, schema, table);
0974: }
0975:
0976: public ResultSet getProcedures(String catalog,
0977: String schemaPattern, String procedureNamePattern)
0978: throws SQLException {
0979: ProxyMethodManager.check("ProxyDatabaseMetaData",
0980: "getProcedures");
0981: return _data.getProcedures(catalog, schemaPattern,
0982: procedureNamePattern);
0983: }
0984:
0985: public ResultSet getSuperTables(String catalog,
0986: String schemaPattern, String tableNamePattern)
0987: throws SQLException {
0988: ProxyMethodManager.check("ProxyDatabaseMetaData",
0989: "getSuperTables");
0990: return _data.getSuperTables(catalog, schemaPattern,
0991: tableNamePattern);
0992: }
0993:
0994: public ResultSet getSuperTypes(String catalog,
0995: String schemaPattern, String typeNamePattern)
0996: throws SQLException {
0997: ProxyMethodManager.check("ProxyDatabaseMetaData",
0998: "getSuperTypes");
0999: return _data.getSuperTypes(catalog, schemaPattern,
1000: typeNamePattern);
1001: }
1002:
1003: public ResultSet getTablePrivileges(String catalog,
1004: String schemaPattern, String tableNamePattern)
1005: throws SQLException {
1006: ProxyMethodManager.check("ProxyDatabaseMetaData",
1007: "getTablePrivileges");
1008: return _data.getTablePrivileges(catalog, schemaPattern,
1009: tableNamePattern);
1010: }
1011:
1012: public ResultSet getVersionColumns(String catalog, String schema,
1013: String table) throws SQLException {
1014: ProxyMethodManager.check("ProxyDatabaseMetaData",
1015: "getVersionColumns");
1016: return _data.getVersionColumns(catalog, schema, table);
1017: }
1018:
1019: public ResultSet getBestRowIdentifier(String catalog,
1020: String schema, String table, int scope, boolean nullable)
1021: throws SQLException {
1022: ProxyMethodManager.check("ProxyDatabaseMetaData",
1023: "getBestRowIdentifier");
1024: return _data.getBestRowIdentifier(catalog, schema, table,
1025: scope, nullable);
1026: }
1027:
1028: public ResultSet getIndexInfo(String catalog, String schema,
1029: String table, boolean unique, boolean approximate)
1030: throws SQLException {
1031: ProxyMethodManager.check("ProxyDatabaseMetaData",
1032: "getIndexInfo");
1033: return _data.getIndexInfo(catalog, schema, table, unique,
1034: approximate);
1035: }
1036:
1037: public ResultSet getUDTs(String catalog, String schemaPattern,
1038: String typeNamePattern, int[] types) throws SQLException {
1039: ProxyMethodManager.check("ProxyDatabaseMetaData", "getUDTs");
1040: return _data.getUDTs(catalog, schemaPattern, typeNamePattern,
1041: types);
1042: }
1043:
1044: public ResultSet getAttributes(String catalog,
1045: String schemaPattern, String typeNamePattern,
1046: String attributeNamePattern) throws SQLException {
1047: ProxyMethodManager.check("ProxyDatabaseMetaData",
1048: "getAttributes");
1049: return _data.getAttributes(catalog, schemaPattern,
1050: typeNamePattern, attributeNamePattern);
1051: }
1052:
1053: public ResultSet getColumnPrivileges(String catalog, String schema,
1054: String table, String columnNamePattern) throws SQLException {
1055: ProxyMethodManager.check("ProxyDatabaseMetaData",
1056: "getColumnPrivileges");
1057: return _data.getColumnPrivileges(catalog, schema, table,
1058: columnNamePattern);
1059:
1060: }
1061:
1062: public ResultSet getColumns(String catalog, String schemaPattern,
1063: String tableNamePattern, String columnNamePattern)
1064: throws SQLException {
1065: ProxyMethodManager.check("ProxyDatabaseMetaData", "getColumns");
1066: return _data.getColumns(catalog, schemaPattern,
1067: tableNamePattern, columnNamePattern);
1068: }
1069:
1070: public ResultSet getProcedureColumns(String catalog,
1071: String schemaPattern, String procedureNamePattern,
1072: String columnNamePattern) throws SQLException {
1073: ProxyMethodManager.check("ProxyDatabaseMetaData",
1074: "getProcedureColumns");
1075: return _data.getProcedureColumns(catalog, schemaPattern,
1076: procedureNamePattern, columnNamePattern);
1077: }
1078:
1079: public ResultSet getTables(String catalog, String schemaPattern,
1080: String tableNamePattern, String[] types)
1081: throws SQLException {
1082: ProxyMethodManager.check("ProxyDatabaseMetaData", "getTables");
1083: return _data.getTables(catalog, schemaPattern,
1084: tableNamePattern, types);
1085: }
1086:
1087: public ResultSet getCrossReference(String primaryCatalog,
1088: String primarySchema, String primaryTable,
1089: String foreignCatalog, String foreignSchema,
1090: String foreignTable) throws SQLException {
1091: ProxyMethodManager.check("ProxyDatabaseMetaData",
1092: "getCrossReference");
1093: return _data.getCrossReference(primaryCatalog, primarySchema,
1094: primaryTable, foreignCatalog, foreignSchema,
1095: foreignTable);
1096: }
1097:
1098: }
|