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