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