1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.dbcp2;
18
19 import java.sql.Connection;
20 import java.sql.DatabaseMetaData;
21 import java.sql.ResultSet;
22 import java.sql.RowIdLifetime;
23 import java.sql.SQLException;
24 import java.util.Objects;
25
26
27
28
29
30
31
32
33
34
35
36
37 public class DelegatingDatabaseMetaData implements DatabaseMetaData {
38
39
40 private final DatabaseMetaData databaseMetaData;
41
42
43 private final DelegatingConnection<?> connection;
44
45
46
47
48
49
50
51
52
53 public DelegatingDatabaseMetaData(final DelegatingConnection<?> connection,
54 final DatabaseMetaData databaseMetaData) {
55 this.connection = Objects.requireNonNull(connection, "connection");
56 this.databaseMetaData = Objects.requireNonNull(databaseMetaData, "databaseMetaData");
57 }
58
59 @Override
60 public boolean allProceduresAreCallable() throws SQLException {
61 try {
62 return databaseMetaData.allProceduresAreCallable();
63 } catch (final SQLException e) {
64 handleException(e);
65 return false;
66 }
67 }
68
69 @Override
70 public boolean allTablesAreSelectable() throws SQLException {
71 try {
72 return databaseMetaData.allTablesAreSelectable();
73 } catch (final SQLException e) {
74 handleException(e);
75 return false;
76 }
77 }
78
79 @Override
80 public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
81 try {
82 return databaseMetaData.autoCommitFailureClosesAllResultSets();
83 } catch (final SQLException e) {
84 handleException(e);
85 return false;
86 }
87 }
88
89 @Override
90 public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
91 try {
92 return databaseMetaData.dataDefinitionCausesTransactionCommit();
93 } catch (final SQLException e) {
94 handleException(e);
95 return false;
96 }
97 }
98
99 @Override
100 public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
101 try {
102 return databaseMetaData.dataDefinitionIgnoredInTransactions();
103 } catch (final SQLException e) {
104 handleException(e);
105 return false;
106 }
107 }
108
109 @Override
110 public boolean deletesAreDetected(final int type) throws SQLException {
111 try {
112 return databaseMetaData.deletesAreDetected(type);
113 } catch (final SQLException e) {
114 handleException(e);
115 return false;
116 }
117 }
118
119 @Override
120 public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
121 try {
122 return databaseMetaData.doesMaxRowSizeIncludeBlobs();
123 } catch (final SQLException e) {
124 handleException(e);
125 return false;
126 }
127 }
128
129 @Override
130 public boolean generatedKeyAlwaysReturned() throws SQLException {
131 connection.checkOpen();
132 try {
133 return Jdbc41Bridge.generatedKeyAlwaysReturned(databaseMetaData);
134 } catch (final SQLException e) {
135 handleException(e);
136 return false;
137 }
138 }
139
140 @Override
141 public ResultSet getAttributes(final String catalog, final String schemaPattern, final String typeNamePattern,
142 final String attributeNamePattern) throws SQLException {
143 connection.checkOpen();
144 try {
145 return DelegatingResultSet.wrapResultSet(connection,
146 databaseMetaData.getAttributes(catalog, schemaPattern, typeNamePattern, attributeNamePattern));
147 } catch (final SQLException e) {
148 handleException(e);
149 throw new AssertionError();
150 }
151 }
152
153 @Override
154 public ResultSet getBestRowIdentifier(final String catalog, final String schema, final String table,
155 final int scope, final boolean nullable) throws SQLException {
156 connection.checkOpen();
157 try {
158 return DelegatingResultSet.wrapResultSet(connection,
159 databaseMetaData.getBestRowIdentifier(catalog, schema, table, scope, nullable));
160 } catch (final SQLException e) {
161 handleException(e);
162 throw new AssertionError();
163 }
164 }
165
166 @Override
167 public ResultSet getCatalogs() throws SQLException {
168 connection.checkOpen();
169 try {
170 return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getCatalogs());
171 } catch (final SQLException e) {
172 handleException(e);
173 throw new AssertionError();
174 }
175 }
176
177 @Override
178 public String getCatalogSeparator() throws SQLException {
179 try {
180 return databaseMetaData.getCatalogSeparator();
181 } catch (final SQLException e) {
182 handleException(e);
183 throw new AssertionError();
184 }
185 }
186
187 @Override
188 public String getCatalogTerm() throws SQLException {
189 try {
190 return databaseMetaData.getCatalogTerm();
191 } catch (final SQLException e) {
192 handleException(e);
193 throw new AssertionError();
194 }
195 }
196
197 @Override
198 public ResultSet getClientInfoProperties() throws SQLException {
199 connection.checkOpen();
200 try {
201 return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getClientInfoProperties());
202 } catch (final SQLException e) {
203 handleException(e);
204 throw new AssertionError();
205 }
206 }
207
208 @Override
209 public ResultSet getColumnPrivileges(final String catalog, final String schema, final String table,
210 final String columnNamePattern) throws SQLException {
211 connection.checkOpen();
212 try {
213 return DelegatingResultSet.wrapResultSet(connection,
214 databaseMetaData.getColumnPrivileges(catalog, schema, table, columnNamePattern));
215 } catch (final SQLException e) {
216 handleException(e);
217 throw new AssertionError();
218 }
219 }
220
221 @Override
222 public ResultSet getColumns(final String catalog, final String schemaPattern, final String tableNamePattern,
223 final String columnNamePattern) throws SQLException {
224 connection.checkOpen();
225 try {
226 return DelegatingResultSet.wrapResultSet(connection,
227 databaseMetaData.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern));
228 } catch (final SQLException e) {
229 handleException(e);
230 throw new AssertionError();
231 }
232 }
233
234 @Override
235 public Connection getConnection() throws SQLException {
236 return connection;
237 }
238
239 @Override
240 public ResultSet getCrossReference(final String parentCatalog, final String parentSchema, final String parentTable,
241 final String foreignCatalog, final String foreignSchema, final String foreignTable) throws SQLException {
242 connection.checkOpen();
243 try {
244 return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getCrossReference(parentCatalog,
245 parentSchema, parentTable, foreignCatalog, foreignSchema, foreignTable));
246 } catch (final SQLException e) {
247 handleException(e);
248 throw new AssertionError();
249 }
250 }
251
252 @Override
253 public int getDatabaseMajorVersion() throws SQLException {
254 try {
255 return databaseMetaData.getDatabaseMajorVersion();
256 } catch (final SQLException e) {
257 handleException(e);
258 return 0;
259 }
260 }
261
262 @Override
263 public int getDatabaseMinorVersion() throws SQLException {
264 try {
265 return databaseMetaData.getDatabaseMinorVersion();
266 } catch (final SQLException e) {
267 handleException(e);
268 return 0;
269 }
270 }
271
272 @Override
273 public String getDatabaseProductName() throws SQLException {
274 try {
275 return databaseMetaData.getDatabaseProductName();
276 } catch (final SQLException e) {
277 handleException(e);
278 throw new AssertionError();
279 }
280 }
281
282 @Override
283 public String getDatabaseProductVersion() throws SQLException {
284 try {
285 return databaseMetaData.getDatabaseProductVersion();
286 } catch (final SQLException e) {
287 handleException(e);
288 throw new AssertionError();
289 }
290 }
291
292 @Override
293 public int getDefaultTransactionIsolation() throws SQLException {
294 try {
295 return databaseMetaData.getDefaultTransactionIsolation();
296 } catch (final SQLException e) {
297 handleException(e);
298 return 0;
299 }
300 }
301
302
303
304
305
306
307 public DatabaseMetaData getDelegate() {
308 return databaseMetaData;
309 }
310
311 @Override
312 public int getDriverMajorVersion() {
313 return databaseMetaData.getDriverMajorVersion();
314 }
315
316 @Override
317 public int getDriverMinorVersion() {
318 return databaseMetaData.getDriverMinorVersion();
319 }
320
321 @Override
322 public String getDriverName() throws SQLException {
323 try {
324 return databaseMetaData.getDriverName();
325 } catch (final SQLException e) {
326 handleException(e);
327 throw new AssertionError();
328 }
329 }
330
331 @Override
332 public String getDriverVersion() throws SQLException {
333 try {
334 return databaseMetaData.getDriverVersion();
335 } catch (final SQLException e) {
336 handleException(e);
337 throw new AssertionError();
338 }
339 }
340
341 @Override
342 public ResultSet getExportedKeys(final String catalog, final String schema, final String table)
343 throws SQLException {
344 connection.checkOpen();
345 try {
346 return DelegatingResultSet.wrapResultSet(connection,
347 databaseMetaData.getExportedKeys(catalog, schema, table));
348 } catch (final SQLException e) {
349 handleException(e);
350 throw new AssertionError();
351 }
352 }
353
354 @Override
355 public String getExtraNameCharacters() throws SQLException {
356 try {
357 return databaseMetaData.getExtraNameCharacters();
358 } catch (final SQLException e) {
359 handleException(e);
360 throw new AssertionError();
361 }
362 }
363
364 @Override
365 public ResultSet getFunctionColumns(final String catalog, final String schemaPattern,
366 final String functionNamePattern, final String columnNamePattern) throws SQLException {
367 connection.checkOpen();
368 try {
369 return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getFunctionColumns(catalog,
370 schemaPattern, functionNamePattern, columnNamePattern));
371 } catch (final SQLException e) {
372 handleException(e);
373 throw new AssertionError();
374 }
375 }
376
377 @Override
378 public ResultSet getFunctions(final String catalog, final String schemaPattern, final String functionNamePattern)
379 throws SQLException {
380 connection.checkOpen();
381 try {
382 return DelegatingResultSet.wrapResultSet(connection,
383 databaseMetaData.getFunctions(catalog, schemaPattern, functionNamePattern));
384 } catch (final SQLException e) {
385 handleException(e);
386 throw new AssertionError();
387 }
388 }
389
390 @Override
391 public String getIdentifierQuoteString() throws SQLException {
392 try {
393 return databaseMetaData.getIdentifierQuoteString();
394 } catch (final SQLException e) {
395 handleException(e);
396 throw new AssertionError();
397 }
398 }
399
400 @Override
401 public ResultSet getImportedKeys(final String catalog, final String schema, final String table)
402 throws SQLException {
403 connection.checkOpen();
404 try {
405 return DelegatingResultSet.wrapResultSet(connection,
406 databaseMetaData.getImportedKeys(catalog, schema, table));
407 } catch (final SQLException e) {
408 handleException(e);
409 throw new AssertionError();
410 }
411 }
412
413 @Override
414 public ResultSet getIndexInfo(final String catalog, final String schema, final String table, final boolean unique,
415 final boolean approximate) throws SQLException {
416 connection.checkOpen();
417 try {
418 return DelegatingResultSet.wrapResultSet(connection,
419 databaseMetaData.getIndexInfo(catalog, schema, table, unique, approximate));
420 } catch (final SQLException e) {
421 handleException(e);
422 throw new AssertionError();
423 }
424 }
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440 public DatabaseMetaData getInnermostDelegate() {
441 DatabaseMetaData m = databaseMetaData;
442 while (m instanceof DelegatingDatabaseMetaData) {
443 m = ((DelegatingDatabaseMetaData) m).getDelegate();
444 if (this == m) {
445 return null;
446 }
447 }
448 return m;
449 }
450
451 @Override
452 public int getJDBCMajorVersion() throws SQLException {
453 try {
454 return databaseMetaData.getJDBCMajorVersion();
455 } catch (final SQLException e) {
456 handleException(e);
457 return 0;
458 }
459 }
460
461 @Override
462 public int getJDBCMinorVersion() throws SQLException {
463 try {
464 return databaseMetaData.getJDBCMinorVersion();
465 } catch (final SQLException e) {
466 handleException(e);
467 return 0;
468 }
469 }
470
471 @Override
472 public int getMaxBinaryLiteralLength() throws SQLException {
473 try {
474 return databaseMetaData.getMaxBinaryLiteralLength();
475 } catch (final SQLException e) {
476 handleException(e);
477 return 0;
478 }
479 }
480
481 @Override
482 public int getMaxCatalogNameLength() throws SQLException {
483 try {
484 return databaseMetaData.getMaxCatalogNameLength();
485 } catch (final SQLException e) {
486 handleException(e);
487 return 0;
488 }
489 }
490
491 @Override
492 public int getMaxCharLiteralLength() throws SQLException {
493 try {
494 return databaseMetaData.getMaxCharLiteralLength();
495 } catch (final SQLException e) {
496 handleException(e);
497 return 0;
498 }
499 }
500
501 @Override
502 public int getMaxColumnNameLength() throws SQLException {
503 try {
504 return databaseMetaData.getMaxColumnNameLength();
505 } catch (final SQLException e) {
506 handleException(e);
507 return 0;
508 }
509 }
510
511 @Override
512 public int getMaxColumnsInGroupBy() throws SQLException {
513 try {
514 return databaseMetaData.getMaxColumnsInGroupBy();
515 } catch (final SQLException e) {
516 handleException(e);
517 return 0;
518 }
519 }
520
521 @Override
522 public int getMaxColumnsInIndex() throws SQLException {
523 try {
524 return databaseMetaData.getMaxColumnsInIndex();
525 } catch (final SQLException e) {
526 handleException(e);
527 return 0;
528 }
529 }
530
531 @Override
532 public int getMaxColumnsInOrderBy() throws SQLException {
533 try {
534 return databaseMetaData.getMaxColumnsInOrderBy();
535 } catch (final SQLException e) {
536 handleException(e);
537 return 0;
538 }
539 }
540
541 @Override
542 public int getMaxColumnsInSelect() throws SQLException {
543 try {
544 return databaseMetaData.getMaxColumnsInSelect();
545 } catch (final SQLException e) {
546 handleException(e);
547 return 0;
548 }
549 }
550
551 @Override
552 public int getMaxColumnsInTable() throws SQLException {
553 try {
554 return databaseMetaData.getMaxColumnsInTable();
555 } catch (final SQLException e) {
556 handleException(e);
557 return 0;
558 }
559 }
560
561 @Override
562 public int getMaxConnections() throws SQLException {
563 try {
564 return databaseMetaData.getMaxConnections();
565 } catch (final SQLException e) {
566 handleException(e);
567 return 0;
568 }
569 }
570
571 @Override
572 public int getMaxCursorNameLength() throws SQLException {
573 try {
574 return databaseMetaData.getMaxCursorNameLength();
575 } catch (final SQLException e) {
576 handleException(e);
577 return 0;
578 }
579 }
580
581 @Override
582 public int getMaxIndexLength() throws SQLException {
583 try {
584 return databaseMetaData.getMaxIndexLength();
585 } catch (final SQLException e) {
586 handleException(e);
587 return 0;
588 }
589 }
590
591
592
593
594 @Override
595 public long getMaxLogicalLobSize() throws SQLException {
596 try {
597 return databaseMetaData.getMaxLogicalLobSize();
598 } catch (final SQLException e) {
599 handleException(e);
600 return 0;
601 }
602 }
603
604 @Override
605 public int getMaxProcedureNameLength() throws SQLException {
606 try {
607 return databaseMetaData.getMaxProcedureNameLength();
608 } catch (final SQLException e) {
609 handleException(e);
610 return 0;
611 }
612 }
613
614 @Override
615 public int getMaxRowSize() throws SQLException {
616 try {
617 return databaseMetaData.getMaxRowSize();
618 } catch (final SQLException e) {
619 handleException(e);
620 return 0;
621 }
622 }
623
624 @Override
625 public int getMaxSchemaNameLength() throws SQLException {
626 try {
627 return databaseMetaData.getMaxSchemaNameLength();
628 } catch (final SQLException e) {
629 handleException(e);
630 return 0;
631 }
632 }
633
634 @Override
635 public int getMaxStatementLength() throws SQLException {
636 try {
637 return databaseMetaData.getMaxStatementLength();
638 } catch (final SQLException e) {
639 handleException(e);
640 return 0;
641 }
642 }
643
644 @Override
645 public int getMaxStatements() throws SQLException {
646 try {
647 return databaseMetaData.getMaxStatements();
648 } catch (final SQLException e) {
649 handleException(e);
650 return 0;
651 }
652 }
653
654 @Override
655 public int getMaxTableNameLength() throws SQLException {
656 try {
657 return databaseMetaData.getMaxTableNameLength();
658 } catch (final SQLException e) {
659 handleException(e);
660 return 0;
661 }
662 }
663
664 @Override
665 public int getMaxTablesInSelect() throws SQLException {
666 try {
667 return databaseMetaData.getMaxTablesInSelect();
668 } catch (final SQLException e) {
669 handleException(e);
670 return 0;
671 }
672 }
673
674 @Override
675 public int getMaxUserNameLength() throws SQLException {
676 try {
677 return databaseMetaData.getMaxUserNameLength();
678 } catch (final SQLException e) {
679 handleException(e);
680 return 0;
681 }
682 }
683
684 @Override
685 public String getNumericFunctions() throws SQLException {
686 try {
687 return databaseMetaData.getNumericFunctions();
688 } catch (final SQLException e) {
689 handleException(e);
690 throw new AssertionError();
691 }
692 }
693
694 @Override
695 public ResultSet getPrimaryKeys(final String catalog, final String schema, final String table) throws SQLException {
696 connection.checkOpen();
697 try {
698 return DelegatingResultSet.wrapResultSet(connection,
699 databaseMetaData.getPrimaryKeys(catalog, schema, table));
700 } catch (final SQLException e) {
701 handleException(e);
702 throw new AssertionError();
703 }
704 }
705
706 @Override
707 public ResultSet getProcedureColumns(final String catalog, final String schemaPattern,
708 final String procedureNamePattern, final String columnNamePattern) throws SQLException {
709 connection.checkOpen();
710 try {
711 return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getProcedureColumns(catalog,
712 schemaPattern, procedureNamePattern, columnNamePattern));
713 } catch (final SQLException e) {
714 handleException(e);
715 throw new AssertionError();
716 }
717 }
718
719 @Override
720 public ResultSet getProcedures(final String catalog, final String schemaPattern, final String procedureNamePattern)
721 throws SQLException {
722 connection.checkOpen();
723 try {
724 return DelegatingResultSet.wrapResultSet(connection,
725 databaseMetaData.getProcedures(catalog, schemaPattern, procedureNamePattern));
726 } catch (final SQLException e) {
727 handleException(e);
728 throw new AssertionError();
729 }
730 }
731
732 @Override
733 public String getProcedureTerm() throws SQLException {
734 try {
735 return databaseMetaData.getProcedureTerm();
736 } catch (final SQLException e) {
737 handleException(e);
738 throw new AssertionError();
739 }
740 }
741
742 @Override
743 public ResultSet getPseudoColumns(final String catalog, final String schemaPattern, final String tableNamePattern,
744 final String columnNamePattern) throws SQLException {
745 connection.checkOpen();
746 try {
747 return DelegatingResultSet.wrapResultSet(connection, Jdbc41Bridge.getPseudoColumns(databaseMetaData,
748 catalog, schemaPattern, tableNamePattern, columnNamePattern));
749 } catch (final SQLException e) {
750 handleException(e);
751 throw new AssertionError();
752 }
753 }
754
755 @Override
756 public int getResultSetHoldability() throws SQLException {
757 try {
758 return databaseMetaData.getResultSetHoldability();
759 } catch (final SQLException e) {
760 handleException(e);
761 return 0;
762 }
763 }
764
765 @Override
766 public RowIdLifetime getRowIdLifetime() throws SQLException {
767 try {
768 return databaseMetaData.getRowIdLifetime();
769 } catch (final SQLException e) {
770 handleException(e);
771 throw new AssertionError();
772 }
773 }
774
775 @Override
776 public ResultSet getSchemas() throws SQLException {
777 connection.checkOpen();
778 try {
779 return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getSchemas());
780 } catch (final SQLException e) {
781 handleException(e);
782 throw new AssertionError();
783 }
784 }
785
786 @Override
787 public ResultSet getSchemas(final String catalog, final String schemaPattern) throws SQLException {
788 connection.checkOpen();
789 try {
790 return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getSchemas(catalog, schemaPattern));
791 } catch (final SQLException e) {
792 handleException(e);
793 throw new AssertionError();
794 }
795 }
796
797 @Override
798 public String getSchemaTerm() throws SQLException {
799 try {
800 return databaseMetaData.getSchemaTerm();
801 } catch (final SQLException e) {
802 handleException(e);
803 throw new AssertionError();
804 }
805 }
806
807 @Override
808 public String getSearchStringEscape() throws SQLException {
809 try {
810 return databaseMetaData.getSearchStringEscape();
811 } catch (final SQLException e) {
812 handleException(e);
813 throw new AssertionError();
814 }
815 }
816
817 @Override
818 public String getSQLKeywords() throws SQLException {
819 try {
820 return databaseMetaData.getSQLKeywords();
821 } catch (final SQLException e) {
822 handleException(e);
823 throw new AssertionError();
824 }
825 }
826
827 @Override
828 public int getSQLStateType() throws SQLException {
829 try {
830 return databaseMetaData.getSQLStateType();
831 } catch (final SQLException e) {
832 handleException(e);
833 return 0;
834 }
835 }
836
837 @Override
838 public String getStringFunctions() throws SQLException {
839 try {
840 return databaseMetaData.getStringFunctions();
841 } catch (final SQLException e) {
842 handleException(e);
843 throw new AssertionError();
844 }
845 }
846
847 @Override
848 public ResultSet getSuperTables(final String catalog, final String schemaPattern, final String tableNamePattern)
849 throws SQLException {
850 connection.checkOpen();
851 try {
852 return DelegatingResultSet.wrapResultSet(connection,
853 databaseMetaData.getSuperTables(catalog, schemaPattern, tableNamePattern));
854 } catch (final SQLException e) {
855 handleException(e);
856 throw new AssertionError();
857 }
858 }
859
860 @Override
861 public ResultSet getSuperTypes(final String catalog, final String schemaPattern, final String typeNamePattern)
862 throws SQLException {
863 connection.checkOpen();
864 try {
865 return DelegatingResultSet.wrapResultSet(connection,
866 databaseMetaData.getSuperTypes(catalog, schemaPattern, typeNamePattern));
867 } catch (final SQLException e) {
868 handleException(e);
869 throw new AssertionError();
870 }
871 }
872
873 @Override
874 public String getSystemFunctions() throws SQLException {
875 try {
876 return databaseMetaData.getSystemFunctions();
877 } catch (final SQLException e) {
878 handleException(e);
879 throw new AssertionError();
880 }
881 }
882
883 @Override
884 public ResultSet getTablePrivileges(final String catalog, final String schemaPattern, final String tableNamePattern)
885 throws SQLException {
886 connection.checkOpen();
887 try {
888 return DelegatingResultSet.wrapResultSet(connection,
889 databaseMetaData.getTablePrivileges(catalog, schemaPattern, tableNamePattern));
890 } catch (final SQLException e) {
891 handleException(e);
892 throw new AssertionError();
893 }
894 }
895
896 @Override
897 public ResultSet getTables(final String catalog, final String schemaPattern, final String tableNamePattern,
898 final String[] types) throws SQLException {
899 connection.checkOpen();
900 try {
901 return DelegatingResultSet.wrapResultSet(connection,
902 databaseMetaData.getTables(catalog, schemaPattern, tableNamePattern, types));
903 } catch (final SQLException e) {
904 handleException(e);
905 throw new AssertionError();
906 }
907 }
908
909 @Override
910 public ResultSet getTableTypes() throws SQLException {
911 connection.checkOpen();
912 try {
913 return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getTableTypes());
914 } catch (final SQLException e) {
915 handleException(e);
916 throw new AssertionError();
917 }
918 }
919
920 @Override
921 public String getTimeDateFunctions() throws SQLException {
922 try {
923 return databaseMetaData.getTimeDateFunctions();
924 } catch (final SQLException e) {
925 handleException(e);
926 throw new AssertionError();
927 }
928 }
929
930 @Override
931 public ResultSet getTypeInfo() throws SQLException {
932 connection.checkOpen();
933 try {
934 return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getTypeInfo());
935 } catch (final SQLException e) {
936 handleException(e);
937 throw new AssertionError();
938 }
939 }
940
941 @Override
942 public ResultSet getUDTs(final String catalog, final String schemaPattern, final String typeNamePattern,
943 final int[] types) throws SQLException {
944 connection.checkOpen();
945 try {
946 return DelegatingResultSet.wrapResultSet(connection,
947 databaseMetaData.getUDTs(catalog, schemaPattern, typeNamePattern, types));
948 } catch (final SQLException e) {
949 handleException(e);
950 throw new AssertionError();
951 }
952 }
953
954 @Override
955 public String getURL() throws SQLException {
956 try {
957 return databaseMetaData.getURL();
958 } catch (final SQLException e) {
959 handleException(e);
960 throw new AssertionError();
961 }
962 }
963
964 @Override
965 public String getUserName() throws SQLException {
966 try {
967 return databaseMetaData.getUserName();
968 } catch (final SQLException e) {
969 handleException(e);
970 throw new AssertionError();
971 }
972 }
973
974 @Override
975 public ResultSet getVersionColumns(final String catalog, final String schema, final String table)
976 throws SQLException {
977 connection.checkOpen();
978 try {
979 return DelegatingResultSet.wrapResultSet(connection,
980 databaseMetaData.getVersionColumns(catalog, schema, table));
981 } catch (final SQLException e) {
982 handleException(e);
983 throw new AssertionError();
984 }
985 }
986
987 protected void handleException(final SQLException e) throws SQLException {
988 if (connection == null) {
989 throw e;
990 }
991 connection.handleException(e);
992 }
993
994 @Override
995 public boolean insertsAreDetected(final int type) throws SQLException {
996 try {
997 return databaseMetaData.insertsAreDetected(type);
998 } catch (final SQLException e) {
999 handleException(e);
1000 return false;
1001 }
1002 }
1003
1004 @Override
1005 public boolean isCatalogAtStart() throws SQLException {
1006 try {
1007 return databaseMetaData.isCatalogAtStart();
1008 } catch (final SQLException e) {
1009 handleException(e);
1010 return false;
1011 }
1012 }
1013
1014 @Override
1015 public boolean isReadOnly() throws SQLException {
1016 try {
1017 return databaseMetaData.isReadOnly();
1018 } catch (final SQLException e) {
1019 handleException(e);
1020 return false;
1021 }
1022 }
1023
1024 @Override
1025 public boolean isWrapperFor(final Class<?> iface) throws SQLException {
1026 if (iface.isAssignableFrom(getClass())) {
1027 return true;
1028 }
1029 if (iface.isAssignableFrom(databaseMetaData.getClass())) {
1030 return true;
1031 }
1032 return databaseMetaData.isWrapperFor(iface);
1033 }
1034
1035 @Override
1036 public boolean locatorsUpdateCopy() throws SQLException {
1037 try {
1038 return databaseMetaData.locatorsUpdateCopy();
1039 } catch (final SQLException e) {
1040 handleException(e);
1041 return false;
1042 }
1043 }
1044
1045 @Override
1046 public boolean nullPlusNonNullIsNull() throws SQLException {
1047 try {
1048 return databaseMetaData.nullPlusNonNullIsNull();
1049 } catch (final SQLException e) {
1050 handleException(e);
1051 return false;
1052 }
1053 }
1054
1055 @Override
1056 public boolean nullsAreSortedAtEnd() throws SQLException {
1057 try {
1058 return databaseMetaData.nullsAreSortedAtEnd();
1059 } catch (final SQLException e) {
1060 handleException(e);
1061 return false;
1062 }
1063 }
1064
1065 @Override
1066 public boolean nullsAreSortedAtStart() throws SQLException {
1067 try {
1068 return databaseMetaData.nullsAreSortedAtStart();
1069 } catch (final SQLException e) {
1070 handleException(e);
1071 return false;
1072 }
1073 }
1074
1075 @Override
1076 public boolean nullsAreSortedHigh() throws SQLException {
1077 try {
1078 return databaseMetaData.nullsAreSortedHigh();
1079 } catch (final SQLException e) {
1080 handleException(e);
1081 return false;
1082 }
1083 }
1084
1085 @Override
1086 public boolean nullsAreSortedLow() throws SQLException {
1087 try {
1088 return databaseMetaData.nullsAreSortedLow();
1089 } catch (final SQLException e) {
1090 handleException(e);
1091 return false;
1092 }
1093 }
1094
1095 @Override
1096 public boolean othersDeletesAreVisible(final int type) throws SQLException {
1097 try {
1098 return databaseMetaData.othersDeletesAreVisible(type);
1099 } catch (final SQLException e) {
1100 handleException(e);
1101 return false;
1102 }
1103 }
1104
1105 @Override
1106 public boolean othersInsertsAreVisible(final int type) throws SQLException {
1107 try {
1108 return databaseMetaData.othersInsertsAreVisible(type);
1109 } catch (final SQLException e) {
1110 handleException(e);
1111 return false;
1112 }
1113 }
1114
1115 @Override
1116 public boolean othersUpdatesAreVisible(final int type) throws SQLException {
1117 try {
1118 return databaseMetaData.othersUpdatesAreVisible(type);
1119 } catch (final SQLException e) {
1120 handleException(e);
1121 return false;
1122 }
1123 }
1124
1125 @Override
1126 public boolean ownDeletesAreVisible(final int type) throws SQLException {
1127 try {
1128 return databaseMetaData.ownDeletesAreVisible(type);
1129 } catch (final SQLException e) {
1130 handleException(e);
1131 return false;
1132 }
1133 }
1134
1135 @Override
1136 public boolean ownInsertsAreVisible(final int type) throws SQLException {
1137 try {
1138 return databaseMetaData.ownInsertsAreVisible(type);
1139 } catch (final SQLException e) {
1140 handleException(e);
1141 return false;
1142 }
1143 }
1144
1145 @Override
1146 public boolean ownUpdatesAreVisible(final int type) throws SQLException {
1147 try {
1148 return databaseMetaData.ownUpdatesAreVisible(type);
1149 } catch (final SQLException e) {
1150 handleException(e);
1151 return false;
1152 }
1153 }
1154
1155 @Override
1156 public boolean storesLowerCaseIdentifiers() throws SQLException {
1157 try {
1158 return databaseMetaData.storesLowerCaseIdentifiers();
1159 } catch (final SQLException e) {
1160 handleException(e);
1161 return false;
1162 }
1163 }
1164
1165 @Override
1166 public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
1167 try {
1168 return databaseMetaData.storesLowerCaseQuotedIdentifiers();
1169 } catch (final SQLException e) {
1170 handleException(e);
1171 return false;
1172 }
1173 }
1174
1175 @Override
1176 public boolean storesMixedCaseIdentifiers() throws SQLException {
1177 try {
1178 return databaseMetaData.storesMixedCaseIdentifiers();
1179 } catch (final SQLException e) {
1180 handleException(e);
1181 return false;
1182 }
1183 }
1184
1185 @Override
1186 public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
1187 try {
1188 return databaseMetaData.storesMixedCaseQuotedIdentifiers();
1189 } catch (final SQLException e) {
1190 handleException(e);
1191 return false;
1192 }
1193 }
1194
1195 @Override
1196 public boolean storesUpperCaseIdentifiers() throws SQLException {
1197 try {
1198 return databaseMetaData.storesUpperCaseIdentifiers();
1199 } catch (final SQLException e) {
1200 handleException(e);
1201 return false;
1202 }
1203 }
1204
1205 @Override
1206 public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
1207 try {
1208 return databaseMetaData.storesUpperCaseQuotedIdentifiers();
1209 } catch (final SQLException e) {
1210 handleException(e);
1211 return false;
1212 }
1213 }
1214
1215 @Override
1216 public boolean supportsAlterTableWithAddColumn() throws SQLException {
1217 try {
1218 return databaseMetaData.supportsAlterTableWithAddColumn();
1219 } catch (final SQLException e) {
1220 handleException(e);
1221 return false;
1222 }
1223 }
1224
1225 @Override
1226 public boolean supportsAlterTableWithDropColumn() throws SQLException {
1227 try {
1228 return databaseMetaData.supportsAlterTableWithDropColumn();
1229 } catch (final SQLException e) {
1230 handleException(e);
1231 return false;
1232 }
1233 }
1234
1235 @Override
1236 public boolean supportsANSI92EntryLevelSQL() throws SQLException {
1237 try {
1238 return databaseMetaData.supportsANSI92EntryLevelSQL();
1239 } catch (final SQLException e) {
1240 handleException(e);
1241 return false;
1242 }
1243 }
1244
1245 @Override
1246 public boolean supportsANSI92FullSQL() throws SQLException {
1247 try {
1248 return databaseMetaData.supportsANSI92FullSQL();
1249 } catch (final SQLException e) {
1250 handleException(e);
1251 return false;
1252 }
1253 }
1254
1255 @Override
1256 public boolean supportsANSI92IntermediateSQL() throws SQLException {
1257 try {
1258 return databaseMetaData.supportsANSI92IntermediateSQL();
1259 } catch (final SQLException e) {
1260 handleException(e);
1261 return false;
1262 }
1263 }
1264
1265 @Override
1266 public boolean supportsBatchUpdates() throws SQLException {
1267 try {
1268 return databaseMetaData.supportsBatchUpdates();
1269 } catch (final SQLException e) {
1270 handleException(e);
1271 return false;
1272 }
1273 }
1274
1275 @Override
1276 public boolean supportsCatalogsInDataManipulation() throws SQLException {
1277 try {
1278 return databaseMetaData.supportsCatalogsInDataManipulation();
1279 } catch (final SQLException e) {
1280 handleException(e);
1281 return false;
1282 }
1283 }
1284
1285 @Override
1286 public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
1287 try {
1288 return databaseMetaData.supportsCatalogsInIndexDefinitions();
1289 } catch (final SQLException e) {
1290 handleException(e);
1291 return false;
1292 }
1293 }
1294
1295 @Override
1296 public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
1297 try {
1298 return databaseMetaData.supportsCatalogsInPrivilegeDefinitions();
1299 } catch (final SQLException e) {
1300 handleException(e);
1301 return false;
1302 }
1303 }
1304
1305 @Override
1306 public boolean supportsCatalogsInProcedureCalls() throws SQLException {
1307 try {
1308 return databaseMetaData.supportsCatalogsInProcedureCalls();
1309 } catch (final SQLException e) {
1310 handleException(e);
1311 return false;
1312 }
1313 }
1314
1315 @Override
1316 public boolean supportsCatalogsInTableDefinitions() throws SQLException {
1317 try {
1318 return databaseMetaData.supportsCatalogsInTableDefinitions();
1319 } catch (final SQLException e) {
1320 handleException(e);
1321 return false;
1322 }
1323 }
1324
1325 @Override
1326 public boolean supportsColumnAliasing() throws SQLException {
1327 try {
1328 return databaseMetaData.supportsColumnAliasing();
1329 } catch (final SQLException e) {
1330 handleException(e);
1331 return false;
1332 }
1333 }
1334
1335 @Override
1336 public boolean supportsConvert() throws SQLException {
1337 try {
1338 return databaseMetaData.supportsConvert();
1339 } catch (final SQLException e) {
1340 handleException(e);
1341 return false;
1342 }
1343 }
1344
1345 @Override
1346 public boolean supportsConvert(final int fromType, final int toType) throws SQLException {
1347 try {
1348 return databaseMetaData.supportsConvert(fromType, toType);
1349 } catch (final SQLException e) {
1350 handleException(e);
1351 return false;
1352 }
1353 }
1354
1355 @Override
1356 public boolean supportsCoreSQLGrammar() throws SQLException {
1357 try {
1358 return databaseMetaData.supportsCoreSQLGrammar();
1359 } catch (final SQLException e) {
1360 handleException(e);
1361 return false;
1362 }
1363 }
1364
1365 @Override
1366 public boolean supportsCorrelatedSubqueries() throws SQLException {
1367 try {
1368 return databaseMetaData.supportsCorrelatedSubqueries();
1369 } catch (final SQLException e) {
1370 handleException(e);
1371 return false;
1372 }
1373 }
1374
1375 @Override
1376 public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
1377 try {
1378 return databaseMetaData.supportsDataDefinitionAndDataManipulationTransactions();
1379 } catch (final SQLException e) {
1380 handleException(e);
1381 return false;
1382 }
1383 }
1384
1385 @Override
1386 public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
1387 try {
1388 return databaseMetaData.supportsDataManipulationTransactionsOnly();
1389 } catch (final SQLException e) {
1390 handleException(e);
1391 return false;
1392 }
1393 }
1394
1395 @Override
1396 public boolean supportsDifferentTableCorrelationNames() throws SQLException {
1397 try {
1398 return databaseMetaData.supportsDifferentTableCorrelationNames();
1399 } catch (final SQLException e) {
1400 handleException(e);
1401 return false;
1402 }
1403 }
1404
1405 @Override
1406 public boolean supportsExpressionsInOrderBy() throws SQLException {
1407 try {
1408 return databaseMetaData.supportsExpressionsInOrderBy();
1409 } catch (final SQLException e) {
1410 handleException(e);
1411 return false;
1412 }
1413 }
1414
1415 @Override
1416 public boolean supportsExtendedSQLGrammar() throws SQLException {
1417 try {
1418 return databaseMetaData.supportsExtendedSQLGrammar();
1419 } catch (final SQLException e) {
1420 handleException(e);
1421 return false;
1422 }
1423 }
1424
1425 @Override
1426 public boolean supportsFullOuterJoins() throws SQLException {
1427 try {
1428 return databaseMetaData.supportsFullOuterJoins();
1429 } catch (final SQLException e) {
1430 handleException(e);
1431 return false;
1432 }
1433 }
1434
1435 @Override
1436 public boolean supportsGetGeneratedKeys() throws SQLException {
1437 try {
1438 return databaseMetaData.supportsGetGeneratedKeys();
1439 } catch (final SQLException e) {
1440 handleException(e);
1441 return false;
1442 }
1443 }
1444
1445 @Override
1446 public boolean supportsGroupBy() throws SQLException {
1447 try {
1448 return databaseMetaData.supportsGroupBy();
1449 } catch (final SQLException e) {
1450 handleException(e);
1451 return false;
1452 }
1453 }
1454
1455 @Override
1456 public boolean supportsGroupByBeyondSelect() throws SQLException {
1457 try {
1458 return databaseMetaData.supportsGroupByBeyondSelect();
1459 } catch (final SQLException e) {
1460 handleException(e);
1461 return false;
1462 }
1463 }
1464
1465 @Override
1466 public boolean supportsGroupByUnrelated() throws SQLException {
1467 try {
1468 return databaseMetaData.supportsGroupByUnrelated();
1469 } catch (final SQLException e) {
1470 handleException(e);
1471 return false;
1472 }
1473 }
1474
1475 @Override
1476 public boolean supportsIntegrityEnhancementFacility() throws SQLException {
1477 try {
1478 return databaseMetaData.supportsIntegrityEnhancementFacility();
1479 } catch (final SQLException e) {
1480 handleException(e);
1481 return false;
1482 }
1483 }
1484
1485 @Override
1486 public boolean supportsLikeEscapeClause() throws SQLException {
1487 try {
1488 return databaseMetaData.supportsLikeEscapeClause();
1489 } catch (final SQLException e) {
1490 handleException(e);
1491 return false;
1492 }
1493 }
1494
1495 @Override
1496 public boolean supportsLimitedOuterJoins() throws SQLException {
1497 try {
1498 return databaseMetaData.supportsLimitedOuterJoins();
1499 } catch (final SQLException e) {
1500 handleException(e);
1501 return false;
1502 }
1503 }
1504
1505 @Override
1506 public boolean supportsMinimumSQLGrammar() throws SQLException {
1507 try {
1508 return databaseMetaData.supportsMinimumSQLGrammar();
1509 } catch (final SQLException e) {
1510 handleException(e);
1511 return false;
1512 }
1513 }
1514
1515 @Override
1516 public boolean supportsMixedCaseIdentifiers() throws SQLException {
1517 try {
1518 return databaseMetaData.supportsMixedCaseIdentifiers();
1519 } catch (final SQLException e) {
1520 handleException(e);
1521 return false;
1522 }
1523 }
1524
1525 @Override
1526 public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
1527 try {
1528 return databaseMetaData.supportsMixedCaseQuotedIdentifiers();
1529 } catch (final SQLException e) {
1530 handleException(e);
1531 return false;
1532 }
1533 }
1534
1535 @Override
1536 public boolean supportsMultipleOpenResults() throws SQLException {
1537 try {
1538 return databaseMetaData.supportsMultipleOpenResults();
1539 } catch (final SQLException e) {
1540 handleException(e);
1541 return false;
1542 }
1543 }
1544
1545 @Override
1546 public boolean supportsMultipleResultSets() throws SQLException {
1547 try {
1548 return databaseMetaData.supportsMultipleResultSets();
1549 } catch (final SQLException e) {
1550 handleException(e);
1551 return false;
1552 }
1553 }
1554
1555 @Override
1556 public boolean supportsMultipleTransactions() throws SQLException {
1557 try {
1558 return databaseMetaData.supportsMultipleTransactions();
1559 } catch (final SQLException e) {
1560 handleException(e);
1561 return false;
1562 }
1563 }
1564
1565 @Override
1566 public boolean supportsNamedParameters() throws SQLException {
1567 try {
1568 return databaseMetaData.supportsNamedParameters();
1569 } catch (final SQLException e) {
1570 handleException(e);
1571 return false;
1572 }
1573 }
1574
1575 @Override
1576 public boolean supportsNonNullableColumns() throws SQLException {
1577 try {
1578 return databaseMetaData.supportsNonNullableColumns();
1579 } catch (final SQLException e) {
1580 handleException(e);
1581 return false;
1582 }
1583 }
1584
1585 @Override
1586 public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
1587 try {
1588 return databaseMetaData.supportsOpenCursorsAcrossCommit();
1589 } catch (final SQLException e) {
1590 handleException(e);
1591 return false;
1592 }
1593 }
1594
1595 @Override
1596 public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
1597 try {
1598 return databaseMetaData.supportsOpenCursorsAcrossRollback();
1599 } catch (final SQLException e) {
1600 handleException(e);
1601 return false;
1602 }
1603 }
1604
1605 @Override
1606 public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
1607 try {
1608 return databaseMetaData.supportsOpenStatementsAcrossCommit();
1609 } catch (final SQLException e) {
1610 handleException(e);
1611 return false;
1612 }
1613 }
1614
1615 @Override
1616 public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
1617 try {
1618 return databaseMetaData.supportsOpenStatementsAcrossRollback();
1619 } catch (final SQLException e) {
1620 handleException(e);
1621 return false;
1622 }
1623 }
1624
1625 @Override
1626 public boolean supportsOrderByUnrelated() throws SQLException {
1627 try {
1628 return databaseMetaData.supportsOrderByUnrelated();
1629 } catch (final SQLException e) {
1630 handleException(e);
1631 return false;
1632 }
1633 }
1634
1635 @Override
1636 public boolean supportsOuterJoins() throws SQLException {
1637 try {
1638 return databaseMetaData.supportsOuterJoins();
1639 } catch (final SQLException e) {
1640 handleException(e);
1641 return false;
1642 }
1643 }
1644
1645 @Override
1646 public boolean supportsPositionedDelete() throws SQLException {
1647 try {
1648 return databaseMetaData.supportsPositionedDelete();
1649 } catch (final SQLException e) {
1650 handleException(e);
1651 return false;
1652 }
1653 }
1654
1655 @Override
1656 public boolean supportsPositionedUpdate() throws SQLException {
1657 try {
1658 return databaseMetaData.supportsPositionedUpdate();
1659 } catch (final SQLException e) {
1660 handleException(e);
1661 return false;
1662 }
1663 }
1664
1665
1666
1667
1668 @Override
1669 public boolean supportsRefCursors() throws SQLException {
1670 try {
1671 return databaseMetaData.supportsRefCursors();
1672 } catch (final SQLException e) {
1673 handleException(e);
1674 return false;
1675 }
1676 }
1677
1678 @Override
1679 public boolean supportsResultSetConcurrency(final int type, final int concurrency) throws SQLException {
1680 try {
1681 return databaseMetaData.supportsResultSetConcurrency(type, concurrency);
1682 } catch (final SQLException e) {
1683 handleException(e);
1684 return false;
1685 }
1686 }
1687
1688 @Override
1689 public boolean supportsResultSetHoldability(final int holdability) throws SQLException {
1690 try {
1691 return databaseMetaData.supportsResultSetHoldability(holdability);
1692 } catch (final SQLException e) {
1693 handleException(e);
1694 return false;
1695 }
1696 }
1697
1698 @Override
1699 public boolean supportsResultSetType(final int type) throws SQLException {
1700 try {
1701 return databaseMetaData.supportsResultSetType(type);
1702 } catch (final SQLException e) {
1703 handleException(e);
1704 return false;
1705 }
1706 }
1707
1708 @Override
1709 public boolean supportsSavepoints() throws SQLException {
1710 try {
1711 return databaseMetaData.supportsSavepoints();
1712 } catch (final SQLException e) {
1713 handleException(e);
1714 return false;
1715 }
1716 }
1717
1718 @Override
1719 public boolean supportsSchemasInDataManipulation() throws SQLException {
1720 try {
1721 return databaseMetaData.supportsSchemasInDataManipulation();
1722 } catch (final SQLException e) {
1723 handleException(e);
1724 return false;
1725 }
1726 }
1727
1728 @Override
1729 public boolean supportsSchemasInIndexDefinitions() throws SQLException {
1730 try {
1731 return databaseMetaData.supportsSchemasInIndexDefinitions();
1732 } catch (final SQLException e) {
1733 handleException(e);
1734 return false;
1735 }
1736 }
1737
1738 @Override
1739 public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
1740 try {
1741 return databaseMetaData.supportsSchemasInPrivilegeDefinitions();
1742 } catch (final SQLException e) {
1743 handleException(e);
1744 return false;
1745 }
1746 }
1747
1748 @Override
1749 public boolean supportsSchemasInProcedureCalls() throws SQLException {
1750 try {
1751 return databaseMetaData.supportsSchemasInProcedureCalls();
1752 } catch (final SQLException e) {
1753 handleException(e);
1754 return false;
1755 }
1756 }
1757
1758 @Override
1759 public boolean supportsSchemasInTableDefinitions() throws SQLException {
1760 try {
1761 return databaseMetaData.supportsSchemasInTableDefinitions();
1762 } catch (final SQLException e) {
1763 handleException(e);
1764 return false;
1765 }
1766 }
1767
1768 @Override
1769 public boolean supportsSelectForUpdate() throws SQLException {
1770 try {
1771 return databaseMetaData.supportsSelectForUpdate();
1772 } catch (final SQLException e) {
1773 handleException(e);
1774 return false;
1775 }
1776 }
1777
1778 @Override
1779 public boolean supportsStatementPooling() throws SQLException {
1780 try {
1781 return databaseMetaData.supportsStatementPooling();
1782 } catch (final SQLException e) {
1783 handleException(e);
1784 return false;
1785 }
1786 }
1787
1788 @Override
1789 public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
1790 try {
1791 return databaseMetaData.supportsStoredFunctionsUsingCallSyntax();
1792 } catch (final SQLException e) {
1793 handleException(e);
1794 return false;
1795 }
1796 }
1797
1798 @Override
1799 public boolean supportsStoredProcedures() throws SQLException {
1800 try {
1801 return databaseMetaData.supportsStoredProcedures();
1802 } catch (final SQLException e) {
1803 handleException(e);
1804 return false;
1805 }
1806 }
1807
1808 @Override
1809 public boolean supportsSubqueriesInComparisons() throws SQLException {
1810 try {
1811 return databaseMetaData.supportsSubqueriesInComparisons();
1812 } catch (final SQLException e) {
1813 handleException(e);
1814 return false;
1815 }
1816 }
1817
1818 @Override
1819 public boolean supportsSubqueriesInExists() throws SQLException {
1820 try {
1821 return databaseMetaData.supportsSubqueriesInExists();
1822 } catch (final SQLException e) {
1823 handleException(e);
1824 return false;
1825 }
1826 }
1827
1828 @Override
1829 public boolean supportsSubqueriesInIns() throws SQLException {
1830 try {
1831 return databaseMetaData.supportsSubqueriesInIns();
1832 } catch (final SQLException e) {
1833 handleException(e);
1834 return false;
1835 }
1836 }
1837
1838 @Override
1839 public boolean supportsSubqueriesInQuantifieds() throws SQLException {
1840 try {
1841 return databaseMetaData.supportsSubqueriesInQuantifieds();
1842 } catch (final SQLException e) {
1843 handleException(e);
1844 return false;
1845 }
1846 }
1847
1848 @Override
1849 public boolean supportsTableCorrelationNames() throws SQLException {
1850 try {
1851 return databaseMetaData.supportsTableCorrelationNames();
1852 } catch (final SQLException e) {
1853 handleException(e);
1854 return false;
1855 }
1856 }
1857
1858 @Override
1859 public boolean supportsTransactionIsolationLevel(final int level) throws SQLException {
1860 try {
1861 return databaseMetaData.supportsTransactionIsolationLevel(level);
1862 } catch (final SQLException e) {
1863 handleException(e);
1864 return false;
1865 }
1866 }
1867
1868 @Override
1869 public boolean supportsTransactions() throws SQLException {
1870 try {
1871 return databaseMetaData.supportsTransactions();
1872 } catch (final SQLException e) {
1873 handleException(e);
1874 return false;
1875 }
1876 }
1877
1878 @Override
1879 public boolean supportsUnion() throws SQLException {
1880 try {
1881 return databaseMetaData.supportsUnion();
1882 } catch (final SQLException e) {
1883 handleException(e);
1884 return false;
1885 }
1886 }
1887
1888 @Override
1889 public boolean supportsUnionAll() throws SQLException {
1890 try {
1891 return databaseMetaData.supportsUnionAll();
1892 } catch (final SQLException e) {
1893 handleException(e);
1894 return false;
1895 }
1896 }
1897
1898 @Override
1899 public <T> T unwrap(final Class<T> iface) throws SQLException {
1900 if (iface.isAssignableFrom(getClass())) {
1901 return iface.cast(this);
1902 }
1903 if (iface.isAssignableFrom(databaseMetaData.getClass())) {
1904 return iface.cast(databaseMetaData);
1905 }
1906 return databaseMetaData.unwrap(iface);
1907 }
1908
1909 @Override
1910 public boolean updatesAreDetected(final int type) throws SQLException {
1911 try {
1912 return databaseMetaData.updatesAreDetected(type);
1913 } catch (final SQLException e) {
1914 handleException(e);
1915 return false;
1916 }
1917 }
1918
1919 @Override
1920 public boolean usesLocalFilePerTable() throws SQLException {
1921 try {
1922 return databaseMetaData.usesLocalFilePerTable();
1923 } catch (final SQLException e) {
1924 handleException(e);
1925 return false;
1926 }
1927 }
1928
1929 @Override
1930 public boolean usesLocalFiles() throws SQLException {
1931 try {
1932 return databaseMetaData.usesLocalFiles();
1933 } catch (final SQLException e) {
1934 handleException(e);
1935 return false;
1936 }
1937 }
1938 }