001: /*
002: * Distributed as part of c3p0 v.0.9.1.2
003: *
004: * Copyright (C) 2005 Machinery For Change, Inc.
005: *
006: * Author: Steve Waldman <swaldman@mchange.com>
007: *
008: * This library is free software; you can redistribute it and/or modify
009: * it under the terms of the GNU Lesser General Public License version 2.1, as
010: * published by the Free Software Foundation.
011: *
012: * This software is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
015: * GNU Lesser General Public License for more details.
016: *
017: * You should have received a copy of the GNU Lesser General Public License
018: * along with this software; see the file LICENSE. If not, write to the
019: * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
020: * Boston, MA 02111-1307, USA.
021: */
022:
023: package com.mchange.v2.sql.filter;
024:
025: import java.lang.String;
026: import java.sql.Connection;
027: import java.sql.DatabaseMetaData;
028: import java.sql.ResultSet;
029: import java.sql.SQLException;
030:
031: public abstract class SynchronizedFilterDatabaseMetaData implements
032: DatabaseMetaData {
033: protected DatabaseMetaData inner;
034:
035: public SynchronizedFilterDatabaseMetaData(DatabaseMetaData inner) {
036: this .inner = inner;
037: }
038:
039: public SynchronizedFilterDatabaseMetaData() {
040: }
041:
042: public synchronized void setInner(DatabaseMetaData inner) {
043: this .inner = inner;
044: }
045:
046: public synchronized DatabaseMetaData getInner() {
047: return inner;
048: }
049:
050: public synchronized boolean allProceduresAreCallable()
051: throws SQLException {
052: return inner.allProceduresAreCallable();
053: }
054:
055: public synchronized boolean allTablesAreSelectable()
056: throws SQLException {
057: return inner.allTablesAreSelectable();
058: }
059:
060: public synchronized boolean nullsAreSortedHigh()
061: throws SQLException {
062: return inner.nullsAreSortedHigh();
063: }
064:
065: public synchronized boolean nullsAreSortedLow() throws SQLException {
066: return inner.nullsAreSortedLow();
067: }
068:
069: public synchronized boolean nullsAreSortedAtStart()
070: throws SQLException {
071: return inner.nullsAreSortedAtStart();
072: }
073:
074: public synchronized boolean nullsAreSortedAtEnd()
075: throws SQLException {
076: return inner.nullsAreSortedAtEnd();
077: }
078:
079: public synchronized String getDatabaseProductName()
080: throws SQLException {
081: return inner.getDatabaseProductName();
082: }
083:
084: public synchronized String getDatabaseProductVersion()
085: throws SQLException {
086: return inner.getDatabaseProductVersion();
087: }
088:
089: public synchronized String getDriverName() throws SQLException {
090: return inner.getDriverName();
091: }
092:
093: public synchronized String getDriverVersion() throws SQLException {
094: return inner.getDriverVersion();
095: }
096:
097: public synchronized int getDriverMajorVersion() {
098: return inner.getDriverMajorVersion();
099: }
100:
101: public synchronized int getDriverMinorVersion() {
102: return inner.getDriverMinorVersion();
103: }
104:
105: public synchronized boolean usesLocalFiles() throws SQLException {
106: return inner.usesLocalFiles();
107: }
108:
109: public synchronized boolean usesLocalFilePerTable()
110: throws SQLException {
111: return inner.usesLocalFilePerTable();
112: }
113:
114: public synchronized boolean supportsMixedCaseIdentifiers()
115: throws SQLException {
116: return inner.supportsMixedCaseIdentifiers();
117: }
118:
119: public synchronized boolean storesUpperCaseIdentifiers()
120: throws SQLException {
121: return inner.storesUpperCaseIdentifiers();
122: }
123:
124: public synchronized boolean storesLowerCaseIdentifiers()
125: throws SQLException {
126: return inner.storesLowerCaseIdentifiers();
127: }
128:
129: public synchronized boolean storesMixedCaseIdentifiers()
130: throws SQLException {
131: return inner.storesMixedCaseIdentifiers();
132: }
133:
134: public synchronized boolean supportsMixedCaseQuotedIdentifiers()
135: throws SQLException {
136: return inner.supportsMixedCaseQuotedIdentifiers();
137: }
138:
139: public synchronized boolean storesUpperCaseQuotedIdentifiers()
140: throws SQLException {
141: return inner.storesUpperCaseQuotedIdentifiers();
142: }
143:
144: public synchronized boolean storesLowerCaseQuotedIdentifiers()
145: throws SQLException {
146: return inner.storesLowerCaseQuotedIdentifiers();
147: }
148:
149: public synchronized boolean storesMixedCaseQuotedIdentifiers()
150: throws SQLException {
151: return inner.storesMixedCaseQuotedIdentifiers();
152: }
153:
154: public synchronized String getIdentifierQuoteString()
155: throws SQLException {
156: return inner.getIdentifierQuoteString();
157: }
158:
159: public synchronized String getSQLKeywords() throws SQLException {
160: return inner.getSQLKeywords();
161: }
162:
163: public synchronized String getNumericFunctions()
164: throws SQLException {
165: return inner.getNumericFunctions();
166: }
167:
168: public synchronized String getStringFunctions() throws SQLException {
169: return inner.getStringFunctions();
170: }
171:
172: public synchronized String getSystemFunctions() throws SQLException {
173: return inner.getSystemFunctions();
174: }
175:
176: public synchronized String getTimeDateFunctions()
177: throws SQLException {
178: return inner.getTimeDateFunctions();
179: }
180:
181: public synchronized String getSearchStringEscape()
182: throws SQLException {
183: return inner.getSearchStringEscape();
184: }
185:
186: public synchronized String getExtraNameCharacters()
187: throws SQLException {
188: return inner.getExtraNameCharacters();
189: }
190:
191: public synchronized boolean supportsAlterTableWithAddColumn()
192: throws SQLException {
193: return inner.supportsAlterTableWithAddColumn();
194: }
195:
196: public synchronized boolean supportsAlterTableWithDropColumn()
197: throws SQLException {
198: return inner.supportsAlterTableWithDropColumn();
199: }
200:
201: public synchronized boolean supportsColumnAliasing()
202: throws SQLException {
203: return inner.supportsColumnAliasing();
204: }
205:
206: public synchronized boolean nullPlusNonNullIsNull()
207: throws SQLException {
208: return inner.nullPlusNonNullIsNull();
209: }
210:
211: public synchronized boolean supportsConvert() throws SQLException {
212: return inner.supportsConvert();
213: }
214:
215: public synchronized boolean supportsConvert(int a, int b)
216: throws SQLException {
217: return inner.supportsConvert(a, b);
218: }
219:
220: public synchronized boolean supportsTableCorrelationNames()
221: throws SQLException {
222: return inner.supportsTableCorrelationNames();
223: }
224:
225: public synchronized boolean supportsDifferentTableCorrelationNames()
226: throws SQLException {
227: return inner.supportsDifferentTableCorrelationNames();
228: }
229:
230: public synchronized boolean supportsExpressionsInOrderBy()
231: throws SQLException {
232: return inner.supportsExpressionsInOrderBy();
233: }
234:
235: public synchronized boolean supportsOrderByUnrelated()
236: throws SQLException {
237: return inner.supportsOrderByUnrelated();
238: }
239:
240: public synchronized boolean supportsGroupBy() throws SQLException {
241: return inner.supportsGroupBy();
242: }
243:
244: public synchronized boolean supportsGroupByUnrelated()
245: throws SQLException {
246: return inner.supportsGroupByUnrelated();
247: }
248:
249: public synchronized boolean supportsGroupByBeyondSelect()
250: throws SQLException {
251: return inner.supportsGroupByBeyondSelect();
252: }
253:
254: public synchronized boolean supportsLikeEscapeClause()
255: throws SQLException {
256: return inner.supportsLikeEscapeClause();
257: }
258:
259: public synchronized boolean supportsMultipleResultSets()
260: throws SQLException {
261: return inner.supportsMultipleResultSets();
262: }
263:
264: public synchronized boolean supportsMultipleTransactions()
265: throws SQLException {
266: return inner.supportsMultipleTransactions();
267: }
268:
269: public synchronized boolean supportsNonNullableColumns()
270: throws SQLException {
271: return inner.supportsNonNullableColumns();
272: }
273:
274: public synchronized boolean supportsMinimumSQLGrammar()
275: throws SQLException {
276: return inner.supportsMinimumSQLGrammar();
277: }
278:
279: public synchronized boolean supportsCoreSQLGrammar()
280: throws SQLException {
281: return inner.supportsCoreSQLGrammar();
282: }
283:
284: public synchronized boolean supportsExtendedSQLGrammar()
285: throws SQLException {
286: return inner.supportsExtendedSQLGrammar();
287: }
288:
289: public synchronized boolean supportsANSI92EntryLevelSQL()
290: throws SQLException {
291: return inner.supportsANSI92EntryLevelSQL();
292: }
293:
294: public synchronized boolean supportsANSI92IntermediateSQL()
295: throws SQLException {
296: return inner.supportsANSI92IntermediateSQL();
297: }
298:
299: public synchronized boolean supportsANSI92FullSQL()
300: throws SQLException {
301: return inner.supportsANSI92FullSQL();
302: }
303:
304: public synchronized boolean supportsIntegrityEnhancementFacility()
305: throws SQLException {
306: return inner.supportsIntegrityEnhancementFacility();
307: }
308:
309: public synchronized boolean supportsOuterJoins()
310: throws SQLException {
311: return inner.supportsOuterJoins();
312: }
313:
314: public synchronized boolean supportsFullOuterJoins()
315: throws SQLException {
316: return inner.supportsFullOuterJoins();
317: }
318:
319: public synchronized boolean supportsLimitedOuterJoins()
320: throws SQLException {
321: return inner.supportsLimitedOuterJoins();
322: }
323:
324: public synchronized String getSchemaTerm() throws SQLException {
325: return inner.getSchemaTerm();
326: }
327:
328: public synchronized String getProcedureTerm() throws SQLException {
329: return inner.getProcedureTerm();
330: }
331:
332: public synchronized String getCatalogTerm() throws SQLException {
333: return inner.getCatalogTerm();
334: }
335:
336: public synchronized boolean isCatalogAtStart() throws SQLException {
337: return inner.isCatalogAtStart();
338: }
339:
340: public synchronized String getCatalogSeparator()
341: throws SQLException {
342: return inner.getCatalogSeparator();
343: }
344:
345: public synchronized boolean supportsSchemasInDataManipulation()
346: throws SQLException {
347: return inner.supportsSchemasInDataManipulation();
348: }
349:
350: public synchronized boolean supportsSchemasInProcedureCalls()
351: throws SQLException {
352: return inner.supportsSchemasInProcedureCalls();
353: }
354:
355: public synchronized boolean supportsSchemasInTableDefinitions()
356: throws SQLException {
357: return inner.supportsSchemasInTableDefinitions();
358: }
359:
360: public synchronized boolean supportsSchemasInIndexDefinitions()
361: throws SQLException {
362: return inner.supportsSchemasInIndexDefinitions();
363: }
364:
365: public synchronized boolean supportsSchemasInPrivilegeDefinitions()
366: throws SQLException {
367: return inner.supportsSchemasInPrivilegeDefinitions();
368: }
369:
370: public synchronized boolean supportsCatalogsInDataManipulation()
371: throws SQLException {
372: return inner.supportsCatalogsInDataManipulation();
373: }
374:
375: public synchronized boolean supportsCatalogsInProcedureCalls()
376: throws SQLException {
377: return inner.supportsCatalogsInProcedureCalls();
378: }
379:
380: public synchronized boolean supportsCatalogsInTableDefinitions()
381: throws SQLException {
382: return inner.supportsCatalogsInTableDefinitions();
383: }
384:
385: public synchronized boolean supportsCatalogsInIndexDefinitions()
386: throws SQLException {
387: return inner.supportsCatalogsInIndexDefinitions();
388: }
389:
390: public synchronized boolean supportsCatalogsInPrivilegeDefinitions()
391: throws SQLException {
392: return inner.supportsCatalogsInPrivilegeDefinitions();
393: }
394:
395: public synchronized boolean supportsPositionedDelete()
396: throws SQLException {
397: return inner.supportsPositionedDelete();
398: }
399:
400: public synchronized boolean supportsPositionedUpdate()
401: throws SQLException {
402: return inner.supportsPositionedUpdate();
403: }
404:
405: public synchronized boolean supportsSelectForUpdate()
406: throws SQLException {
407: return inner.supportsSelectForUpdate();
408: }
409:
410: public synchronized boolean supportsStoredProcedures()
411: throws SQLException {
412: return inner.supportsStoredProcedures();
413: }
414:
415: public synchronized boolean supportsSubqueriesInComparisons()
416: throws SQLException {
417: return inner.supportsSubqueriesInComparisons();
418: }
419:
420: public synchronized boolean supportsSubqueriesInExists()
421: throws SQLException {
422: return inner.supportsSubqueriesInExists();
423: }
424:
425: public synchronized boolean supportsSubqueriesInIns()
426: throws SQLException {
427: return inner.supportsSubqueriesInIns();
428: }
429:
430: public synchronized boolean supportsSubqueriesInQuantifieds()
431: throws SQLException {
432: return inner.supportsSubqueriesInQuantifieds();
433: }
434:
435: public synchronized boolean supportsCorrelatedSubqueries()
436: throws SQLException {
437: return inner.supportsCorrelatedSubqueries();
438: }
439:
440: public synchronized boolean supportsUnion() throws SQLException {
441: return inner.supportsUnion();
442: }
443:
444: public synchronized boolean supportsUnionAll() throws SQLException {
445: return inner.supportsUnionAll();
446: }
447:
448: public synchronized boolean supportsOpenCursorsAcrossCommit()
449: throws SQLException {
450: return inner.supportsOpenCursorsAcrossCommit();
451: }
452:
453: public synchronized boolean supportsOpenCursorsAcrossRollback()
454: throws SQLException {
455: return inner.supportsOpenCursorsAcrossRollback();
456: }
457:
458: public synchronized boolean supportsOpenStatementsAcrossCommit()
459: throws SQLException {
460: return inner.supportsOpenStatementsAcrossCommit();
461: }
462:
463: public synchronized boolean supportsOpenStatementsAcrossRollback()
464: throws SQLException {
465: return inner.supportsOpenStatementsAcrossRollback();
466: }
467:
468: public synchronized int getMaxBinaryLiteralLength()
469: throws SQLException {
470: return inner.getMaxBinaryLiteralLength();
471: }
472:
473: public synchronized int getMaxCharLiteralLength()
474: throws SQLException {
475: return inner.getMaxCharLiteralLength();
476: }
477:
478: public synchronized int getMaxColumnNameLength()
479: throws SQLException {
480: return inner.getMaxColumnNameLength();
481: }
482:
483: public synchronized int getMaxColumnsInGroupBy()
484: throws SQLException {
485: return inner.getMaxColumnsInGroupBy();
486: }
487:
488: public synchronized int getMaxColumnsInIndex() throws SQLException {
489: return inner.getMaxColumnsInIndex();
490: }
491:
492: public synchronized int getMaxColumnsInOrderBy()
493: throws SQLException {
494: return inner.getMaxColumnsInOrderBy();
495: }
496:
497: public synchronized int getMaxColumnsInSelect() throws SQLException {
498: return inner.getMaxColumnsInSelect();
499: }
500:
501: public synchronized int getMaxColumnsInTable() throws SQLException {
502: return inner.getMaxColumnsInTable();
503: }
504:
505: public synchronized int getMaxConnections() throws SQLException {
506: return inner.getMaxConnections();
507: }
508:
509: public synchronized int getMaxCursorNameLength()
510: throws SQLException {
511: return inner.getMaxCursorNameLength();
512: }
513:
514: public synchronized int getMaxIndexLength() throws SQLException {
515: return inner.getMaxIndexLength();
516: }
517:
518: public synchronized int getMaxSchemaNameLength()
519: throws SQLException {
520: return inner.getMaxSchemaNameLength();
521: }
522:
523: public synchronized int getMaxProcedureNameLength()
524: throws SQLException {
525: return inner.getMaxProcedureNameLength();
526: }
527:
528: public synchronized int getMaxCatalogNameLength()
529: throws SQLException {
530: return inner.getMaxCatalogNameLength();
531: }
532:
533: public synchronized int getMaxRowSize() throws SQLException {
534: return inner.getMaxRowSize();
535: }
536:
537: public synchronized boolean doesMaxRowSizeIncludeBlobs()
538: throws SQLException {
539: return inner.doesMaxRowSizeIncludeBlobs();
540: }
541:
542: public synchronized int getMaxStatementLength() throws SQLException {
543: return inner.getMaxStatementLength();
544: }
545:
546: public synchronized int getMaxStatements() throws SQLException {
547: return inner.getMaxStatements();
548: }
549:
550: public synchronized int getMaxTableNameLength() throws SQLException {
551: return inner.getMaxTableNameLength();
552: }
553:
554: public synchronized int getMaxTablesInSelect() throws SQLException {
555: return inner.getMaxTablesInSelect();
556: }
557:
558: public synchronized int getMaxUserNameLength() throws SQLException {
559: return inner.getMaxUserNameLength();
560: }
561:
562: public synchronized int getDefaultTransactionIsolation()
563: throws SQLException {
564: return inner.getDefaultTransactionIsolation();
565: }
566:
567: public synchronized boolean supportsTransactions()
568: throws SQLException {
569: return inner.supportsTransactions();
570: }
571:
572: public synchronized boolean supportsTransactionIsolationLevel(int a)
573: throws SQLException {
574: return inner.supportsTransactionIsolationLevel(a);
575: }
576:
577: public synchronized boolean supportsDataDefinitionAndDataManipulationTransactions()
578: throws SQLException {
579: return inner
580: .supportsDataDefinitionAndDataManipulationTransactions();
581: }
582:
583: public synchronized boolean supportsDataManipulationTransactionsOnly()
584: throws SQLException {
585: return inner.supportsDataManipulationTransactionsOnly();
586: }
587:
588: public synchronized boolean dataDefinitionCausesTransactionCommit()
589: throws SQLException {
590: return inner.dataDefinitionCausesTransactionCommit();
591: }
592:
593: public synchronized boolean dataDefinitionIgnoredInTransactions()
594: throws SQLException {
595: return inner.dataDefinitionIgnoredInTransactions();
596: }
597:
598: public synchronized ResultSet getProcedures(String a, String b,
599: String c) throws SQLException {
600: return inner.getProcedures(a, b, c);
601: }
602:
603: public synchronized ResultSet getProcedureColumns(String a,
604: String b, String c, String d) throws SQLException {
605: return inner.getProcedureColumns(a, b, c, d);
606: }
607:
608: public synchronized ResultSet getTables(String a, String b,
609: String c, String[] d) throws SQLException {
610: return inner.getTables(a, b, c, d);
611: }
612:
613: public synchronized ResultSet getSchemas() throws SQLException {
614: return inner.getSchemas();
615: }
616:
617: public synchronized ResultSet getCatalogs() throws SQLException {
618: return inner.getCatalogs();
619: }
620:
621: public synchronized ResultSet getTableTypes() throws SQLException {
622: return inner.getTableTypes();
623: }
624:
625: public synchronized ResultSet getColumnPrivileges(String a,
626: String b, String c, String d) throws SQLException {
627: return inner.getColumnPrivileges(a, b, c, d);
628: }
629:
630: public synchronized ResultSet getTablePrivileges(String a,
631: String b, String c) throws SQLException {
632: return inner.getTablePrivileges(a, b, c);
633: }
634:
635: public synchronized ResultSet getBestRowIdentifier(String a,
636: String b, String c, int d, boolean e) throws SQLException {
637: return inner.getBestRowIdentifier(a, b, c, d, e);
638: }
639:
640: public synchronized ResultSet getVersionColumns(String a, String b,
641: String c) throws SQLException {
642: return inner.getVersionColumns(a, b, c);
643: }
644:
645: public synchronized ResultSet getPrimaryKeys(String a, String b,
646: String c) throws SQLException {
647: return inner.getPrimaryKeys(a, b, c);
648: }
649:
650: public synchronized ResultSet getImportedKeys(String a, String b,
651: String c) throws SQLException {
652: return inner.getImportedKeys(a, b, c);
653: }
654:
655: public synchronized ResultSet getExportedKeys(String a, String b,
656: String c) throws SQLException {
657: return inner.getExportedKeys(a, b, c);
658: }
659:
660: public synchronized ResultSet getCrossReference(String a, String b,
661: String c, String d, String e, String f) throws SQLException {
662: return inner.getCrossReference(a, b, c, d, e, f);
663: }
664:
665: public synchronized ResultSet getTypeInfo() throws SQLException {
666: return inner.getTypeInfo();
667: }
668:
669: public synchronized ResultSet getIndexInfo(String a, String b,
670: String c, boolean d, boolean e) throws SQLException {
671: return inner.getIndexInfo(a, b, c, d, e);
672: }
673:
674: public synchronized boolean supportsResultSetType(int a)
675: throws SQLException {
676: return inner.supportsResultSetType(a);
677: }
678:
679: public synchronized boolean supportsResultSetConcurrency(int a,
680: int b) throws SQLException {
681: return inner.supportsResultSetConcurrency(a, b);
682: }
683:
684: public synchronized boolean ownUpdatesAreVisible(int a)
685: throws SQLException {
686: return inner.ownUpdatesAreVisible(a);
687: }
688:
689: public synchronized boolean ownDeletesAreVisible(int a)
690: throws SQLException {
691: return inner.ownDeletesAreVisible(a);
692: }
693:
694: public synchronized boolean ownInsertsAreVisible(int a)
695: throws SQLException {
696: return inner.ownInsertsAreVisible(a);
697: }
698:
699: public synchronized boolean othersUpdatesAreVisible(int a)
700: throws SQLException {
701: return inner.othersUpdatesAreVisible(a);
702: }
703:
704: public synchronized boolean othersDeletesAreVisible(int a)
705: throws SQLException {
706: return inner.othersDeletesAreVisible(a);
707: }
708:
709: public synchronized boolean othersInsertsAreVisible(int a)
710: throws SQLException {
711: return inner.othersInsertsAreVisible(a);
712: }
713:
714: public synchronized boolean updatesAreDetected(int a)
715: throws SQLException {
716: return inner.updatesAreDetected(a);
717: }
718:
719: public synchronized boolean deletesAreDetected(int a)
720: throws SQLException {
721: return inner.deletesAreDetected(a);
722: }
723:
724: public synchronized boolean insertsAreDetected(int a)
725: throws SQLException {
726: return inner.insertsAreDetected(a);
727: }
728:
729: public synchronized boolean supportsBatchUpdates()
730: throws SQLException {
731: return inner.supportsBatchUpdates();
732: }
733:
734: public synchronized ResultSet getUDTs(String a, String b, String c,
735: int[] d) throws SQLException {
736: return inner.getUDTs(a, b, c, d);
737: }
738:
739: public synchronized boolean supportsSavepoints()
740: throws SQLException {
741: return inner.supportsSavepoints();
742: }
743:
744: public synchronized boolean supportsNamedParameters()
745: throws SQLException {
746: return inner.supportsNamedParameters();
747: }
748:
749: public synchronized boolean supportsMultipleOpenResults()
750: throws SQLException {
751: return inner.supportsMultipleOpenResults();
752: }
753:
754: public synchronized boolean supportsGetGeneratedKeys()
755: throws SQLException {
756: return inner.supportsGetGeneratedKeys();
757: }
758:
759: public synchronized ResultSet getSuperTypes(String a, String b,
760: String c) throws SQLException {
761: return inner.getSuperTypes(a, b, c);
762: }
763:
764: public synchronized ResultSet getSuperTables(String a, String b,
765: String c) throws SQLException {
766: return inner.getSuperTables(a, b, c);
767: }
768:
769: public synchronized boolean supportsResultSetHoldability(int a)
770: throws SQLException {
771: return inner.supportsResultSetHoldability(a);
772: }
773:
774: public synchronized int getResultSetHoldability()
775: throws SQLException {
776: return inner.getResultSetHoldability();
777: }
778:
779: public synchronized int getDatabaseMajorVersion()
780: throws SQLException {
781: return inner.getDatabaseMajorVersion();
782: }
783:
784: public synchronized int getDatabaseMinorVersion()
785: throws SQLException {
786: return inner.getDatabaseMinorVersion();
787: }
788:
789: public synchronized int getJDBCMajorVersion() throws SQLException {
790: return inner.getJDBCMajorVersion();
791: }
792:
793: public synchronized int getJDBCMinorVersion() throws SQLException {
794: return inner.getJDBCMinorVersion();
795: }
796:
797: public synchronized int getSQLStateType() throws SQLException {
798: return inner.getSQLStateType();
799: }
800:
801: public synchronized boolean locatorsUpdateCopy()
802: throws SQLException {
803: return inner.locatorsUpdateCopy();
804: }
805:
806: public synchronized boolean supportsStatementPooling()
807: throws SQLException {
808: return inner.supportsStatementPooling();
809: }
810:
811: public synchronized String getURL() throws SQLException {
812: return inner.getURL();
813: }
814:
815: public synchronized boolean isReadOnly() throws SQLException {
816: return inner.isReadOnly();
817: }
818:
819: public synchronized ResultSet getAttributes(String a, String b,
820: String c, String d) throws SQLException {
821: return inner.getAttributes(a, b, c, d);
822: }
823:
824: public synchronized Connection getConnection() throws SQLException {
825: return inner.getConnection();
826: }
827:
828: public synchronized ResultSet getColumns(String a, String b,
829: String c, String d) throws SQLException {
830: return inner.getColumns(a, b, c, d);
831: }
832:
833: public synchronized String getUserName() throws SQLException {
834: return inner.getUserName();
835: }
836: }
|