Java > Open Source Codes > com > nilostep > xlsql > jdbc > xlDatabaseMetaData


1 /*
2  * x l S Q L
3  * (c) Jim Caprioli, NiLOSTEP.com
4  * See xlSQL-license.txt for license details
5  *
6  */
7 package com.nilostep.xlsql.jdbc;
8
9 import java.sql.*;
10
11 public class xlDatabaseMetaData implements DatabaseMetaData, Constants {
12     //~ Static variables/initializers ··········································
13
14     private xlConnection xlCon;
15     private DatabaseMetaData dbMeta;
16
17     public static final int NOT_SUPPORTED = -1;
18
19     //~ Constructors ···························································
20
21     /** Creates a new instance of DatabaseMetaDataImpl */
22     protected xlDatabaseMetaData(xlConnection con, DatabaseMetaData meta) {
23         xlCon = con;
24         dbMeta = meta;
25     }
26
27     //~ Methods ································································
28
29     /**
30     * Implements method in interface java.sql.Connection
31     * @see java.sql.DatabaseMetaData#allProceduresAreCallable
32     */
33     public boolean allProceduresAreCallable() throws SQLException {
34         return dbMeta.allProceduresAreCallable();
35     }
36
37     /**
38     * Implements method in interface java.sql.Connection
39     * @see java.sql.DatabaseMetaData#allTablesAreSelectable
40     */
41     public boolean allTablesAreSelectable() throws SQLException {
42         return dbMeta.allTablesAreSelectable();
43     }
44
45     /**
46     * Implements method in interface java.sql.Connection
47     * @see java.sql.DatabaseMetaData#dataDefinitionCausesTransactionCommit
48     */
49     public boolean dataDefinitionCausesTransactionCommit()
50                                                   throws SQLException {
51         return dbMeta.dataDefinitionCausesTransactionCommit();
52     }
53
54     /**
55     * Implements method in interface java.sql.Connection
56     * @see java.sql.DatabaseMetaData#dataDefinitionIgnoredInTransactions
57     */
58     public boolean dataDefinitionIgnoredInTransactions()
59                                                 throws SQLException {
60         return dbMeta.dataDefinitionIgnoredInTransactions();
61     }
62
63     /**
64     * Implements method in interface java.sql.Connection
65     * @see java.sql.DatabaseMetaData#deletesAreDetected
66     */
67     public boolean deletesAreDetected(int type) throws SQLException {
68         return dbMeta.deletesAreDetected(type);
69     }
70
71     /**
72     * Implements method in interface java.sql.Connection
73     * @see java.sql.DatabaseMetaData#doesMaxRowSizeIncludeBlobs
74     */
75     public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
76         return dbMeta.doesMaxRowSizeIncludeBlobs();
77     }
78
79     /**
80     * Implements method in interface java.sql.Connection
81     * @see java.sql.DatabaseMetaData#getAttributes
82     */
83     public ResultSet getAttributes(String catalog, String schemaPattern,
84                                    String typeNamePattern,
85                                    String attributeNamePattern)
86                             throws SQLException {
87         return dbMeta.getAttributes(catalog, schemaPattern,
88                         typeNamePattern, attributeNamePattern);
89     }
90
91     /**
92     * Implements method in interface java.sql.Connection
93     * @see java.sql.DatabaseMetaData#getBestRowIdentifier
94     */
95     public ResultSet getBestRowIdentifier(String catalog, String schema,
96                                           String table, int scope,
97                                           boolean nullable)
98                                    throws SQLException {
99         return dbMeta.getBestRowIdentifier(catalog, schema,
100                                             table, scope, nullable);
101     }
102
103     /**
104     * Implements method in interface java.sql.Connection
105     * @see java.sql.DatabaseMetaData#getCatalogSeparator
106     */
107     public String getCatalogSeparator() throws SQLException {
108 //NiLOSTEP...
109 // [ ISSUE ]
110 return dbMeta.getCatalogSeparator();
111 //End
112 }
113
114     /**
115     * Implements method in interface java.sql.Connection
116     * @see java.sql.DatabaseMetaData#getCatalogTerm
117     */
118     public String getCatalogTerm() throws SQLException {
119 //NiLOSTEP...
120 // [ ISSUE ]
121 return dbMeta.getCatalogTerm();
122 //End
123 }
124
125     /**
126     * Implements method in interface java.sql.Connection
127     * @see java.sql.DatabaseMetaData#getCatalogs
128     */
129     public ResultSet getCatalogs() throws SQLException {
130 //NiLOSTEP...
131 // [ ISSUE ]
132 return dbMeta.getCatalogs();
133 // End
134 }
135
136     /**
137     * Implements method in interface java.sql.Connection
138     * @see java.sql.DatabaseMetaData#getColumnPrivileges
139     */
140     public ResultSet getColumnPrivileges(String catalog, String schema,
141                                          String table, String columnNamePattern)
142                                   throws SQLException {
143         return dbMeta.getColumnPrivileges(catalog, schema,
144                                             table, columnNamePattern);
145     }
146
147     /**
148     * Implements method in interface java.sql.Connection
149     * @see java.sql.DatabaseMetaData#getColumns
150     */
151     public ResultSet getColumns(String catalog, String schemaPattern,
152                                 String tableNamePattern,
153                                 String columnNamePattern)
154                          throws SQLException {
155         return dbMeta.getColumns(catalog, schemaPattern,
156                                 tableNamePattern, columnNamePattern);
157     }
158
159     /**
160     * Implements method in interface java.sql.Connection
161     * @see java.sql.DatabaseMetaData#getConnection
162     */
163     public Connection getConnection() throws SQLException {
164         return xlCon;
165     }
166
167     /**
168     * Implements method in interface java.sql.Connection
169     * @see java.sql.DatabaseMetaData#getCrossReference
170     */
171     public ResultSet getCrossReference(String primaryCatalog,
172                                        String primarySchema,
173                                        String primaryTable,
174                                        String foreignCatalog,
175                                        String foreignSchema,
176                                        String foreignTable)
177                                 throws SQLException {
178         return dbMeta.getCrossReference(primaryCatalog, primarySchema,
179                     primaryTable, foreignCatalog, foreignSchema, foreignTable);
180     }
181
182     /**
183     * Implements method in interface java.sql.Connection
184     * @see java.sql.DatabaseMetaData#getDatabaseMajorVersion
185     */
186     public int getDatabaseMajorVersion() throws SQLException {
187         return MAJOR_XLSQL_VERSION;
188     }
189
190     /**
191     * Implements method in interface java.sql.Connection
192     * @see java.sql.DatabaseMetaData#getDatabaseMinorVersion
193     */
194     public int getDatabaseMinorVersion() throws SQLException {
195         return MINOR_XLSQL_VERSION;
196     }
197
198     /**
199     * Implements method in interface java.sql.Connection
200     * @see java.sql.DatabaseMetaData#getDatabaseProductName
201     */
202     public String getDatabaseProductName() throws SQLException {
203         return XLSQL;
204     }
205
206     /**
207     * Implements method in interface java.sql.Connection
208     * @see java.sql.DatabaseMetaData#getDatabaseProductVersion
209     */
210     public String getDatabaseProductVersion() throws SQLException {
211         return XLSQL_RELEASE;
212     }
213
214     /**
215     * Implements method in interface java.sql.Connection
216     * @see java.sql.DatabaseMetaData#getDefaultTransactionIsolation
217     */
218     public int getDefaultTransactionIsolation() throws SQLException {
219         return dbMeta.getDefaultTransactionIsolation();
220     }
221
222     /**
223     * Implements method in interface java.sql.Connection
224     * @see java.sql.DatabaseMetaData#getDriverMajorVersion
225     */
226     public int getDriverMajorVersion() {
227         return MAJOR_VERSION;
228     }
229
230     /**
231     * Implements method in interface java.sql.Connection
232     * @see java.sql.DatabaseMetaData#getDriverMinorVersion
233     */
234     public int getDriverMinorVersion() {
235         return MINOR_VERSION;
236     }
237
238     /**
239     * Implements method in interface java.sql.Connection
240     * @see java.sql.DatabaseMetaData#getDriverName
241     */
242     public String getDriverName() throws SQLException {
243         return DRIVER_NAME;
244     }
245
246     /**
247     * Implements method in interface java.sql.Connection
248     * @see java.sql.DatabaseMetaData#getDriverVersion
249     */
250     public String getDriverVersion() throws SQLException {
251         return DRIVER_RELEASE;
252     }
253
254     /**
255     * Implements method in interface java.sql.Connection
256     * @see java.sql.DatabaseMetaData#getExportedKeys
257     */
258     public ResultSet getExportedKeys(String catalog, String schema,
259                                      String table) throws SQLException {
260         return dbMeta.getExportedKeys(catalog, schema, table);
261     }
262
263     /**
264     * Implements method in interface java.sql.Connection
265     * @see java.sql.DatabaseMetaData#getExtraNameCharacters
266     */
267     public String getExtraNameCharacters() throws SQLException {
268         return dbMeta.getExtraNameCharacters();
269     }
270
271     /**
272     * Implements method in interface java.sql.Connection
273     * @see java.sql.DatabaseMetaData#getIdentifierQuoteString
274     */
275     public String getIdentifierQuoteString() throws SQLException {
276         return dbMeta.getIdentifierQuoteString();
277     }
278
279     /**
280     * Implements method in interface java.sql.Connection
281     * @see java.sql.DatabaseMetaData#getImportedKeys
282     */
283     public ResultSet getImportedKeys(String catalog, String schema,
284                                      String table) throws SQLException {
285         return dbMeta.getImportedKeys(catalog, schema, table);
286     }
287
288     /**
289     * Implements method in interface java.sql.Connection
290     * @see java.sql.DatabaseMetaData#getIndexInfo
291     */
292     public ResultSet getIndexInfo(String catalog, String schema, String table,
293                                   boolean unique, boolean approximate)
294                            throws SQLException {
295         return dbMeta.getIndexInfo(catalog, schema, table, unique, approximate);
296     }
297
298     /**
299     * Implements method in interface java.sql.Connection
300     * @see java.sql.DatabaseMetaData#getJDBCMajorVersion
301     */
302     public int getJDBCMajorVersion() throws SQLException {
303         return JDBC_MAJOR_VERSION;
304     }
305
306     /**
307     * Implements method in interface java.sql.Connection
308     * @see java.sql.DatabaseMetaData#getJDBCMinorVersion
309     */
310     public int getJDBCMinorVersion() throws SQLException {
311         return JDBC_MINOR_VERSION;
312     }
313
314     /**
315     * Implements method in interface java.sql.Connection
316     * @see java.sql.DatabaseMetaData#getMaxBinaryLiteralLength
317     */
318     public int getMaxBinaryLiteralLength() throws SQLException {
319         return dbMeta.getMaxBinaryLiteralLength();
320     }
321
322     /**
323     * Implements method in interface java.sql.Connection
324     * @see java.sql.DatabaseMetaData#getMaxCatalogNameLength
325     */
326     public int getMaxCatalogNameLength() throws SQLException {
327 // NiLOSTEP...
328 // ( ISSUE )
329 return dbMeta.getMaxCatalogNameLength();
330 // End
331 }
332
333     /**
334     * Implements method in interface java.sql.Connection
335     * @see java.sql.DatabaseMetaData#getMaxCharLiteralLength
336     */
337     public int getMaxCharLiteralLength() throws SQLException {
338         return dbMeta.getMaxCharLiteralLength();
339     }
340
341     /**
342     * Implements method in interface java.sql.Connection
343     * @see java.sql.DatabaseMetaData#getMaxColumnNameLength
344     */
345     public int getMaxColumnNameLength() throws SQLException {
346         return dbMeta.getMaxColumnNameLength();
347     }
348
349     /**
350     * Implements method in interface java.sql.Connection
351     * @see java.sql.DatabaseMetaData#getMaxColumnsInGroupBy
352     */
353     public int getMaxColumnsInGroupBy() throws SQLException {
354         return dbMeta.getMaxColumnsInGroupBy();
355     }
356
357     /**
358     * Implements method in interface java.sql.Connection
359     * @see java.sql.DatabaseMetaData#getMaxColumnsInIndex
360     */
361     public int getMaxColumnsInIndex() throws SQLException {
362         return dbMeta.getMaxColumnsInIndex();
363     }
364
365     /**
366     * Implements method in interface java.sql.Connection
367     * @see java.sql.DatabaseMetaData#getMaxColumnsInOrderBy
368     */
369     public int getMaxColumnsInOrderBy() throws SQLException {
370         return dbMeta.getMaxColumnsInOrderBy();
371     }
372
373     /**
374     * Implements method in interface java.sql.Connection
375     * @see java.sql.DatabaseMetaData#getMaxColumnsInSelect
376     */
377     public int getMaxColumnsInSelect() throws SQLException {
378         return dbMeta.getMaxColumnsInSelect();
379     }
380
381     /**
382     * Implements method in interface java.sql.Connection
383     * @see java.sql.DatabaseMetaData#getMaxColumnsInTable
384     */
385     public int getMaxColumnsInTable() throws SQLException {
386 // NiLOSTEP...
387 // ISSUE
388 return 255;
389 // End
390 }
391
392     /**
393     * Implements method in interface java.sql.Connection
394     * @see java.sql.DatabaseMetaData#getMaxConnections
395     */
396     public int getMaxConnections() throws SQLException {
397 // NiLOSTEP...
398 // ISSUE
399 return 1;
400 //End
401 }
402     
403     /**
404     * Implements method in interface java.sql.Connection
405     * @see java.sql.DatabaseMetaData#getMaxCursorNameLength
406     */
407     public int getMaxCursorNameLength() throws SQLException {
408         return dbMeta.getMaxCursorNameLength();
409     }
410
411     /**
412     * Implements method in interface java.sql.Connection
413     * @see java.sql.DatabaseMetaData#getMaxIndexLength
414     */
415     public int getMaxIndexLength() throws SQLException {
416         return dbMeta.getMaxIndexLength();
417     }
418
419     /**
420     * Implements method in interface java.sql.Connection
421     * @see java.sql.DatabaseMetaData#getMaxProcedureNameLength
422     */
423     public int getMaxProcedureNameLength() throws SQLException {
424         return dbMeta.getMaxProcedureNameLength();
425     }
426
427     /**
428     * Implements method in interface java.sql.Connection
429     * @see java.sql.DatabaseMetaData#getMaxRowSize
430     */
431     public int getMaxRowSize() throws SQLException {
432         return dbMeta.getMaxRowSize();
433     }
434
435     /**
436     * Implements method in interface java.sql.Connection
437     * @see java.sql.DatabaseMetaData#getMaxSchemaNameLength
438     */
439     public int getMaxSchemaNameLength() throws SQLException {
440         return dbMeta.getMaxSchemaNameLength();
441     }
442
443     /**
444     * Implements method in interface java.sql.Connection
445     * @see java.sql.DatabaseMetaData#getMaxStatementLength
446     */
447     public int getMaxStatementLength() throws SQLException {
448         return dbMeta.getMaxStatementLength();
449     }
450
451     /**
452     * Implements method in interface java.sql.Connection
453     * @see java.sql.DatabaseMetaData#getMaxStatements
454     */
455     public int getMaxStatements() throws SQLException {
456         return dbMeta.getMaxStatements();
457     }
458
459     /**
460     * Implements method in interface java.sql.Connection
461     * @see java.sql.DatabaseMetaData#getMaxTableNameLength
462     */
463     public int getMaxTableNameLength() throws SQLException {
464         return dbMeta.getMaxTableNameLength();
465     }
466
467     /**
468     * Implements method in interface java.sql.Connection
469     * @see java.sql.DatabaseMetaData#getMaxTablesInSelect
470     */
471     public int getMaxTablesInSelect() throws SQLException {
472         return dbMeta.getMaxTablesInSelect();
473     }
474
475     /**
476     * Implements method in interface java.sql.Connection
477     * @see java.sql.DatabaseMetaData#getMaxUserNameLength
478     */
479     public int getMaxUserNameLength() throws SQLException {
480         return dbMeta.getMaxUserNameLength();
481     }
482
483     /**
484     * Implements method in interface java.sql.Connection
485     * @see java.sql.DatabaseMetaData#getNumericFunctions
486     */
487     public String getNumericFunctions() throws SQLException {
488         return dbMeta.getNumericFunctions();
489     }
490
491     /**
492     * Implements method in interface java.sql.Connection
493     * @see java.sql.DatabaseMetaData#getPrimaryKeys
494     */
495     public ResultSet getPrimaryKeys(String catalog, String schema, String table)
496                              throws SQLException {
497         return dbMeta.getPrimaryKeys(catalog, schema, table);
498     }
499
500     /**
501     * Implements method in interface java.sql.Connection
502     * @see java.sql.DatabaseMetaData#getProcedureColumns
503     */
504     public ResultSet getProcedureColumns(String catalog, String schemaPattern,
505                                          String procedureNamePattern,
506                                          String columnNamePattern)
507                                   throws SQLException {
508         return dbMeta.getProcedureColumns(catalog, schemaPattern,
509                                     procedureNamePattern, columnNamePattern);
510     }
511
512     /**
513     * Implements method in interface java.sql.Connection
514     * @see java.sql.DatabaseMetaData#getProcedureTerm
515     */
516     public String getProcedureTerm() throws SQLException {
517         return dbMeta.getProcedureTerm();
518     }
519
520     /**
521     * Implements method in interface java.sql.Connection
522     * @see java.sql.DatabaseMetaData#getProcedures
523     */
524     public ResultSet getProcedures(String catalog, String schemaPattern,
525                                    String procedureNamePattern)
526                             throws SQLException {
527         return dbMeta.getProcedures(catalog, schemaPattern,
528                                                 procedureNamePattern);
529     }
530
531     /**
532     * Implements method in interface java.sql.Connection
533     * @see java.sql.DatabaseMetaData#getResultSetHoldability
534     */
535     public int getResultSetHoldability() throws SQLException {
536         return dbMeta.getResultSetHoldability();
537     }
538
539     /**
540     * Implements method in interface java.sql.Connection
541     * @see java.sql.DatabaseMetaData#getSQLKeywords
542     */
543     public String getSQLKeywords() throws SQLException {
544         return dbMeta.getSQLKeywords();
545     }
546
547     /**
548     * Implements method in interface java.sql.Connection
549     * @see java.sql.DatabaseMetaData#getSQLStateType
550     */
551     public int getSQLStateType() throws SQLException {
552         return dbMeta.getSQLStateType();
553     }
554
555     /**
556     * Implements method in interface java.sql.Connection
557     * @see java.sql.DatabaseMetaData#getSchemaTerm
558     */
559     public String getSchemaTerm() throws SQLException {
560         return dbMeta.getSchemaTerm();
561     }
562
563     /**
564     * Implements method in interface java.sql.Connection
565     * @see java.sql.DatabaseMetaData#getSchemas
566     */
567     public ResultSet getSchemas() throws SQLException {
568 //NiLOSTEP...
569 // [ ISSUE ]
570 //End
571 return dbMeta.getSchemas();
572     }
573
574     /**
575     * Implements method in interface java.sql.Connection
576     * @see java.sql.DatabaseMetaData#getSearchStringEscape
577     */
578     public String getSearchStringEscape() throws SQLException {
579         return dbMeta.getSearchStringEscape();
580     }
581
582     /**
583     * Implements method in interface java.sql.Connection
584     * @see java.sql.DatabaseMetaData#getStringFunctions
585     */
586     public String getStringFunctions() throws SQLException {
587         return dbMeta.getStringFunctions();
588     }
589
590     /**
591     * Implements method in interface java.sql.Connection
592     * @see java.sql.DatabaseMetaData#getSuperTables
593     */
594     public ResultSet getSuperTables(String catalog, String schemaPattern,
595                                     String tableNamePattern)
596                              throws SQLException {
597          return dbMeta.getSuperTables(catalog, schemaPattern, tableNamePattern);
598     }
599
600     /**
601     * Implements method in interface java.sql.Connection
602     * @see java.sql.DatabaseMetaData#getSuperTypes
603     */
604     public ResultSet getSuperTypes(String catalog, String schemaPattern,
605                                    String typeNamePattern)
606                             throws SQLException {
607
608         return dbMeta.getSuperTypes(catalog, schemaPattern, typeNamePattern);
609     }
610
611     /**
612     * Implements method in interface java.sql.Connection
613     * @see java.sql.DatabaseMetaData#getSystemFunctions
614     */
615     public String getSystemFunctions() throws SQLException {
616          return dbMeta.getSystemFunctions();
617     }
618
619     /**
620     * Implements method in interface java.sql.Connection
621     * @see java.sql.DatabaseMetaData#getTablePrivileges
622     */
623     public ResultSet getTablePrivileges(String catalog, String schemaPattern,
624                                         String tableNamePattern)
625                                  throws SQLException {
626          return dbMeta.getTablePrivileges(catalog, schemaPattern,
627                                                     tableNamePattern);
628     }
629
630     /**
631     * Implements method in interface java.sql.Connection
632     * @see java.sql.DatabaseMetaData#getTableTypes
633     */
634     public ResultSet getTableTypes() throws SQLException {
635         return dbMeta.getTableTypes();
636     }
637
638     /**
639     * Implements method in interface java.sql.Connection
640     * @see java.sql.DatabaseMetaData#getTables
641     */
642     public ResultSet getTables(String catalog, String schemaPattern,
643                                String tableNamePattern, String [] types)
644                         throws SQLException {
645         return dbMeta.getTables(catalog, schemaPattern, tableNamePattern, types);
646     }
647
648     /**
649     * Implements method in interface java.sql.Connection
650     * @see java.sql.DatabaseMetaData#getTimeDateFunctions
651     */
652     public String getTimeDateFunctions() throws SQLException {
653          return dbMeta.getTimeDateFunctions();
654     }
655
656     /**
657     * Implements method in interface java.sql.Connection
658     * @see java.sql.DatabaseMetaData#getTypeInfo
659     */
660     public ResultSet getTypeInfo() throws SQLException {
661          return dbMeta.getTypeInfo();
662     }
663
664     /**
665     * Implements method in interface java.sql.Connection
666     * @see java.sql.DatabaseMetaData#getUDTs
667     */
668     public ResultSet getUDTs(String catalog, String schemaPattern,
669                              String typeNamePattern, int[] types)
670                       throws SQLException {
671         return dbMeta.getUDTs(catalog, schemaPattern, typeNamePattern, types);
672     }
673
674     /**
675     * Implements method in interface java.sql.Connection
676     * @see java.sql.DatabaseMetaData#getURL
677     */
678     public String getURL() throws SQLException {
679         return xlCon.URL;
680     }
681
682     /**
683     * Implements method in interface java.sql.Connection
684     * @see java.sql.DatabaseMetaData#getUserName
685     */
686     public String getUserName() throws SQLException {
687 // NiLOSTEP...
688 // [ ISSUE ]
689 //
690 return null;
691     }
692
693     /**
694     * Implements method in interface java.sql.Connection
695     * @see java.sql.DatabaseMetaData#getVersionColumns
696     */
697     public ResultSet getVersionColumns(String catalog, String schema,
698                                        String table) throws SQLException {
699         return dbMeta.getVersionColumns(catalog, schema, table);
700     }
701
702     /**
703     * Implements method in interface java.sql.Connection
704     * @see java.sql.DatabaseMetaData#insertsAreDetected
705     */
706     public boolean insertsAreDetected(int type) throws SQLException {
707         return dbMeta.insertsAreDetected(type);
708     }
709
710     /**
711     * Implements method in interface java.sql.Connection
712     * @see java.sql.DatabaseMetaData#isCatalogAtStart
713     */
714     public boolean isCatalogAtStart() throws SQLException {
715         return dbMeta.isCatalogAtStart();
716     }
717
718     /**
719     * Implements method in interface java.sql.Connection
720     * @see java.sql.DatabaseMetaData#isReadOnly
721     */
722     public boolean isReadOnly() throws SQLException {
723         return dbMeta.isReadOnly();
724     }
725
726     /**
727     * Implements method in interface java.sql.Connection
728     * @see java.sql.DatabaseMetaData#locatorsUpdateCopy
729     */
730     public boolean locatorsUpdateCopy() throws SQLException {
731         return dbMeta.locatorsUpdateCopy();
732     }
733
734     /**
735     * Implements method in interface java.sql.Connection
736     * @see java.sql.DatabaseMetaData#nullPlusNonNullIsNull
737     */
738     public boolean nullPlusNonNullIsNull() throws SQLException {
739         return dbMeta.nullPlusNonNullIsNull();
740     }
741
742     /**
743     * Implements method in interface java.sql.Connection
744     * @see java.sql.DatabaseMetaData#nullsAreSortedAtEnd
745     */
746     public boolean nullsAreSortedAtEnd() throws SQLException {
747         return dbMeta.nullsAreSortedAtEnd();
748     }
749
750     /**
751     * Implements method in interface java.sql.Connection
752     * @see java.sql.DatabaseMetaData#nullsAreSortedAtStart
753     */
754     public boolean nullsAreSortedAtStart() throws SQLException {
755         return dbMeta.nullsAreSortedAtStart();
756     }
757
758     /**
759     * Implements method in interface java.sql.Connection
760     * @see java.sql.DatabaseMetaData#nullsAreSortedHigh
761     */
762     public boolean nullsAreSortedHigh() throws SQLException {
763         return dbMeta.nullsAreSortedHigh();
764     }
765
766     /**
767     * Implements method in interface java.sql.Connection
768     * @see java.sql.DatabaseMetaData#nullsAreSortedLow
769     */
770     public boolean nullsAreSortedLow() throws SQLException {
771         return dbMeta.nullsAreSortedLow();
772     }
773
774     /**
775     * Implements method in interface java.sql.Connection
776     * @see java.sql.DatabaseMetaData#othersDeletesAreVisible
777     */
778     public boolean othersDeletesAreVisible(int type) throws SQLException {
779         return dbMeta.othersDeletesAreVisible(type);
780     }
781
782     /**
783     * Implements method in interface java.sql.Connection
784     * @see java.sql.DatabaseMetaData#othersInsertsAreVisible
785     */
786     public boolean othersInsertsAreVisible(int type) throws SQLException {
787         return dbMeta.othersInsertsAreVisible(type);
788     }
789
790     /**
791     * Implements method in interface java.sql.Connection
792     * @see java.sql.DatabaseMetaData#othersUpdatesAreVisible
793     */
794     public boolean othersUpdatesAreVisible(int type) throws SQLException {
795         return dbMeta.othersUpdatesAreVisible(type);
796     }
797
798     /**
799     * Implements method in interface java.sql.Connection
800     * @see java.sql.DatabaseMetaData#ownDeletesAreVisible
801     */
802     public boolean ownDeletesAreVisible(int type) throws SQLException {
803         return dbMeta.ownDeletesAreVisible(type);
804     }
805
806     /**
807     * Implements method in interface java.sql.Connection
808     * @see java.sql.DatabaseMetaData#ownInsertsAreVisible
809     */
810     public boolean ownInsertsAreVisible(int type) throws SQLException {
811         return dbMeta.ownInsertsAreVisible(type);
812     }
813
814     /**
815     * Implements method in interface java.sql.Connection
816     * @see java.sql.DatabaseMetaData#ownUpdatesAreVisible
817     */
818     public boolean ownUpdatesAreVisible(int type) throws SQLException {
819         return dbMeta.ownUpdatesAreVisible(type);
820     }
821
822     /**
823     * Implements method in interface java.sql.Connection
824     * @see java.sql.DatabaseMetaData#storesLowerCaseIdentifiers
825     */
826     public boolean storesLowerCaseIdentifiers() throws SQLException {
827         return dbMeta.storesLowerCaseIdentifiers();
828     }
829
830     /**
831     * Implements method in interface java.sql.Connection
832     * @see java.sql.DatabaseMetaData#storesLowerCaseQuotedIdentifiers
833     */
834     public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
835         return dbMeta.storesLowerCaseQuotedIdentifiers();
836     }
837
838     /**
839     * Implements method in interface java.sql.Connection
840     * @see java.sql.DatabaseMetaData#storesMixedCaseIdentifiers
841     */
842     public boolean storesMixedCaseIdentifiers() throws SQLException {
843         return dbMeta.storesMixedCaseIdentifiers();
844     }
845
846     /**
847     * Implements method in interface java.sql.Connection
848     * @see java.sql.DatabaseMetaData#storesMixedCaseQuotedIdentifiers
849     */
850     public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
851         return dbMeta.storesMixedCaseQuotedIdentifiers();
852     }
853
854     /**
855     * Implements method in interface java.sql.Connection
856     * @see java.sql.DatabaseMetaData#storesUpperCaseIdentifiers
857     */
858     public boolean storesUpperCaseIdentifiers() throws SQLException {
859         return dbMeta.storesUpperCaseIdentifiers();
860     }
861
862     /**
863     * Implements method in interface java.sql.Connection
864     * @see java.sql.DatabaseMetaData#storesUpperCaseQuotedIdentifiers
865     */
866     public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
867         return dbMeta.storesUpperCaseQuotedIdentifiers();
868     }
869
870     /**
871     * Implements method in interface java.sql.Connection
872     * @see java.sql.DatabaseMetaData#supportsANSI92EntryLevelSQL
873     */
874     public boolean supportsANSI92EntryLevelSQL() throws SQLException {
875         return dbMeta.supportsANSI92EntryLevelSQL();
876     }
877
878     /**
879     * Implements method in interface java.sql.Connection
880     * @see java.sql.DatabaseMetaData#supportsANSI92FullSQL
881     */
882     public boolean supportsANSI92FullSQL() throws SQLException {
883         return dbMeta.supportsANSI92FullSQL();
884     }
885
886     /**
887     * Implements method in interface java.sql.Connection
888     * @see java.sql.DatabaseMetaData#supportsANSI92IntermediateSQL
889     */
890     public boolean supportsANSI92IntermediateSQL() throws SQLException {
891         return dbMeta.supportsANSI92IntermediateSQL();
892     }
893
894     /**
895     * Implements method in interface java.sql.Connection
896     * @see java.sql.DatabaseMetaData#supportsAlterTableWithAddColumn
897     */
898     public boolean supportsAlterTableWithAddColumn() throws SQLException {
899         return dbMeta.supportsAlterTableWithAddColumn();
900     }
901
902     /**
903     * Implements method in interface java.sql.Connection
904     * @see java.sql.DatabaseMetaData#supportsAlterTableWithDropColumn
905     */
906     public boolean supportsAlterTableWithDropColumn() throws SQLException {
907         return dbMeta.supportsAlterTableWithDropColumn();
908     }
909
910     /**
911     * Implements method in interface java.sql.Connection
912     * @see java.sql.DatabaseMetaData#supportsBatchUpdates
913     */
914     public boolean supportsBatchUpdates() throws SQLException {
915         return dbMeta.supportsBatchUpdates();
916     }
917
918     /**
919     * Implements method in interface java.sql.Connection
920     * @see java.sql.DatabaseMetaData#supportsCatalogsInDataManipulation
921     */
922     public boolean supportsCatalogsInDataManipulation()
923                                                throws SQLException {
924         return dbMeta.supportsCatalogsInDataManipulation();
925     }
926
927     /**
928     * Implements method in interface java.sql.Connection
929     * @see java.sql.DatabaseMetaData#supportsCatalogsInIndexDefinitions
930     */
931     public boolean supportsCatalogsInIndexDefinitions()
932                                                throws SQLException {
933         return dbMeta.supportsCatalogsInIndexDefinitions();
934     }
935
936     /**
937     * Implements method in interface java.sql.Connection
938     * @see java.sql.DatabaseMetaData#supportsCatalogsInPrivilegeDefinitions
939     */
940     public boolean supportsCatalogsInPrivilegeDefinitions()
941                                                    throws SQLException {
942         return dbMeta.supportsCatalogsInPrivilegeDefinitions();
943     }
944
945     /**
946     * Implements method in interface java.sql.Connection
947     * @see java.sql.DatabaseMetaData#supportsCatalogsInProcedureCalls
948     */
949     public boolean supportsCatalogsInProcedureCalls() throws SQLException {
950         return dbMeta.supportsCatalogsInProcedureCalls();
951     }
952
953     /**
954     * Implements method in interface java.sql.Connection
955     * @see java.sql.DatabaseMetaData#supportsCatalogsInTableDefinitions
956     */
957     public boolean supportsCatalogsInTableDefinitions()
958                                                throws SQLException {
959         return dbMeta.supportsCatalogsInTableDefinitions();
960     }
961
962     /**
963     * Implements method in interface java.sql.Connection
964     * @see java.sql.DatabaseMetaData#supportsColumnAliasing
965     */
966     public boolean supportsColumnAliasing() throws SQLException {
967         return dbMeta.supportsColumnAliasing();
968     }
969
970     /**
971     * Implements method in interface java.sql.Connection
972     * @see java.sql.DatabaseMetaData#supportsConvert
973     */
974     public boolean supportsConvert() throws SQLException {
975         return dbMeta.supportsConvert();
976     }
977
978     /**
979     * Implements method in interface java.sql.Connection
980     * @see java.sql.DatabaseMetaData#supportsConvert
981     */
982     public boolean supportsConvert(int fromType, int toType)
983                             throws SQLException {
984         return dbMeta.supportsConvert(fromType, toType);
985     }
986
987     /**
988     * Implements method in interface java.sql.Connection
989     * @see java.sql.DatabaseMetaData#supportsCoreSQLGrammar
990     */
991     public boolean supportsCoreSQLGrammar() throws SQLException {
992         return dbMeta.supportsCoreSQLGrammar();
993     }
994
995     /**
996     * Implements method in interface java.sql.Connection
997     * @see java.sql.DatabaseMetaData#supportsCorrelatedSubqueries
998     */
999     public boolean supportsCorrelatedSubqueries() throws SQLException {
1000        return dbMeta.supportsCorrelatedSubqueries();
1001    }
1002
1003    /**
1004    * Implements method in interface java.sql.Connection
1005    * @see java.sql.DatabaseMetaData#supportsDataDefinitionAndDataManipulationTransactions
1006    */
1007    public boolean supportsDataDefinitionAndDataManipulationTransactions()
1008        throws SQLException {
1009        return dbMeta.supportsDataDefinitionAndDataManipulationTransactions();
1010    }
1011
1012    /**
1013    * Implements method in interface java.sql.Connection
1014    * @see java.sql.DatabaseMetaData#supportsDataManipulationTransactionsOnly
1015    */
1016    public boolean supportsDataManipulationTransactionsOnly()
1017                                                     throws SQLException {
1018        return dbMeta.supportsDataManipulationTransactionsOnly();
1019    }
1020
1021    /**
1022    * Implements method in interface java.sql.Connection
1023    * @see java.sql.DatabaseMetaData#supportsDifferentTableCorrelationNames
1024    */
1025    public boolean supportsDifferentTableCorrelationNames()
1026                                                   throws SQLException {
1027        return dbMeta.supportsDifferentTableCorrelationNames();
1028    }
1029
1030    /**
1031    * Implements method in interface java.sql.Connection
1032    * @see java.sql.DatabaseMetaData#supportsExpressionsInOrderBy
1033    */
1034    public boolean supportsExpressionsInOrderBy() throws SQLException {
1035        return dbMeta.supportsExpressionsInOrderBy();
1036    }
1037
1038    /**
1039    * Implements method in interface java.sql.Connection
1040    * @see java.sql.DatabaseMetaData#supportsExtendedSQLGrammar
1041    */
1042    public boolean supportsExtendedSQLGrammar() throws SQLException {
1043        return dbMeta.supportsExtendedSQLGrammar();
1044    }
1045
1046    /**
1047    * Implements method in interface java.sql.Connection
1048    * @see java.sql.DatabaseMetaData#supportsFullOuterJoins
1049    */
1050    public boolean supportsFullOuterJoins() throws SQLException {
1051        return dbMeta.supportsFullOuterJoins();
1052    }
1053
1054    /**
1055    * Implements method in interface java.sql.Connection
1056    * @see java.sql.DatabaseMetaData#supportsGetGeneratedKeys
1057    */
1058    public boolean supportsGetGeneratedKeys() throws SQLException {
1059        return dbMeta.supportsGetGeneratedKeys();
1060    }
1061
1062    /**
1063    * Implements method in interface java.sql.Connection
1064    * @see java.sql.DatabaseMetaData#supportsGroupBy
1065    */
1066    public boolean supportsGroupBy() throws SQLException {
1067        return dbMeta.supportsGroupBy();
1068    }
1069
1070    /**
1071    * Implements method in interface java.sql.Connection
1072    * @see java.sql.DatabaseMetaData#supportsGroupByBeyondSelect
1073    */
1074    public boolean supportsGroupByBeyondSelect() throws SQLException {
1075        return dbMeta.supportsGroupByBeyondSelect();
1076    }
1077
1078    /**
1079    * Implements method in interface java.sql.Connection
1080    * @see java.sql.DatabaseMetaData#supportsGroupByUnrelated
1081    */
1082    public boolean supportsGroupByUnrelated() throws SQLException {
1083        return dbMeta.supportsGroupByUnrelated();
1084    }
1085
1086    /**
1087    * Implements method in interface java.sql.Connection
1088    * @see java.sql.DatabaseMetaData#supportsIntegrityEnhancementFacility
1089    */
1090    public boolean supportsIntegrityEnhancementFacility()
1091                                                 throws SQLException {
1092        return dbMeta.supportsIntegrityEnhancementFacility();
1093    }
1094
1095    /**
1096    * Implements method in interface java.sql.Connection
1097    * @see java.sql.DatabaseMetaData#supportsLikeEscapeClause
1098    */
1099    public boolean supportsLikeEscapeClause() throws SQLException {
1100        return dbMeta.supportsLikeEscapeClause();
1101    }
1102
1103    /**
1104    * Implements method in interface java.sql.Connection
1105    * @see java.sql.DatabaseMetaData#supportsLimitedOuterJoins
1106    */
1107    public boolean supportsLimitedOuterJoins() throws SQLException {
1108        return dbMeta.supportsLimitedOuterJoins();
1109    }
1110
1111    /**
1112    * Implements method in interface java.sql.Connection
1113    * @see java.sql.DatabaseMetaData#supportsMinimumSQLGrammar
1114    */
1115    public boolean supportsMinimumSQLGrammar() throws SQLException {
1116        return dbMeta.supportsMinimumSQLGrammar();
1117    }
1118
1119    /**
1120    * Implements method in interface java.sql.Connection
1121    * @see java.sql.DatabaseMetaData#supportsMixedCaseIdentifiers
1122    */
1123    public boolean supportsMixedCaseIdentifiers() throws SQLException {
1124        return dbMeta.supportsMixedCaseIdentifiers();
1125    }
1126
1127    /**
1128    * Implements method in interface java.sql.Connection
1129    * @see java.sql.DatabaseMetaData#supportsMixedCaseQuotedIdentifiers
1130    */
1131    public boolean supportsMixedCaseQuotedIdentifiers()
1132                                               throws SQLException {
1133        return dbMeta.supportsMixedCaseQuotedIdentifiers();
1134    }
1135
1136    /**
1137    * Implements method in interface java.sql.Connection
1138    * @see java.sql.DatabaseMetaData#supportsMultipleOpenResults
1139    */
1140    public boolean supportsMultipleOpenResults() throws SQLException {
1141        return dbMeta.supportsMultipleOpenResults();
1142    }
1143
1144    /**
1145    * Implements method in interface java.sql.Connection
1146    * @see java.sql.DatabaseMetaData#supportsMultipleResultSets
1147    */
1148    public boolean supportsMultipleResultSets() throws SQLException {
1149        return dbMeta.supportsMultipleResultSets();
1150    }
1151
1152    /**
1153    * Implements method in interface java.sql.Connection
1154    * @see java.sql.DatabaseMetaData#supportsMultipleTransactions
1155    */
1156    public boolean supportsMultipleTransactions() throws SQLException {
1157        return dbMeta.supportsMultipleTransactions();
1158    }
1159
1160    /**
1161    * Implements method in interface java.sql.Connection
1162    * @see java.sql.DatabaseMetaData#supportsNamedParameters
1163    */
1164    public boolean supportsNamedParameters() throws SQLException {
1165        return dbMeta.supportsNamedParameters();
1166    }
1167
1168    /**
1169    * Implements method in interface java.sql.Connection
1170    * @see java.sql.DatabaseMetaData#supportsNonNullableColumns
1171    */
1172    public boolean supportsNonNullableColumns() throws SQLException {
1173        return dbMeta.supportsNonNullableColumns();
1174    }
1175
1176    /**
1177    * Implements method in interface java.sql.Connection
1178    * @see java.sql.DatabaseMetaData#supportsOpenCursorsAcrossCommit
1179    */
1180    public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
1181        return dbMeta.supportsOpenCursorsAcrossCommit();
1182    }
1183
1184    /**
1185    * Implements method in interface java.sql.Connection
1186    * @see java.sql.DatabaseMetaData#supportsOpenCursorsAcrossRollback
1187    */
1188    public boolean supportsOpenCursorsAcrossRollback()
1189                                              throws SQLException {
1190        return dbMeta.supportsOpenCursorsAcrossRollback();
1191    }
1192
1193    /**
1194    * Implements method in interface java.sql.Connection
1195    * @see java.sql.DatabaseMetaData#supportsOpenStatementsAcrossCommit
1196    */
1197    public boolean supportsOpenStatementsAcrossCommit()
1198                                               throws SQLException {
1199        return dbMeta.supportsOpenStatementsAcrossCommit();
1200    }
1201
1202    /**
1203    * Implements method in interface java.sql.Connection
1204    * @see java.sql.DatabaseMetaData#supportsOpenStatementsAcrossRollback
1205    */
1206    public boolean supportsOpenStatementsAcrossRollback()
1207                                                 throws SQLException {
1208        return dbMeta.supportsOpenStatementsAcrossRollback();
1209    }
1210
1211    /**
1212    * Implements method in interface java.sql.Connection
1213    * @see java.sql.DatabaseMetaData#supportsOrderByUnrelated
1214    */
1215    public boolean supportsOrderByUnrelated() throws SQLException {
1216        return dbMeta.supportsOrderByUnrelated();
1217    }
1218
1219    /**
1220    * Implements method in interface java.sql.Connection
1221    * @see java.sql.DatabaseMetaData#supportsOuterJoins
1222    */
1223    public boolean supportsOuterJoins() throws SQLException {
1224        return dbMeta.supportsOuterJoins();
1225    }
1226
1227    /**
1228    * Implements method in interface java.sql.Connection
1229    * @see java.sql.DatabaseMetaData#supportsPositionedDelete
1230    */
1231    public boolean supportsPositionedDelete() throws SQLException {
1232        return dbMeta.supportsPositionedDelete();
1233    }
1234
1235    /**
1236    * Implements method in interface java.sql.Connection
1237    * @see java.sql.DatabaseMetaData#supportsPositionedUpdate
1238    */
1239    public boolean supportsPositionedUpdate() throws SQLException {
1240        return dbMeta.supportsPositionedUpdate();
1241    }
1242
1243    /**
1244    * Implements method in interface java.sql.Connection
1245    * @see java.sql.DatabaseMetaData#supportsResultSetConcurrency
1246    */
1247    public boolean supportsResultSetConcurrency(int type, int concurrency)
1248                                         throws SQLException {
1249        return dbMeta.supportsResultSetConcurrency(type, concurrency);
1250    }
1251
1252    /**
1253    * Implements method in interface java.sql.Connection
1254    * @see java.sql.DatabaseMetaData#supportsResultSetHoldability
1255    */
1256    public boolean supportsResultSetHoldability(int holdability)
1257                                         throws SQLException {
1258        return dbMeta.supportsResultSetHoldability(holdability);
1259    }
1260
1261    /**
1262    * Implements method in interface java.sql.Connection
1263    * @see java.sql.DatabaseMetaData#supportsResultSetType
1264    */
1265    public boolean supportsResultSetType(int type) throws SQLException {
1266        return dbMeta.supportsResultSetType(type);
1267    }
1268
1269    /**
1270    * Implements method in interface java.sql.Connection
1271    * @see java.sql.DatabaseMetaData#supportsSavepoints
1272    */
1273    public boolean supportsSavepoints() throws SQLException {
1274        return dbMeta.supportsSavepoints();
1275    }
1276
1277    /**
1278    * Implements method in interface java.sql.Connection
1279    * @see java.sql.DatabaseMetaData#supportsSchemasInDataManipulation
1280    */
1281    public boolean supportsSchemasInDataManipulation()
1282                                              throws SQLException {
1283        return dbMeta.supportsSchemasInDataManipulation();
1284    }
1285
1286    /**
1287    * Implements method in interface java.sql.Connection
1288    * @see java.sql.DatabaseMetaData#supportsSchemasInIndexDefinitions
1289    */
1290    public boolean supportsSchemasInIndexDefinitions()
1291                                              throws SQLException {
1292        return dbMeta.supportsSchemasInIndexDefinitions();
1293    }
1294
1295    /**
1296    * Implements method in interface java.sql.Connection
1297    * @see java.sql.DatabaseMetaData#supportsSchemasInPrivilegeDefinitions
1298    */
1299    public boolean supportsSchemasInPrivilegeDefinitions()
1300                                                  throws SQLException {
1301        return dbMeta.supportsSchemasInPrivilegeDefinitions();
1302    }
1303
1304    /**
1305    * Implements method in interface java.sql.Connection
1306    * @see java.sql.DatabaseMetaData#supportsSchemasInProcedureCalls
1307    */
1308    public boolean supportsSchemasInProcedureCalls() throws SQLException {
1309        return dbMeta.supportsSchemasInProcedureCalls();
1310    }
1311
1312    /**
1313    * Implements method in interface java.sql.Connection
1314    * @see java.sql.DatabaseMetaData#supportsSchemasInTableDefinitions
1315    */
1316    public boolean supportsSchemasInTableDefinitions()
1317                                              throws SQLException {
1318        return dbMeta.supportsSchemasInTableDefinitions();
1319    }
1320
1321    /**
1322    * Implements method in interface java.sql.Connection
1323    * @see java.sql.DatabaseMetaData#supportsSelectForUpdate
1324    */
1325    public boolean supportsSelectForUpdate() throws SQLException {
1326        return dbMeta.supportsSelectForUpdate();
1327    }
1328
1329    /**
1330    * Implements method in interface java.sql.Connection
1331    * @see java.sql.DatabaseMetaData#supportsStatementPooling
1332    */
1333    public boolean supportsStatementPooling() throws SQLException {
1334        return dbMeta.supportsStatementPooling();
1335    }
1336
1337    /**
1338    * Implements method in interface java.sql.Connection
1339    * @see java.sql.DatabaseMetaData#supportsStoredProcedures
1340    */
1341    public boolean supportsStoredProcedures() throws SQLException {
1342        return dbMeta.supportsStoredProcedures();
1343    }
1344
1345    /**
1346    * Implements method in interface java.sql.Connection
1347    * @see java.sql.DatabaseMetaData#supportsSubqueriesInComparisons
1348    */
1349    public boolean supportsSubqueriesInComparisons() throws SQLException {
1350        return dbMeta.supportsSubqueriesInComparisons();
1351    }
1352
1353    /**
1354    * Implements method in interface java.sql.Connection
1355    * @see java.sql.DatabaseMetaData#supportsSubqueriesInExists
1356    */
1357    public boolean supportsSubqueriesInExists() throws SQLException {
1358        return dbMeta.supportsSubqueriesInExists();
1359    }
1360
1361    /**
1362    * Implements method in interface java.sql.Connection
1363    * @see java.sql.DatabaseMetaData#supportsSubqueriesInIns
1364    */
1365    public boolean supportsSubqueriesInIns() throws SQLException {
1366        return dbMeta.supportsSubqueriesInIns();
1367    }
1368
1369    /**
1370    * Implements method in interface java.sql.Connection
1371    * @see java.sql.DatabaseMetaData#supportsSubqueriesInQuantifieds
1372    */
1373    public boolean supportsSubqueriesInQuantifieds() throws SQLException {
1374        return dbMeta.supportsSubqueriesInQuantifieds();
1375    }
1376
1377    /**
1378    * Implements method in interface java.sql.Connection
1379    * @see java.sql.DatabaseMetaData#supportsTableCorrelationNames
1380    */
1381    public boolean supportsTableCorrelationNames() throws SQLException {
1382        return dbMeta.supportsTableCorrelationNames();
1383    }
1384
1385    /**
1386    * Implements method in interface java.sql.Connection
1387    * @see java.sql.DatabaseMetaData#supportsTransactionIsolationLevel
1388    */
1389    public boolean supportsTransactionIsolationLevel(int level)
1390                                              throws SQLException {
1391        return dbMeta.supportsTransactionIsolationLevel(level);
1392    }
1393
1394    /**
1395    * Implements method in interface java.sql.Connection
1396    * @see java.sql.DatabaseMetaData#supportsTransactions
1397    */
1398    public boolean supportsTransactions() throws SQLException {
1399        return dbMeta.supportsTransactions();
1400    }
1401
1402    /**
1403    * Implements method in interface java.sql.Connection
1404    * @see java.sql.DatabaseMetaData#supportsUnion
1405    */
1406    public boolean supportsUnion() throws SQLException {
1407        return dbMeta.supportsUnion();
1408    }
1409
1410    /**
1411    * Implements method in interface java.sql.Connection
1412    * @see java.sql.DatabaseMetaData#supportsUnionAll
1413    */
1414    public boolean supportsUnionAll() throws SQLException {
1415        return dbMeta.supportsUnionAll();
1416    }
1417
1418    /**
1419    * Implements method in interface java.sql.Connection
1420    * @see java.sql.DatabaseMetaData#updatesAreDetected
1421    */
1422    public boolean updatesAreDetected(int type) throws SQLException {
1423        return dbMeta.updatesAreDetected(type);
1424    }
1425
1426    /**
1427    * Implements method in interface java.sql.Connection
1428    * @see java.sql.DatabaseMetaData#usesLocalFilePerTable
1429    */
1430    public boolean usesLocalFilePerTable() throws SQLException {
1431        return dbMeta.usesLocalFilePerTable();
1432    }
1433
1434    /**
1435    * Implements method in interface java.sql.Connection
1436    * @see java.sql.DatabaseMetaData#usesLocalFiles
1437    */
1438    public boolean usesLocalFiles() throws SQLException {
1439        return dbMeta.usesLocalFiles();
1440    }
1441}

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags