Java > Open Source Codes > org > continuent > sequoia > driver > DatabaseMetaData


1 /**
2  * Sequoia: Database clustering technology.
3  * Copyright (C) 2002-2004 French National Institute For Research In Computer
4  * Science And Control (INRIA).
5  * Copyright (C) 2005 AmicoSoft, Inc. dba Emic Networks
6  * Contact: sequoia@continuent.org
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  *
20  * Initial developer(s): Emmanuel Cecchet.
21  * Contributor(s): Jean-Bernard van Zuylen
22  */
23
24 package org.continuent.sequoia.driver;
25
26 import java.sql.SQLException ;
27 import java.util.HashMap ;
28
29 import org.continuent.sequoia.common.sql.metadata.MetadataContainer;
30 import org.continuent.sequoia.common.sql.metadata.MetadataDescription;
31 import org.continuent.sequoia.common.util.Constants;
32
33 /**
34  * DatabaseMetaData retrieves most of the values from the Sequoia controller. If
35  * you are using an heterogeneous cluster, the values returned are the one of
36  * the first database that was enabled on the controller.
37  *
38  * @author <a HREF="mailto:Emmanuel.Cecchet@inria.fr">Emmanuel Cecchet </a>
39  * @author <a HREF="mailto:jbvanzuylen@transwide.com">Jean-Bernard van Zuylen
40  * </a>
41  * @version 1.0
42  */
43 public class DatabaseMetaData implements java.sql.DatabaseMetaData
44 {
45   /** The connection association */
46   private Connection connection;
47
48   /**
49    * ("getXXX(Y,Z,...)", value) hash table of the metadata queries.
50    */
51   private HashMap metadataContainer;
52
53   /**
54    * Creates a new <code>DatabaseMetaData</code> instance.
55    *
56    * @param conn a <code>Connection</code> value
57    */
58   public DatabaseMetaData(Connection conn)
59   {
60     this.connection = conn;
61     metadataContainer = new HashMap ();
62   }
63
64   /**
65    * Lazy evaluation of a static metadata value. If the value is already in the
66    * hash table, we return it. Else we send a network request to the controller
67    * and add it to the table. <br>
68    *
69    * @param methodName metadata method name
70    * @param parametersType parameters type of method to invoke
71    * @param arguments arguments to invoke the method
72    * @param allowsNull true if a null metadata can be returned, if set to false
73    * an exception will be thrown if the metadata is null
74    * @return the value returned by the given method
75    * @throws SQLException if the connection fails
76    */
77   private Object getMetadata(String methodName, Class [] parametersType,
78       Object [] arguments, boolean allowsNull) throws SQLException
79   {
80     String key = MetadataContainer.getContainerKey(methodName, parametersType,
81         arguments);
82     Object value = metadataContainer.get(key);
83
84     if (value == null)
85     { // Value not yet in container
86 value = connection.getStaticMetadata(key);
87       if ((value == null) && !allowsNull)
88         throw new SQLException ("Unable to retrieve metadata for " + key);
89       metadataContainer.put(key, value);
90     }
91     return value;
92   }
93
94   /**
95    * @see java.sql.DatabaseMetaData#allProceduresAreCallable()
96    */
97   public boolean allProceduresAreCallable() throws SQLException
98   {
99     return ((Boolean ) getMetadata(
100         MetadataDescription.ALL_PROCEDURES_ARE_CALLABLE, null, null, false))
101         .booleanValue();
102   }
103
104   /**
105    * @see java.sql.DatabaseMetaData#allTablesAreSelectable()
106    */
107   public boolean allTablesAreSelectable() throws SQLException
108   {
109     return ((Boolean ) getMetadata(
110         MetadataDescription.ALL_TABLES_ARE_SELECTABLE, null, null, false))
111         .booleanValue();
112   }
113
114   /**
115    * @see java.sql.DatabaseMetaData#dataDefinitionCausesTransactionCommit()
116    */
117   public boolean dataDefinitionCausesTransactionCommit() throws SQLException
118   {
119     return ((Boolean ) getMetadata(
120         MetadataDescription.DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT, null,
121         null, false)).booleanValue();
122   }
123
124   /**
125    * @see java.sql.DatabaseMetaData#dataDefinitionIgnoredInTransactions()
126    */
127   public boolean dataDefinitionIgnoredInTransactions() throws SQLException
128   {
129     return ((Boolean ) getMetadata(
130         MetadataDescription.DATA_DEFINITION_IGNORED_IN_TRANSACTIONS, null,
131         null, false)).booleanValue();
132   }
133
134   /**
135    * @see java.sql.DatabaseMetaData#deletesAreDetected(int)
136    */
137   public boolean deletesAreDetected(int type) throws SQLException
138   {
139     return ((Boolean ) getMetadata(MetadataDescription.DELETES_ARE_DETECTED,
140         new Class []{Integer.TYPE}, new Object []{new Integer (type)}, false))
141         .booleanValue();
142   }
143
144   /**
145    * @see java.sql.DatabaseMetaData#doesMaxRowSizeIncludeBlobs()
146    */
147   public boolean doesMaxRowSizeIncludeBlobs() throws SQLException
148   {
149     return ((Boolean ) getMetadata(
150         MetadataDescription.DOES_MAX_ROW_SIZE_INCLUDE_BLOBS, null, null, false))
151         .booleanValue();
152   }
153
154   /**
155    * @see java.sql.DatabaseMetaData#getBestRowIdentifier(java.lang.String,
156    * java.lang.String, java.lang.String, int, boolean)
157    */
158   public java.sql.ResultSet getBestRowIdentifier(String catalog, String schema,
159       String table, int scope, boolean nullable) throws SQLException
160   {
161     return connection.getBestRowIdentifier(catalog, schema, table, scope,
162         nullable);
163   }
164
165   /**
166    * @see java.sql.DatabaseMetaData#getCatalogs()
167    */
168   public java.sql.ResultSet getCatalogs() throws SQLException
169   {
170     return connection.getCatalogs();
171   }
172
173   /**
174    * @see java.sql.DatabaseMetaData#getCatalogSeparator()
175    */
176   public String getCatalogSeparator() throws SQLException
177   {
178     return ((String ) getMetadata(MetadataDescription.GET_CATALOG_SEPARATOR,
179         null, null, true));
180   }
181
182   /**
183    * @see java.sql.DatabaseMetaData#getCatalogTerm()
184    */
185   public String getCatalogTerm() throws SQLException
186   {
187     return ((String ) getMetadata(MetadataDescription.GET_CATALOG_TERM, null,
188         null, true));
189   }
190
191   /**
192    * @param catalog a catalog name; "" retrieves those without a catalog
193    * @param schemaPattern a schema name pattern; "" retrieves those without a
194    * schema
195    * @param tableNamePattern a table name pattern
196    * @param columnNamePattern a column name pattern
197    * @return <code>null</code>
198    * @exception SQLException if an error occurs
199    * @see #getSearchStringEscape
200    */
201   public java.sql.ResultSet getColumns(String catalog, String schemaPattern,
202       String tableNamePattern, String columnNamePattern) throws SQLException
203   {
204     return connection.getColumns(catalog, schemaPattern, tableNamePattern,
205         columnNamePattern);
206   }
207
208   /**
209    * @see java.sql.DatabaseMetaData#getColumnPrivileges(java.lang.String,
210    * java.lang.String, java.lang.String, java.lang.String)
211    */
212   public java.sql.ResultSet getColumnPrivileges(String catalog,
213       String schemaPattern, String tableNamePattern, String columnNamePattern)
214       throws SQLException
215   {
216     return connection.getColumnPrivileges(catalog, schemaPattern,
217         tableNamePattern, columnNamePattern);
218   }
219
220   /**
221    * Retrieves the <code>Connection</code> that produced this
222    * <code>DatabaseMetaData</code>.
223    *
224    * @return the <code>Connection</code> object
225    * @exception SQLException if an error occurs
226    */
227   public java.sql.Connection getConnection() throws SQLException
228   {
229     return connection;
230   }
231
232   /**
233    * @see java.sql.DatabaseMetaData#getCrossReference(java.lang.String,
234    * java.lang.String, java.lang.String, java.lang.String,
235    * java.lang.String, java.lang.String)
236    */
237   public java.sql.ResultSet getCrossReference(String primaryCatalog,
238       String primarySchema, String primaryTable, String foreignCatalog,
239       String foreignSchema, String foreignTable) throws SQLException
240   {
241     return connection.getCrossReference(primaryCatalog, primarySchema,
242         primaryTable, foreignCatalog, foreignSchema, foreignTable);
243   }
244
245   /**
246    * We return a comma separated list of database engine names connected to the
247    * controller. A name appears only once regardless of the number of instances
248    * of this particular db engine. If no database product name is provided by
249    * the backend drivers, default is to return "Sequoia Controller".
250    *
251    * @return comma separated list of database product names
252    * @exception SQLException if a database access error occurs
253    */
254   public String getDatabaseProductName() throws SQLException
255   {
256     return connection.getDatabaseProductName();
257   }
258
259   /**
260    * What is the version of this database product.
261    *
262    * @return the Sequoia driver version
263    * @exception SQLException if an error occurs
264    */
265   public String getDatabaseProductVersion() throws SQLException
266   {
267     return connection.getControllerVersionNumber();
268   }
269
270   /**
271    * @see java.sql.DatabaseMetaData#getDefaultTransactionIsolation()
272    */
273   public int getDefaultTransactionIsolation() throws SQLException
274   {
275     return ((Integer ) getMetadata(
276         MetadataDescription.GET_DEFAULT_TRANSACTION_ISOLATION, null, null,
277         false)).intValue();
278   }
279
280   /**
281    * What is this JDBC driver's major version number?
282    *
283    * @return the JDBC driver major version
284    */
285   public int getDriverMajorVersion()
286   {
287     return Driver.MAJOR_VERSION;
288   }
289
290   /**
291    * What is this JDBC driver's minor version number?
292    *
293    * @return the JDBC driver minor version
294    */
295   public int getDriverMinorVersion()
296   {
297     return Driver.MINOR_VERSION;
298   }
299
300   /**
301    * What is the name of this JDBC driver?
302    *
303    * @return the JDBC driver name
304    * @exception SQLException why?
305    */
306   public String getDriverName() throws SQLException
307   {
308     return "Sequoia Generic Driver";
309   }
310
311   /**
312    * What is the version string of this JDBC driver?
313    *
314    * @return the JDBC driver name.
315    * @exception SQLException why?
316    */
317   public String getDriverVersion() throws SQLException
318   {
319     return Constants.VERSION;
320   }
321
322   /**
323    * @see java.sql.DatabaseMetaData#getExportedKeys(java.lang.String,
324    * java.lang.String, java.lang.String)
325    */
326   public java.sql.ResultSet getExportedKeys(String catalog, String schema,
327       String table) throws SQLException
328   {
329     return connection.getExportedKeys(catalog, schema, table);
330   }
331
332   /**
333    * @see java.sql.DatabaseMetaData#getExtraNameCharacters()
334    */
335   public String getExtraNameCharacters() throws SQLException
336   {
337     return ((String ) getMetadata(MetadataDescription.GET_EXTRA_NAME_CHARACTERS,
338         null, null, true));
339   }
340
341   /**
342    * @see java.sql.DatabaseMetaData#getIdentifierQuoteString()
343    */
344   public String getIdentifierQuoteString() throws SQLException
345   {
346     return ((String ) getMetadata(
347         MetadataDescription.GET_IDENTIFIER_QUOTE_STRING, null, null, true));
348   }
349
350   /**
351    * @see java.sql.DatabaseMetaData#getImportedKeys(java.lang.String,
352    * java.lang.String, java.lang.String)
353    */
354   public java.sql.ResultSet getImportedKeys(String catalog, String schema,
355       String table) throws SQLException
356   {
357     return connection.getImportedKeys(catalog, schema, table);
358   }
359
360   /**
361    * @see java.sql.DatabaseMetaData#getIndexInfo(java.lang.String,
362    * java.lang.String, java.lang.String, boolean, boolean)
363    */
364   public java.sql.ResultSet getIndexInfo(String catalog, String schema,
365       String table, boolean unique, boolean approximate) throws SQLException
366   {
367     return connection.getIndexInfo(catalog, schema, table, unique, approximate);
368   }
369
370   /**
371    * @see java.sql.DatabaseMetaData#getMaxBinaryLiteralLength()
372    */
373   public int getMaxBinaryLiteralLength() throws SQLException
374   {
375     return ((Integer ) getMetadata(
376         MetadataDescription.GET_MAX_BINARY_LITERAL_LENGTH, null, null, false))
377         .intValue();
378
379   }
380
381   /**
382    * @see java.sql.DatabaseMetaData#getMaxCatalogNameLength()
383    */
384   public int getMaxCatalogNameLength() throws SQLException
385   {
386     return ((Integer ) getMetadata(
387         MetadataDescription.GET_MAX_CATALOG_NAME_LENGTH, null, null, false))
388         .intValue();
389   }
390
391   /**
392    * @see java.sql.DatabaseMetaData#getMaxCharLiteralLength()
393    */
394   public int getMaxCharLiteralLength() throws SQLException
395   {
396     return ((Integer ) getMetadata(
397         MetadataDescription.GET_MAX_CHAR_LITERAL_LENGTH, null, null, false))
398         .intValue();
399   }
400
401   /**
402    * @see java.sql.DatabaseMetaData#getMaxColumnNameLength()
403    */
404   public int getMaxColumnNameLength() throws SQLException
405   {
406     return ((Integer ) getMetadata(
407         MetadataDescription.GET_MAX_COLUMN_NAME_LENGTH, null, null, false))
408         .intValue();
409   }
410
411   /**
412    * @see java.sql.DatabaseMetaData#getMaxColumnsInGroupBy()
413    */
414   public int getMaxColumnsInGroupBy() throws SQLException
415   {
416     return ((Integer ) getMetadata(
417         MetadataDescription.GET_MAX_COLUMNS_IN_GROUP_BY, null, null, false))
418         .intValue();
419   }
420
421   /**
422    * @see java.sql.DatabaseMetaData#getMaxColumnsInIndex()
423    */
424   public int getMaxColumnsInIndex() throws SQLException
425   {
426     return ((Integer ) getMetadata(MetadataDescription.GET_MAX_COLUMNS_IN_INDEX,
427         null, null, false)).intValue();
428   }
429
430   /**
431    * @see java.sql.DatabaseMetaData#getMaxColumnsInOrderBy()
432    */
433   public int getMaxColumnsInOrderBy() throws SQLException
434   {
435     return ((Integer ) getMetadata(
436         MetadataDescription.GET_MAX_COLUMNS_IN_ORDER_BY, null, null, false))
437         .intValue();
438   }
439
440   /**
441    * @see java.sql.DatabaseMetaData#getMaxColumnsInSelect()
442    */
443   public int getMaxColumnsInSelect() throws SQLException
444   {
445     return ((Integer ) getMetadata(
446         MetadataDescription.GET_MAX_COLUMNS_IN_SELECT, null, null, false))
447         .intValue();
448   }
449
450   /**
451    * @see java.sql.DatabaseMetaData#getMaxColumnsInTable()
452    */
453   public int getMaxColumnsInTable() throws SQLException
454   {
455     return ((Integer ) getMetadata(MetadataDescription.GET_MAX_COLUMNS_IN_TABLE,
456         null, null, false)).intValue();
457   }
458
459   /**
460    * Maximum number of connections to the database (virtually no limit since
461    * these are virtual connections to the Controller). The spec says 0 should be
462    * returned if unknown.
463    *
464    * @return value retrieved from first enabled backend
465    * @exception SQLException if a database access error occurs
466    */
467   public int getMaxConnections() throws SQLException
468   {
469     // TODO: max connection should be the max number of connection to the
470 // virtual database
471 return ((Integer ) getMetadata(MetadataDescription.GET_MAX_CONNECTIONS,
472         null, null, false)).intValue();
473   }
474
475   /**
476    * @see java.sql.DatabaseMetaData#getMaxCursorNameLength()
477    */
478   public int getMaxCursorNameLength() throws SQLException
479   {
480     return ((Integer ) getMetadata(
481         MetadataDescription.GET_MAX_CURSOR_NAME_LENGTH, null, null, false))
482         .intValue();
483   }
484
485   /**
486    * @see java.sql.DatabaseMetaData#getMaxIndexLength()
487    */
488   public int getMaxIndexLength() throws SQLException
489   {
490     return ((Integer ) getMetadata(MetadataDescription.GET_MAX_INDEX_LENGTH,
491         null, null, false)).intValue();
492   }
493
494   /**
495    * @see java.sql.DatabaseMetaData#getMaxProcedureNameLength()
496    */
497   public int getMaxProcedureNameLength() throws SQLException
498   {
499     return ((Integer ) getMetadata(
500         MetadataDescription.GET_MAX_PROCEDURE_NAME_LENGTH, null, null, false))
501         .intValue();
502   }
503
504   /**
505    * @see java.sql.DatabaseMetaData#getMaxRowSize()
506    */
507   public int getMaxRowSize() throws SQLException
508   {
509     return ((Integer ) getMetadata(MetadataDescription.GET_MAX_ROW_SIZE, null,
510         null, false)).intValue();
511   }
512
513   /**
514    * @see java.sql.DatabaseMetaData#getMaxSchemaNameLength()
515    */
516   public int getMaxSchemaNameLength() throws SQLException
517   {
518     return ((Integer ) getMetadata(
519         MetadataDescription.GET_MAX_SCHEMA_NAME_LENGTH, null, null, false))
520         .intValue();
521   }
522
523   /**
524    * @see java.sql.DatabaseMetaData#getMaxStatementLength()
525    */
526   public int getMaxStatementLength() throws SQLException
527   {
528     return ((Integer ) getMetadata(MetadataDescription.GET_MAX_STATEMENT_LENGTH,
529         null, null, false)).intValue();
530   }
531
532   /**
533    * @see java.sql.DatabaseMetaData#getMaxStatements()
534    */
535   public int getMaxStatements() throws SQLException
536   {
537     return ((Integer ) getMetadata(MetadataDescription.GET_MAX_STATEMENTS, null,
538         null, false)).intValue();
539   }
540
541   /**
542    * @see java.sql.DatabaseMetaData#getMaxTableNameLength()
543    */
544   public int getMaxTableNameLength() throws SQLException
545   {
546     return ((Integer ) getMetadata(
547         MetadataDescription.GET_MAX_TABLE_NAME_LENGTH, null, null, false))
548         .intValue();
549   }
550
551   /**
552    * @see java.sql.DatabaseMetaData#getMaxTablesInSelect()
553    */
554   public int getMaxTablesInSelect() throws SQLException
555   {
556     return ((Integer ) getMetadata(MetadataDescription.GET_MAX_TABLES_IN_SELECT,
557         null, null, false)).intValue();
558   }
559
560   /**
561    * @see java.sql.DatabaseMetaData#getMaxUserNameLength()
562    */
563   public int getMaxUserNameLength() throws SQLException
564   {
565     return ((Integer ) getMetadata(MetadataDescription.GET_MAX_USER_NAME_LENGTH,
566         null, null, false)).intValue();
567   }
568
569   /**
570    * @see java.sql.DatabaseMetaData#getNumericFunctions()
571    */
572   public String getNumericFunctions() throws SQLException
573   {
574     return ((String ) getMetadata(MetadataDescription.GET_NUMERIC_FUNCTIONS,
575         null, null, true));
576   }
577
578   /**
579    * @see java.sql.DatabaseMetaData#getPrimaryKeys(java.lang.String,
580    * java.lang.String, java.lang.String)
581    */
582   public java.sql.ResultSet getPrimaryKeys(String catalog, String schema,
583       String table) throws SQLException
584   {
585     return connection.getPrimaryKeys(catalog, schema, table);
586   }
587
588   /**
589    * @see java.sql.DatabaseMetaData#getProcedureColumns(java.lang.String,
590    * java.lang.String, java.lang.String, java.lang.String)
591    */
592   public java.sql.ResultSet getProcedureColumns(String catalog,
593       String schemaPattern, String procedureNamePattern,
594       String columnNamePattern) throws SQLException
595   {
596     return connection.getProcedureColumns(catalog, schemaPattern,
597         procedureNamePattern, columnNamePattern);
598   }
599
600   /**
601    * @see java.sql.DatabaseMetaData#getProcedures(java.lang.String,
602    * java.lang.String, java.lang.String)
603    */
604   public java.sql.ResultSet getProcedures(String catalog, String schemaPattern,
605       String procedureNamePattern) throws SQLException
606   {
607     return connection.getProcedures(catalog, schemaPattern,
608         procedureNamePattern);
609   }
610
611   /**
612    * @see java.sql.DatabaseMetaData#getProcedureTerm()
613    */
614   public String getProcedureTerm() throws SQLException
615   {
616     return ((String ) getMetadata(MetadataDescription.GET_PROCEDURE_TERM, null,
617         null, true));
618   }
619
620   /**
621    * @see java.sql.DatabaseMetaData#getSchemas()
622    */
623   public java.sql.ResultSet getSchemas() throws SQLException
624   {
625     return connection.getSchemas();
626   }
627
628   /**
629    * @see java.sql.DatabaseMetaData#getSchemaTerm()
630    */
631   public String getSchemaTerm() throws SQLException
632   {
633     return ((String ) getMetadata(MetadataDescription.GET_SCHEMA_TERM, null,
634         null, true));
635   }
636
637   /**
638    * @see java.sql.DatabaseMetaData#getSearchStringEscape()
639    */
640   public String getSearchStringEscape() throws SQLException
641   {
642     return ((String ) getMetadata(MetadataDescription.GET_SEARCH_STRING_ESCAPE,
643         null, null, true));
644   }
645
646   /**
647    * @see java.sql.DatabaseMetaData#getSQLKeywords()
648    */
649   public String getSQLKeywords() throws SQLException
650   {
651     return ((String ) getMetadata(MetadataDescription.GET_SQL_KEYWORDS, null,
652         null, true));
653   }
654
655   /**
656    * @see java.sql.DatabaseMetaData#getStringFunctions()
657    */
658   public String getStringFunctions() throws SQLException
659   {
660     return ((String ) getMetadata(MetadataDescription.GET_STRING_FUNCTIONS,
661         null, null, true));
662   }
663
664   /**
665    * @see java.sql.DatabaseMetaData#getSystemFunctions()
666    */
667   public String getSystemFunctions() throws SQLException
668   {
669     return ((String ) getMetadata(MetadataDescription.GET_SYSTEM_FUNCTIONS,
670         null, null, true));
671   }
672
673   /**
674    * Gets a description of the available tables.
675    *
676    * @param catalog a catalog name; this is ignored, and should be set to
677    * <code>null</code>
678    * @param schemaPattern a schema name pattern; this is ignored, and should be
679    * set to <code>null</code>
680    * @param tableNamePattern a table name pattern. For all tables this should be
681    * "%"
682    * @param types a list of table types to include; <code>null</code> returns
683    * all types
684    * @return <code>null</code>
685    * @exception SQLException if a database-access error occurs.
686    */
687   public java.sql.ResultSet getTables(String catalog, String schemaPattern,
688       String tableNamePattern, String [] types) throws SQLException
689   {
690     return connection
691         .getTables(catalog, schemaPattern, tableNamePattern, types);
692   }
693
694   /**
695    * Gets a description of the access rights for each table available in a
696    * catalog. Note that a table privilege applies to one or more columns in the
697    * table. It would be wrong to assume that this priviledge applies to all
698    * columns (this may be true for some systems but is not true for all.) Only
699    * privileges matching the schema and table name criteria are returned. They
700    * are ordered by TABLE_SCHEM, TABLE_NAME, and PRIVILEGE.
701    *
702    * @param catalog a catalog name; "" retrieves those without a catalog; null
703    * means drop catalog name from the selection criteria
704    * @param schemaPattern a schema name pattern; "" retrieves those without a
705    * schema
706    * @param tableNamePattern a table name pattern
707    * @return <code>ResultSet</code> each row is a table privilege description
708    * @throws SQLException if a database access error occurs
709    */
710   public java.sql.ResultSet getTablePrivileges(String catalog,
711       String schemaPattern, String tableNamePattern) throws SQLException
712   {
713     return connection.getTablePrivileges(catalog, schemaPattern,
714         tableNamePattern);
715   }
716
717   /**
718    * Gets the table types available in this database. The results are ordered by
719    * table type.
720    *
721    * @return <code>ResultSet</code> each row has a single String column that
722    * is a catalog name
723    * @throws SQLException if a database error occurs
724    */
725   public java.sql.ResultSet getTableTypes() throws SQLException
726   {
727     return connection.getTableTypes();
728   }
729
730   /**
731    * @see java.sql.DatabaseMetaData#getTimeDateFunctions()
732    */
733   public String getTimeDateFunctions() throws SQLException
734   {
735     return ((String ) getMetadata(MetadataDescription.GET_TIME_DATE_FUNCTIONS,
736         null, null, true));
737   }
738
739   /**
740    * @see java.sql.DatabaseMetaData#getTypeInfo()
741    */
742   public java.sql.ResultSet getTypeInfo() throws SQLException
743   {
744     return connection.getTypeInfo();
745   }
746
747   /**
748    * @see java.sql.DatabaseMetaData#getUDTs(java.lang.String, java.lang.String,
749    * java.lang.String, int[])
750    */
751   public java.sql.ResultSet getUDTs(String catalog, String schemaPattern,
752       String typeNamePattern, int[] types) throws SQLException
753   {
754     return connection.getUDTs(catalog, schemaPattern, typeNamePattern, types);
755   }
756
757   /**
758    * What is the URL for this database?
759    *
760    * @return the url or null if it cannott be generated
761    * @exception SQLException if a database access error occurs
762    */
763   public String getURL() throws SQLException
764   {
765     return connection.getUrl();
766   }
767
768   /**
769    * What is our user name as known to the database?
770    *
771    * @return our database user name
772    * @exception SQLException if a database access error occurs
773    */
774   public String getUserName() throws SQLException
775   {
776     return connection.getUserName();
777   }
778
779   /**
780    * @see java.sql.DatabaseMetaData#getVersionColumns(java.lang.String,
781    * java.lang.String, java.lang.String)
782    */
783   public java.sql.ResultSet getVersionColumns(String catalog, String schema,
784       String table) throws SQLException
785   {
786     return connection.getVersionColumns(catalog, schema, table);
787   }
788
789   /**
790    * @see java.sql.DatabaseMetaData#insertsAreDetected(int)
791    */
792   public boolean insertsAreDetected(int type) throws SQLException
793   {
794     return ((Boolean ) getMetadata(MetadataDescription.INSERTS_ARE_DETECTED,
795         new Class []{Integer.TYPE}, new Object []{new Integer (type)}, false))
796         .booleanValue();
797   }
798
799   /**
800    * @see java.sql.DatabaseMetaData#isCatalogAtStart()
801    */
802   public boolean isCatalogAtStart() throws SQLException
803   {
804     return ((Boolean ) getMetadata(MetadataDescription.IS_CATALOG_AT_START,
805         null, null, false)).booleanValue();
806   }
807
808   /**
809    * Is the database in read-only mode?
810    *
811    * @return <code>true</code> if so
812    * @exception SQLException if a database access error occurs
813    */
814   public boolean isReadOnly() throws SQLException
815   {
816     return connection.isReadOnly();
817   }
818
819   /**
820    * @see java.sql.DatabaseMetaData#nullPlusNonNullIsNull()
821    */
822   public boolean nullPlusNonNullIsNull() throws SQLException
823   {
824     return ((Boolean ) getMetadata(
825         MetadataDescription.NULL_PLUS_NON_NULL_IS_NULL, null, null, false))
826         .booleanValue();
827   }
828
829   /**
830    * @see java.sql.DatabaseMetaData#nullsAreSortedAtEnd()
831    */
832   public boolean nullsAreSortedAtEnd() throws SQLException
833   {
834     return ((Boolean ) getMetadata(MetadataDescription.NULLS_ARE_SORTED_AT_END,
835         null, null, false)).booleanValue();
836   }
837
838   /**
839    * @see java.sql.DatabaseMetaData#nullsAreSortedAtStart()
840    */
841   public boolean nullsAreSortedAtStart() throws SQLException
842   {
843     return ((Boolean ) getMetadata(
844         MetadataDescription.NULLS_ARE_SORTED_AT_START, null, null, false))
845         .booleanValue();
846   }
847
848   /**
849    * @see java.sql.DatabaseMetaData#nullsAreSortedHigh()
850    */
851   public boolean nullsAreSortedHigh() throws SQLException
852   {
853     return ((Boolean ) getMetadata(MetadataDescription.NULLS_ARE_SORTED_HIGH,
854         null, null, false)).booleanValue();
855   }
856
857   /**
858    * @see java.sql.DatabaseMetaData#nullsAreSortedLow()
859    */
860   public boolean nullsAreSortedLow() throws SQLException
861   {
862     return ((Boolean ) getMetadata(MetadataDescription.NULLS_ARE_SORTED_LOW,
863         null, null, false)).booleanValue();
864   }
865
866   /**
867    * @see java.sql.DatabaseMetaData#othersDeletesAreVisible(int)
868    */
869   public boolean othersDeletesAreVisible(int type) throws SQLException
870   {
871     return ((Boolean ) getMetadata(
872         MetadataDescription.OTHERS_DELETES_ARE_VISIBLE,
873         new Class []{Integer.TYPE}, new Object []{new Integer (type)}, false))
874         .booleanValue();
875   }
876
877   /**
878    * @see java.sql.DatabaseMetaData#othersInsertsAreVisible(int)
879    */
880   public boolean othersInsertsAreVisible(int type) throws SQLException
881   {
882     return ((Boolean ) getMetadata(
883         MetadataDescription.OTHERS_INSERTS_ARE_VISIBLE,
884         new Class []{Integer.TYPE}, new Object []{new Integer (type)}, false))
885         .booleanValue();
886   }
887
888   /**
889    * @see java.sql.DatabaseMetaData#othersUpdatesAreVisible(int)
890    */
891   public boolean othersUpdatesAreVisible(int type) throws SQLException
892   {
893     return ((Boolean ) getMetadata(
894         MetadataDescription.OTHERS_UPDATES_ARE_VISIBLE,
895         new Class []{Integer.TYPE}, new Object []{new Integer (type)}, false))
896         .booleanValue();
897   }
898
899   /**
900    * @see java.sql.DatabaseMetaData#ownDeletesAreVisible(int)
901    */
902   public boolean ownDeletesAreVisible(int type) throws SQLException
903   {
904     return ((Boolean ) getMetadata(MetadataDescription.OWN_DELETES_ARE_VISIBLE,
905         new Class []{Integer.TYPE}, new Object []{new Integer (type)}, false))
906         .booleanValue();
907   }
908
909   /**
910    * @see java.sql.DatabaseMetaData#ownInsertsAreVisible(int)
911    */
912   public boolean ownInsertsAreVisible(int type) throws SQLException
913   {
914     return ((Boolean ) getMetadata(MetadataDescription.OWN_INSERTS_ARE_VISIBLE,
915         new Class []{Integer.TYPE}, new Object []{new Integer (type)}, false))
916         .booleanValue();
917
918   }
919
920   /**
921    * @see java.sql.DatabaseMetaData#ownUpdatesAreVisible(int)
922    */
923   public boolean ownUpdatesAreVisible(int type) throws SQLException
924   {
925     return ((Boolean ) getMetadata(MetadataDescription.OWN_UPDATES_ARE_VISIBLE,
926         new Class []{Integer.TYPE}, new Object []{new Integer (type)}, false))
927         .booleanValue();
928   }
929
930   /**
931    * @see java.sql.DatabaseMetaData#storesLowerCaseIdentifiers()
932    */
933   public boolean storesLowerCaseIdentifiers() throws SQLException
934   {
935     return ((Boolean ) getMetadata(
936         MetadataDescription.STORES_LOWER_CASE_IDENTIFIERS, null, null, false))
937         .booleanValue();
938   }
939
940   /**
941    * @see java.sql.DatabaseMetaData#storesLowerCaseQuotedIdentifiers()
942    */
943   public boolean storesLowerCaseQuotedIdentifiers() throws SQLException
944   {
945     return ((Boolean ) getMetadata(
946         MetadataDescription.STORES_LOWER_CASE_QUOTED_IDENTIFIERS, null, null,
947         false)).booleanValue();
948   }
949
950   /**
951    * @see java.sql.DatabaseMetaData#storesMixedCaseIdentifiers()
952    */
953   public boolean storesMixedCaseIdentifiers() throws SQLException
954   {
955     return ((Boolean ) getMetadata(
956         MetadataDescription.STORES_MIXED_CASE_IDENTIFIERS, null, null, false))
957         .booleanValue();
958   }
959
960   /**
961    * @see java.sql.DatabaseMetaData#storesMixedCaseQuotedIdentifiers()
962    */
963   public boolean storesMixedCaseQuotedIdentifiers() throws SQLException
964   {
965     return ((Boolean ) getMetadata(
966         MetadataDescription.STORES_MIXED_CASE_QUOTED_IDENTIFIERS, null, null,
967         false)).booleanValue();
968   }
969
970   /**
971    * @see java.sql.DatabaseMetaData#storesUpperCaseIdentifiers()
972    */
973   public boolean storesUpperCaseIdentifiers() throws SQLException
974   {
975     return ((Boolean ) getMetadata(
976         MetadataDescription.STORES_UPPER_CASE_IDENTIFIERS, null, null, false))
977         .booleanValue();
978   }
979
980   /**
981    * @see java.sql.DatabaseMetaData#storesUpperCaseQuotedIdentifiers()
982    */
983   public boolean storesUpperCaseQuotedIdentifiers() throws SQLException
984   {
985     return ((Boolean ) getMetadata(
986         MetadataDescription.STORES_UPPER_CASE_QUOTED_IDENTIFIERS, null, null,
987         false)).booleanValue();
988   }
989
990   /**
991    * @see java.sql.DatabaseMetaData#supportsAlterTableWithAddColumn()
992    */
993   public boolean supportsAlterTableWithAddColumn() throws SQLException
994   {
995     return ((Boolean ) getMetadata(
996         MetadataDescription.SUPPORTS_ALTER_TABLE_WITH_ADD_COLUMN, null, null,
997         false)).booleanValue();
998   }
999
1000  /**
1001   * @see java.sql.DatabaseMetaData#supportsAlterTableWithDropColumn()
1002   */
1003  public boolean supportsAlterTableWithDropColumn() throws SQLException
1004  {
1005    return ((Boolean ) getMetadata(
1006        MetadataDescription.SUPPORTS_ALTER_TABLE_WITH_DROP_COLUMN, null, null,
1007        false)).booleanValue();
1008  }
1009
1010  /**
1011   * @see java.sql.DatabaseMetaData#supportsANSI92EntryLevelSQL()
1012   */
1013  public boolean supportsANSI92EntryLevelSQL() throws SQLException
1014  {
1015    return ((Boolean ) getMetadata(
1016        MetadataDescription.SUPPORTS_ANSI92_ENTRY_LEVEL_SQL, null, null, false))
1017        .booleanValue();
1018  }
1019
1020  /**
1021   * @see java.sql.DatabaseMetaData#supportsANSI92FullSQL()
1022   */
1023  public boolean supportsANSI92FullSQL() throws SQLException
1024  {
1025    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_ANSI92_FULL_SQL,
1026        null, null, false)).booleanValue();
1027  }
1028
1029  /**
1030   * @see java.sql.DatabaseMetaData#supportsANSI92IntermediateSQL()
1031   */
1032  public boolean supportsANSI92IntermediateSQL() throws SQLException
1033  {
1034    return ((Boolean ) getMetadata(
1035        MetadataDescription.SUPPORTS_ANSI92_INTERMEDIATE_SQL, null, null, false))
1036        .booleanValue();
1037  }
1038
1039  /**
1040   * @see java.sql.DatabaseMetaData#supportsBatchUpdates()
1041   */
1042  public boolean supportsBatchUpdates() throws SQLException
1043  {
1044    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_BATCH_UPDATES,
1045        null, null, false)).booleanValue();
1046  }
1047
1048  /**
1049   * @see java.sql.DatabaseMetaData#supportsCatalogsInDataManipulation()
1050   */
1051  public boolean supportsCatalogsInDataManipulation() throws SQLException
1052  {
1053    return ((Boolean ) getMetadata(
1054        MetadataDescription.SUPPORTS_CATALOGS_IN_DATA_MANIPULATION, null, null,
1055        false)).booleanValue();
1056  }
1057
1058  /**
1059   * @see java.sql.DatabaseMetaData#supportsCatalogsInIndexDefinitions()
1060   */
1061  public boolean supportsCatalogsInIndexDefinitions() throws SQLException
1062  {
1063    return ((Boolean ) getMetadata(
1064        MetadataDescription.SUPPORTS_CATALOGS_IN_INDEX_DEFINITIONS, null, null,
1065        false)).booleanValue();
1066  }
1067
1068  /**
1069   * @see java.sql.DatabaseMetaData#supportsCatalogsInPrivilegeDefinitions()
1070   */
1071  public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException
1072  {
1073    return ((Boolean ) getMetadata(
1074        MetadataDescription.SUPPORTS_CATALOGS_IN_PRIVILEGE_DEFINITIONS, null,
1075        null, false)).booleanValue();
1076  }
1077
1078  /**
1079   * @see java.sql.DatabaseMetaData#supportsCatalogsInProcedureCalls()
1080   */
1081  public boolean supportsCatalogsInProcedureCalls() throws SQLException
1082  {
1083    return ((Boolean ) getMetadata(
1084        MetadataDescription.SUPPORTS_CATALOGS_IN_PROCEDURE_CALLS, null, null,
1085        false)).booleanValue();
1086  }
1087
1088  /**
1089   * @see java.sql.DatabaseMetaData#supportsCatalogsInTableDefinitions()
1090   */
1091  public boolean supportsCatalogsInTableDefinitions() throws SQLException
1092  {
1093    return ((Boolean ) getMetadata(
1094        MetadataDescription.SUPPORTS_CATALOGS_IN_TABLE_DEFINITIONS, null, null,
1095        false)).booleanValue();
1096  }
1097
1098  /**
1099   * @see java.sql.DatabaseMetaData#supportsColumnAliasing()
1100   */
1101  public boolean supportsColumnAliasing() throws SQLException
1102  {
1103    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_COLUMN_ALIASING,
1104        null, null, false)).booleanValue();
1105  }
1106
1107  /**
1108   * @see java.sql.DatabaseMetaData#supportsConvert()
1109   */
1110  public boolean supportsConvert() throws SQLException
1111  {
1112    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_CONVERT, null,
1113        null, false)).booleanValue();
1114  }
1115
1116  /**
1117   * Not implemented (returns <code>false</code>). We should ask the
1118   * Controller to know.
1119   *
1120   * @param fromType an <code>int</code> value
1121   * @param toType an <code>int</code> value
1122   * @return <code>false</code>
1123   * @exception SQLException <description>
1124   */
1125  public boolean supportsConvert(int fromType, int toType) throws SQLException
1126  {
1127    return false;
1128  }
1129
1130  /**
1131   * @see java.sql.DatabaseMetaData#supportsCoreSQLGrammar()
1132   */
1133  public boolean supportsCoreSQLGrammar() throws SQLException
1134  {
1135    return ((Boolean ) getMetadata(
1136        MetadataDescription.SUPPORTS_CORE_SQL_GRAMMAR, null, null, false))
1137        .booleanValue();
1138  }
1139
1140  /**
1141   * @see java.sql.DatabaseMetaData#supportsCorrelatedSubqueries()
1142   */
1143  public boolean supportsCorrelatedSubqueries() throws SQLException
1144  {
1145    return ((Boolean ) getMetadata(
1146        MetadataDescription.SUPPORTS_CORRELATED_SUBQUERIES, null, null, false))
1147        .booleanValue();
1148  }
1149
1150  /**
1151   * @see java.sql.DatabaseMetaData#supportsDataDefinitionAndDataManipulationTransactions()
1152   */
1153  public boolean supportsDataDefinitionAndDataManipulationTransactions()
1154      throws SQLException
1155  {
1156    return ((Boolean ) getMetadata(
1157        MetadataDescription.SUPPORTS_DATA_DEFINITION_AND_DATA_MANIPULATION_TRANSACTIONS,
1158        null, null, false)).booleanValue();
1159  }
1160
1161  /**
1162   * @see java.sql.DatabaseMetaData#supportsDataManipulationTransactionsOnly()
1163   */
1164  public boolean supportsDataManipulationTransactionsOnly() throws SQLException
1165  {
1166    return ((Boolean ) getMetadata(
1167        MetadataDescription.SUPPORTS_DATA_MANIPULATION_TRANSACTIONS_ONLY, null,
1168        null, false)).booleanValue();
1169  }
1170
1171  /**
1172   * @see java.sql.DatabaseMetaData#supportsDifferentTableCorrelationNames()
1173   */
1174  public boolean supportsDifferentTableCorrelationNames() throws SQLException
1175  {
1176    return ((Boolean ) getMetadata(
1177        MetadataDescription.SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES, null,
1178        null, false)).booleanValue();
1179  }
1180
1181  /**
1182   * @see java.sql.DatabaseMetaData#supportsExpressionsInOrderBy()
1183   */
1184  public boolean supportsExpressionsInOrderBy() throws SQLException
1185  {
1186    return ((Boolean ) getMetadata(
1187        MetadataDescription.SUPPORTS_EXPRESSIONS_IN_ORDER_BY, null, null, false))
1188        .booleanValue();
1189  }
1190
1191  /**
1192   * @see java.sql.DatabaseMetaData#supportsExtendedSQLGrammar()
1193   */
1194  public boolean supportsExtendedSQLGrammar() throws SQLException
1195  {
1196    return ((Boolean ) getMetadata(
1197        MetadataDescription.SUPPORTS_EXTENDED_SQL_GRAMMAR, null, null, false))
1198        .booleanValue();
1199  }
1200
1201  /**
1202   * @see java.sql.DatabaseMetaData#supportsFullOuterJoins()
1203   */
1204  public boolean supportsFullOuterJoins() throws SQLException
1205  {
1206    return ((Boolean ) getMetadata(
1207        MetadataDescription.SUPPORTS_FULL_OUTER_JOINS, null, null, false))
1208        .booleanValue();
1209  }
1210
1211  /**
1212   * @see java.sql.DatabaseMetaData#supportsGroupBy()
1213   */
1214  public boolean supportsGroupBy() throws SQLException
1215  {
1216    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_GROUP_BY, null,
1217        null, false)).booleanValue();
1218  }
1219
1220  /**
1221   * @see java.sql.DatabaseMetaData#supportsGroupByBeyondSelect()
1222   */
1223  public boolean supportsGroupByBeyondSelect() throws SQLException
1224  {
1225    return ((Boolean ) getMetadata(
1226        MetadataDescription.SUPPORTS_GROUP_BY_BEYOND_SELECT, null, null, false))
1227        .booleanValue();
1228  }
1229
1230  /**
1231   * @see java.sql.DatabaseMetaData#supportsGroupByUnrelated()
1232   */
1233  public boolean supportsGroupByUnrelated() throws SQLException
1234  {
1235    return ((Boolean ) getMetadata(
1236        MetadataDescription.SUPPORTS_GROUP_BY_UNRELATED, null, null, false))
1237        .booleanValue();
1238  }
1239
1240  /**
1241   * @see java.sql.DatabaseMetaData#supportsIntegrityEnhancementFacility()
1242   */
1243  public boolean supportsIntegrityEnhancementFacility() throws SQLException
1244  {
1245    return ((Boolean ) getMetadata(
1246        MetadataDescription.SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY, null,
1247        null, false)).booleanValue();
1248  }
1249
1250  /**
1251   * @see java.sql.DatabaseMetaData#supportsLikeEscapeClause()
1252   */
1253  public boolean supportsLikeEscapeClause() throws SQLException
1254  {
1255    return ((Boolean ) getMetadata(
1256        MetadataDescription.SUPPORTS_LIKE_ESCAPE_CLAUSE, null, null, false))
1257        .booleanValue();
1258  }
1259
1260  /**
1261   * @see java.sql.DatabaseMetaData#supportsLimitedOuterJoins()
1262   */
1263  public boolean supportsLimitedOuterJoins() throws SQLException
1264  {
1265    return ((Boolean ) getMetadata(
1266        MetadataDescription.SUPPORTS_LIMITED_OUTER_JOINS, null, null, false))
1267        .booleanValue();
1268  }
1269
1270  /**
1271   * @see java.sql.DatabaseMetaData#supportsMinimumSQLGrammar()
1272   */
1273  public boolean supportsMinimumSQLGrammar() throws SQLException
1274  {
1275    return ((Boolean ) getMetadata(
1276        MetadataDescription.SUPPORTS_MINIMUM_SQL_GRAMMAR, null, null, false))
1277        .booleanValue();
1278  }
1279
1280  /**
1281   * @see java.sql.DatabaseMetaData#supportsMixedCaseIdentifiers()
1282   */
1283  public boolean supportsMixedCaseIdentifiers() throws SQLException
1284  {
1285    return ((Boolean ) getMetadata(
1286        MetadataDescription.SUPPORTS_MIXED_CASE_IDENTIFIERS, null, null, false))
1287        .booleanValue();
1288  }
1289
1290  /**
1291   * @see java.sql.DatabaseMetaData#supportsMixedCaseQuotedIdentifiers()
1292   */
1293  public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException
1294  {
1295    return ((Boolean ) getMetadata(
1296        MetadataDescription.SUPPORTS_MIXED_CASE_QUOTED_IDENTIFIERS, null, null,
1297        false)).booleanValue();
1298  }
1299
1300  /**
1301   * @see java.sql.DatabaseMetaData#supportsMultipleResultSets()
1302   */
1303  public boolean supportsMultipleResultSets() throws SQLException
1304  {
1305    return ((Boolean ) getMetadata(
1306        MetadataDescription.SUPPORTS_MULTIPLE_RESULTSETS, null, null, false))
1307        .booleanValue();
1308  }
1309
1310  /**
1311   * @see java.sql.DatabaseMetaData#supportsMultipleTransactions()
1312   */
1313  public boolean supportsMultipleTransactions() throws SQLException
1314  {
1315    return ((Boolean ) getMetadata(
1316        MetadataDescription.SUPPORTS_MULTIPLE_TRANSACTIONS, null, null, false))
1317        .booleanValue();
1318  }
1319
1320  /**
1321   * @see java.sql.DatabaseMetaData#supportsNonNullableColumns()
1322   */
1323  public boolean supportsNonNullableColumns() throws SQLException
1324  {
1325    return ((Boolean ) getMetadata(
1326        MetadataDescription.SUPPORTS_NON_NULLABLE_COLUMNS, null, null, false))
1327        .booleanValue();
1328  }
1329
1330  /**
1331   * @see java.sql.DatabaseMetaData#supportsOpenCursorsAcrossCommit()
1332   */
1333  public boolean supportsOpenCursorsAcrossCommit() throws SQLException
1334  {
1335    return ((Boolean ) getMetadata(
1336        MetadataDescription.SUPPORTS_OPEN_CURSORS_ACROSS_COMMIT, null, null,
1337        false)).booleanValue();
1338  }
1339
1340  /**
1341   * @see java.sql.DatabaseMetaData#supportsOpenCursorsAcrossRollback()
1342   */
1343  public boolean supportsOpenCursorsAcrossRollback() throws SQLException
1344  {
1345    return ((Boolean ) getMetadata(
1346        MetadataDescription.SUPPORTS_OPEN_CURSORS_ACROSS_ROLLBACK, null, null,
1347        false)).booleanValue();
1348  }
1349
1350  /**
1351   * @see java.sql.DatabaseMetaData#supportsOpenStatementsAcrossCommit()
1352   */
1353  public boolean supportsOpenStatementsAcrossCommit() throws SQLException
1354  {
1355    return ((Boolean ) getMetadata(
1356        MetadataDescription.SUPPORTS_OPEN_STATEMENTS_ACROSS_COMMIT, null, null,
1357        false)).booleanValue();
1358  }
1359
1360  /**
1361   * @see java.sql.DatabaseMetaData#supportsOpenStatementsAcrossRollback()
1362   */
1363  public boolean supportsOpenStatementsAcrossRollback() throws SQLException
1364  {
1365    return ((Boolean ) getMetadata(
1366        MetadataDescription.SUPPORTS_OPEN_STATEMENTS_ACROSS_ROLLBACK, null,
1367        null, false)).booleanValue();
1368  }
1369
1370  /**
1371   * @see java.sql.DatabaseMetaData#supportsOrderByUnrelated()
1372   */
1373  public boolean supportsOrderByUnrelated() throws SQLException
1374  {
1375    return ((Boolean ) getMetadata(
1376        MetadataDescription.SUPPORTS_ORDER_BY_UNRELATED, null, null, false))
1377        .booleanValue();
1378  }
1379
1380  /**
1381   * @see java.sql.DatabaseMetaData#supportsOuterJoins()
1382   */
1383  public boolean supportsOuterJoins() throws SQLException
1384  {
1385    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_OUTER_JOINS,
1386        null, null, false)).booleanValue();
1387  }
1388
1389  /**
1390   * @see java.sql.DatabaseMetaData#supportsPositionedDelete()
1391   */
1392  public boolean supportsPositionedDelete() throws SQLException
1393  {
1394    return ((Boolean ) getMetadata(
1395        MetadataDescription.SUPPORTS_POSITIONED_DELETE, null, null, false))
1396        .booleanValue();
1397  }
1398
1399  /**
1400   * @see java.sql.DatabaseMetaData#supportsPositionedUpdate()
1401   */
1402  public boolean supportsPositionedUpdate() throws SQLException
1403  {
1404    return ((Boolean ) getMetadata(
1405        MetadataDescription.SUPPORTS_POSITIONED_UPDATE, null, null, false))
1406        .booleanValue();
1407  }
1408
1409  /**
1410   * @see java.sql.DatabaseMetaData#supportsResultSetConcurrency(int, int)
1411   */
1412  public boolean supportsResultSetConcurrency(int type, int concurrency)
1413      throws SQLException
1414  {
1415    return ((Boolean ) getMetadata(
1416        MetadataDescription.SUPPORTS_RESULT_SET_CONCURRENCY, new Class []{
1417            Integer.TYPE, Integer.TYPE}, new Object []{new Integer (type),
1418            new Integer (concurrency)}, false)).booleanValue();
1419  }
1420
1421  /**
1422   * @see java.sql.DatabaseMetaData#supportsResultSetHoldability(int)
1423   */
1424  public boolean supportsResultSetHoldability(int holdability)
1425      throws SQLException
1426  {
1427    return ((Boolean ) getMetadata(
1428        MetadataDescription.SUPPORTS_RESULT_SET_HOLDABILITY,
1429        new Class []{Integer.TYPE}, new Object []{new Integer (holdability)},
1430        false)).booleanValue();
1431  }
1432
1433  /**
1434   * @see java.sql.DatabaseMetaData#supportsResultSetType(int)
1435   */
1436  public boolean supportsResultSetType(int type) throws SQLException
1437  {
1438    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_RESULT_SET_TYPE,
1439        new Class []{Integer.TYPE}, new Object []{new Integer (type)}, false))
1440        .booleanValue();
1441  }
1442
1443  /**
1444   * @see java.sql.DatabaseMetaData#supportsSchemasInDataManipulation()
1445   */
1446  public boolean supportsSchemasInDataManipulation() throws SQLException
1447  {
1448    return ((Boolean ) getMetadata(
1449        MetadataDescription.SUPPORTS_SCHEMAS_IN_DATA_MANIPULATION, null, null,
1450        false)).booleanValue();
1451  }
1452
1453  /**
1454   * @see java.sql.DatabaseMetaData#supportsSchemasInIndexDefinitions()
1455   */
1456  public boolean supportsSchemasInIndexDefinitions() throws SQLException
1457  {
1458    return ((Boolean ) getMetadata(
1459        MetadataDescription.SUPPORTS_SCHEMAS_IN_INDEX_DEFINITIONS, null, null,
1460        false)).booleanValue();
1461  }
1462
1463  /**
1464   * @see java.sql.DatabaseMetaData#supportsSchemasInPrivilegeDefinitions()
1465   */
1466  public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException
1467  {
1468    return ((Boolean ) getMetadata(
1469        MetadataDescription.SUPPORTS_SCHEMAS_IN_PRIVILEGE_DEFINITIONS, null,
1470        null, false)).booleanValue();
1471  }
1472
1473  /**
1474   * @see java.sql.DatabaseMetaData#supportsSchemasInProcedureCalls()
1475   */
1476  public boolean supportsSchemasInProcedureCalls() throws SQLException
1477  {
1478    return ((Boolean ) getMetadata(
1479        MetadataDescription.SUPPORTS_SCHEMAS_IN_PROCEDURE_CALLS, null, null,
1480        false)).booleanValue();
1481  }
1482
1483  /**
1484   * @see java.sql.DatabaseMetaData#supportsSchemasInTableDefinitions()
1485   */
1486  public boolean supportsSchemasInTableDefinitions() throws SQLException
1487  {
1488    return ((Boolean ) getMetadata(
1489        MetadataDescription.SUPPORTS_SCHEMAS_IN_TABLE_DEFINITIONS, null, null,
1490        false)).booleanValue();
1491  }
1492
1493  /**
1494   * @see java.sql.DatabaseMetaData#supportsSelectForUpdate()
1495   */
1496  public boolean supportsSelectForUpdate() throws SQLException
1497  {
1498    return ((Boolean ) getMetadata(
1499        MetadataDescription.SUPPORTS_SELECT_FOR_UPDATE, null, null, false))
1500        .booleanValue();
1501  }
1502
1503  /**
1504   * @see java.sql.DatabaseMetaData#supportsStoredProcedures()
1505   */
1506  public boolean supportsStoredProcedures() throws SQLException
1507  {
1508    return ((Boolean ) getMetadata(
1509        MetadataDescription.SUPPORTS_STORED_PROCEDURES, null, null, false))
1510        .booleanValue();
1511  }
1512
1513  /**
1514   * @see java.sql.DatabaseMetaData#supportsSubqueriesInComparisons()
1515   */
1516  public boolean supportsSubqueriesInComparisons() throws SQLException
1517  {
1518    return ((Boolean ) getMetadata(
1519        MetadataDescription.SUPPORTS_SUB_QUERIES_IN_COMPARISONS, null, null,
1520        false)).booleanValue();
1521  }
1522
1523  /**
1524   * @see java.sql.DatabaseMetaData#supportsSubqueriesInExists()
1525   */
1526  public boolean supportsSubqueriesInExists() throws SQLException
1527  {
1528    return ((Boolean ) getMetadata(
1529        MetadataDescription.SUPPORTS_SUB_QUERIES_IN_EXISTS, null, null, false))
1530        .booleanValue();
1531  }
1532
1533  /**
1534   * @see java.sql.DatabaseMetaData#supportsSubqueriesInIns()
1535   */
1536  public boolean supportsSubqueriesInIns() throws SQLException
1537  {
1538    return ((Boolean ) getMetadata(
1539        MetadataDescription.SUPPORTS_SUB_QUERIES_IN_INS, null, null, false))
1540        .booleanValue();
1541  }
1542
1543  /**
1544   * @see java.sql.DatabaseMetaData#supportsSubqueriesInQuantifieds()
1545   */
1546  public boolean supportsSubqueriesInQuantifieds() throws SQLException
1547  {
1548    return ((Boolean ) getMetadata(
1549        MetadataDescription.SUPPORTS_SUB_QUERIES_IN_QUANTIFIEDS, null, null,
1550        false)).booleanValue();
1551  }
1552
1553  /**
1554   * @see java.sql.DatabaseMetaData#supportsTableCorrelationNames()
1555   */
1556  public boolean supportsTableCorrelationNames() throws SQLException
1557  {
1558    return ((Boolean ) getMetadata(
1559        MetadataDescription.SUPPORTS_TABLE_CORRELATION_NAMES, null, null, false))
1560        .booleanValue();
1561  }
1562
1563  /**
1564   * @see java.sql.DatabaseMetaData#supportsTransactionIsolationLevel(int)
1565   */
1566  public boolean supportsTransactionIsolationLevel(int level)
1567      throws SQLException
1568  {
1569    return ((Boolean ) getMetadata(
1570        MetadataDescription.SUPPORTS_TRANSACTION_ISOLATION_LEVEL,
1571        new Class []{Integer.TYPE}, new Object []{new Integer (level)}, false))
1572        .booleanValue();
1573  }
1574
1575  /**
1576   * @see java.sql.DatabaseMetaData#supportsTransactions()
1577   */
1578  public boolean supportsTransactions() throws SQLException
1579  {
1580    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_TRANSACTIONS,
1581        null, null, false)).booleanValue();
1582  }
1583
1584  /**
1585   * @see java.sql.DatabaseMetaData#supportsUnion()
1586   */
1587  public boolean supportsUnion() throws SQLException
1588  {
1589    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_UNION, null,
1590        null, false)).booleanValue();
1591  }
1592
1593  /**
1594   * @see java.sql.DatabaseMetaData#supportsUnionAll()
1595   */
1596  public boolean supportsUnionAll() throws SQLException
1597  {
1598    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_UNION_ALL, null,
1599        null, false)).booleanValue();
1600  }
1601
1602  /**
1603   * @see java.sql.DatabaseMetaData#updatesAreDetected(int)
1604   */
1605  public boolean updatesAreDetected(int type) throws SQLException
1606  {
1607    return ((Boolean ) getMetadata(MetadataDescription.UPDATES_ARE_DETECTED,
1608        new Class []{Integer.TYPE}, new Object []{new Integer (type)}, false))
1609        .booleanValue();
1610  }
1611
1612  /**
1613   * @see java.sql.DatabaseMetaData#usesLocalFilePerTable()
1614   */
1615  public boolean usesLocalFilePerTable() throws SQLException
1616  {
1617    return ((Boolean ) getMetadata(
1618        MetadataDescription.USES_LOCAL_FILE_PER_TABLE, null, null, false))
1619        .booleanValue();
1620  }
1621
1622  /**
1623   * @see java.sql.DatabaseMetaData#usesLocalFiles()
1624   */
1625  public boolean usesLocalFiles() throws SQLException
1626  {
1627    return ((Boolean ) getMetadata(MetadataDescription.USES_LOCAL_FILES, null,
1628        null, false)).booleanValue();
1629  }
1630
1631  // ------------------- JDBC 3.0 -------------------------
1632
1633  /**
1634   * @see java.sql.DatabaseMetaData#supportsSavepoints()
1635   */
1636  public boolean supportsSavepoints() throws SQLException
1637  {
1638    return ((Boolean ) getMetadata(MetadataDescription.SUPPORTS_SAVEPOINTS,
1639        null, null, false)).booleanValue();
1640  }
1641
1642  /**
1643   * @see java.sql.DatabaseMetaData#supportsNamedParameters()
1644   */
1645  public boolean supportsNamedParameters() throws SQLException
1646  {
1647    return ((Boolean ) getMetadata(
1648        MetadataDescription.SUPPORTS_NAMED_PARAMETERS, null, null, false))
1649        .booleanValue();
1650  }
1651
1652  /**
1653   * @see java.sql.DatabaseMetaData#supportsMultipleOpenResults()
1654   */
1655  public boolean supportsMultipleOpenResults() throws SQLException
1656  {
1657    return ((Boolean ) getMetadata(
1658        MetadataDescription.SUPPORTS_MULTIPLE_OPEN_RESULTS, null, null, false))
1659        .booleanValue();
1660  }
1661
1662  /**
1663   * @see java.sql.DatabaseMetaData#supportsGetGeneratedKeys()
1664   */
1665  public boolean supportsGetGeneratedKeys() throws SQLException
1666  {
1667    return ((Boolean ) getMetadata(
1668        MetadataDescription.SUPPORTS_GET_GENERATED_KEYS, null, null, false))
1669        .booleanValue();
1670  }
1671
1672  /**
1673   * @see java.sql.DatabaseMetaData#getSuperTypes(java.lang.String,
1674   * java.lang.String, java.lang.String)
1675   */
1676  public java.sql.ResultSet getSuperTypes(String catalog, String schemaPattern,
1677      String typeNamePattern) throws SQLException
1678  {
1679    return connection.getSuperTypes(catalog, schemaPattern, typeNamePattern);
1680  }
1681
1682  /**
1683   * @see java.sql.DatabaseMetaData#getSuperTables(java.lang.String,
1684   * java.lang.String, java.lang.String)
1685   */
1686  public java.sql.ResultSet getSuperTables(String catalog,
1687      String schemaPattern, String tableNamePattern) throws SQLException
1688  {
1689    return connection.getSuperTables(catalog, schemaPattern, tableNamePattern);
1690  }
1691
1692  /**
1693   * @see java.sql.DatabaseMetaData#getAttributes(java.lang.String,
1694   * java.lang.String, java.lang.String, java.lang.String)
1695   */
1696  public java.sql.ResultSet getAttributes(String catalog, String schemaPattern,
1697      String typeNamePattern, String attributeNamePattern) throws SQLException
1698  {
1699    return connection.getAttributes(catalog, schemaPattern, typeNamePattern,
1700        attributeNamePattern);
1701  }
1702
1703  /**
1704   * @see java.sql.DatabaseMetaData#getResultSetHoldability()
1705   */
1706  public int getResultSetHoldability() throws SQLException
1707  {
1708    return ((Integer ) getMetadata(
1709        MetadataDescription.GET_RESULTSET_HOLDABILITY, null, null, false))
1710        .intValue();
1711  }
1712
1713  /**
1714   * @see java.sql.DatabaseMetaData#getDatabaseMajorVersion()
1715   */
1716  public int getDatabaseMajorVersion() throws SQLException
1717  {
1718    return ((Integer ) getMetadata(
1719        MetadataDescription.GET_DATABASE_MAJOR_VERSION, null, null, false))
1720        .intValue();
1721  }
1722
1723  /**
1724   * @see java.sql.DatabaseMetaData#getDatabaseMinorVersion()
1725   */
1726  public int getDatabaseMinorVersion() throws SQLException
1727  {
1728    return ((Integer ) getMetadata(
1729        MetadataDescription.GET_DATABASE_MINOR_VERSION, null, null, false))
1730        .intValue();
1731  }
1732
1733  /**
1734   * Retrieves the major JDBC version number for this driver.
1735   *
1736   * @return JDBC version major number
1737   * @exception SQLException if a database access error occurs
1738   * @since JDK 1.4
1739   */
1740  public int getJDBCMajorVersion() throws SQLException
1741  {
1742    return Driver.MAJOR_VERSION;
1743  }
1744
1745  /**
1746   * Retrieves the minor JDBC version number for this driver.
1747   *
1748   * @return JDBC version minor number
1749   * @exception SQLException if a database access error occurs
1750   * @since JDK 1.4
1751   */
1752  public int getJDBCMinorVersion() throws SQLException
1753  {
1754    return Driver.MINOR_VERSION;
1755  }
1756
1757  /**
1758   * @see java.sql.DatabaseMetaData#getSQLStateType()
1759   */
1760  public int getSQLStateType() throws SQLException
1761  {
1762    return ((Integer ) getMetadata(MetadataDescription.GET_SQL_STATE_TYPE, null,
1763        null, false)).intValue();
1764  }
1765
1766  /**
1767   * @see java.sql.DatabaseMetaData#locatorsUpdateCopy()
1768   */
1769  public boolean locatorsUpdateCopy() throws SQLException
1770  {
1771    return ((Boolean ) getMetadata(MetadataDescription.LOCATORS_UPDATE_COPY,
1772        null, null, false)).booleanValue();
1773  }
1774
1775  /**
1776   * @see java.sql.DatabaseMetaData#supportsStatementPooling()
1777   */
1778  public boolean supportsStatementPooling() throws SQLException
1779  {
1780    return ((Boolean ) getMetadata(
1781        MetadataDescription.SUPPORTS_STATEMENT_POOLING, null, null, false))
1782        .booleanValue();
1783  }
1784}

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---