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 supportsCatalogsI