001    /* DatabaseMetaData.java -- Information about the database itself.
002       Copyright (C) 1999, 2000, 2001, 2002, 2006 Free Software Foundation, Inc.
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010    
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    package java.sql;
039    
040    public interface DatabaseMetaData
041    {
042      /**
043       * It is unknown whether or not the procedure returns a result.
044       */
045      int procedureResultUnknown = 0;
046    
047      /**
048       * The procedure does not return a result.
049       */
050      int procedureNoResult = 1;
051    
052      /**
053       * The procedure returns a result.
054       */
055      int procedureReturnsResult = 2;
056    
057      /**
058       * The column type is unknown.
059       */
060      int procedureColumnUnknown = 0;
061    
062      /**
063       * The column type is input.
064       */
065      int procedureColumnIn = 1;
066    
067      /**
068       * The column type is input/output.
069       */
070      int procedureColumnInOut = 2;
071    
072      /**
073       * The column type is output
074       */
075      int procedureColumnOut = 4;
076    
077      /**
078       * The column is used for return values.
079       */
080      int procedureColumnReturn = 5;
081    
082      /**
083       * The column is used for storing results
084       */
085      int procedureColumnResult = 3;
086    
087      /**
088       * NULL values are not allowed.
089       */
090      int procedureNoNulls = 0;
091    
092      /**
093       * NULL values are allowed.
094       */
095      int procedureNullable = 1;
096    
097      /**
098       * It is unknown whether or not NULL values are allowed.
099       */
100      int procedureNullableUnknown = 2;
101    
102      /**
103       * The column does not allow NULL
104       */
105      int columnNoNulls = 0;
106    
107      /**
108       * The column does allow NULL
109       */
110      int columnNullable = 1;
111    
112      /**
113       * It is unknown whether or not the column allows NULL
114       */
115      int columnNullableUnknown = 2;
116    
117      /**
118       * The best row's scope is only guaranteed to be valid so long as the
119       * row is actually being used.
120       */
121      int bestRowTemporary = 0;
122    
123      /**
124       * The best row identifier is valid to the end of the transaction.
125       */
126      int bestRowTransaction = 1;
127    
128      /**
129       * The best row identifier is valid to the end of the session.
130       */
131      int bestRowSession = 2;
132    
133      /**
134       * The best row may or may not be a pseudo-column.
135       */
136      int bestRowUnknown = 0;
137    
138      /**
139       * The best row identifier is not a pseudo-column.
140       */
141      int bestRowNotPseudo = 1;
142    
143      /**
144       * The best row identifier is a pseudo-column.
145       */
146      int bestRowPseudo = 2;
147    
148      /**
149       * It is unknown whether or not the version column is a pseudo-column.
150       */
151      int versionColumnUnknown = 0;
152    
153      /**
154       * The version column is not a pseudo-column
155       */
156      int versionColumnNotPseudo = 1;
157    
158      /**
159       * The version column is a pseudo-column
160       */
161      int versionColumnPseudo = 2;
162    
163      /**
164       * Foreign key changes are cascaded in updates or deletes.
165       */
166      int importedKeyCascade = 0;
167    
168      /**
169       * Column may not be updated or deleted in use as a foreign key.
170       */
171      int importedKeyRestrict = 1;
172    
173      /**
174       * When primary key is updated or deleted, the foreign key is set to NULL.
175       */
176      int importedKeySetNull = 2;
177    
178      /**
179       * If the primary key is a foreign key, it cannot be udpated or deleted.
180       */
181      int importedKeyNoAction = 3;
182    
183      /**
184       * If the primary key is updated or deleted, the foreign key is set to
185       * a default value.
186       */
187      int importedKeySetDefault = 4;
188    
189      /**
190       * Wish I knew what this meant.
191       */
192      int importedKeyInitiallyDeferred = 5;
193    
194      /**
195       * Wish I knew what this meant.
196       */
197      int importedKeyInitiallyImmediate = 6;
198    
199      /**
200       * Wish I knew what this meant.
201       */
202      int importedKeyNotDeferrable = 7;
203    
204      /**
205       * A NULL value is not allowed for this data type.
206       */
207      int typeNoNulls = 0;
208    
209      /**
210       * A NULL value is allowed for this data type.
211       */
212      int typeNullable = 1;
213    
214      /**
215       * It is unknown whether or not NULL values are allowed for this data type.
216       */
217      int typeNullableUnknown = 2;
218    
219      /**
220       * Where clauses are not supported for this type.
221       */
222      int typePredNone = 0;
223    
224      /**
225       * Only "WHERE..LIKE" style WHERE clauses are allowed on this data type.
226       */
227      int typePredChar = 1;
228    
229      /**
230       * All WHERE clauses except "WHERE..LIKE" style are allowed on this data type.
231       */
232      int typePredBasic = 2;
233    
234      /**
235       * Any type of WHERE clause is allowed for this data type.
236       */
237      int typeSearchable = 3;
238    
239      /**
240       * This column contains table statistics.
241       */
242      short tableIndexStatistic = 0;
243    
244      /**
245       * This table index is clustered.
246       */
247      short tableIndexClustered = 1;
248    
249      /**
250       * This table index is hashed.
251       */
252      short tableIndexHashed = 2;
253    
254      /**
255       * This table index is of another type.
256       */
257      short tableIndexOther = 3;
258    
259      /**
260       * A NULL value is not allowed for this attribute.
261       */
262      short attributeNoNulls = 0;
263    
264      /**
265       * A NULL value is allowed for this attribute.
266       */
267      short attributeNullable = 1;
268    
269      /**
270       * It is unknown whether or not NULL values are allowed for this attribute.
271       */
272      short attributeNullableUnknown = 2;
273    
274      int sqlStateXOpen = 1;
275    
276      int sqlStateSQL99 = 2;
277    
278      /**
279       * This method tests whether or not all the procedures returned by
280       * the <code>getProcedures</code> method can be called by this user.
281       *
282       * @return <code>true</code> if all the procedures can be called,
283       * <code>false</code> otherwise.
284       * @exception SQLException If an error occurs.
285       */
286      boolean allProceduresAreCallable() throws SQLException;
287    
288      /**
289       * This method tests whether or not all the table returned by the
290       * <code>getTables</code> method can be selected by this user.
291       *
292       * @return <code>true</code> if all the procedures can be called,
293       * <code>false</code> otherwise.
294       *
295       * @exception SQLException If an error occurs.
296       */
297      boolean allTablesAreSelectable() throws SQLException;
298    
299      /**
300       * This method returns the URL for this database.
301       *
302       * @return The URL string for this database, or <code>null</code> if it
303       *         is not known.
304       * @exception SQLException If an error occurs.
305       */
306      String getURL() throws SQLException;
307    
308      /**
309       * This method returns the database username for this connection.
310       *
311       * @return The database username.
312       * @exception SQLException If an error occurs.
313       */
314      String getUserName() throws SQLException;
315    
316      /**
317       * This method tests whether or not the database is in read only mode.
318       *
319       * @return <code>true</code> if the database is in read only mode,
320       *         <code>false</code> otherwise.
321       * @exception SQLException If an error occurs.
322       */
323      boolean isReadOnly() throws SQLException;
324    
325      /**
326       * This method tests whether or not NULL's sort as high values.
327       *
328       * @return <code>true</code> if NULL's sort as high values, <code>false</code>
329       *         otherwise.
330       * @exception SQLException If an error occurs.
331       */
332      boolean nullsAreSortedHigh() throws SQLException;
333    
334      /**
335       * This method tests whether or not NULL's sort as low values.
336       *
337       * @return <code>true</code> if NULL's sort as low values, <code>false</code>
338       * otherwise.
339       * @exception SQLException If an error occurs.
340       */
341      boolean nullsAreSortedLow() throws SQLException;
342    
343      /**
344       * This method tests whether or not NULL's sort as high values.
345       *
346       * @return <code>true</code> if NULL's sort as high values, <code>false</code>
347       * otherwise.
348       * @exception SQLException If an error occurs.
349       */
350      boolean nullsAreSortedAtStart() throws SQLException;
351    
352      /**
353       * This method test whether or not NULL's are sorted to the end
354       * of the list regardless of ascending or descending sort order.
355       *
356       * @return <code>true</code> if NULL's always sort to the end,
357       * <code>false</code> otherwise.
358       * @exception SQLException If an error occurs.
359       */
360      boolean nullsAreSortedAtEnd() throws SQLException;
361    
362      /**
363       * This method returns the name of the database product.
364       *
365       * @return The database product.
366       * @exception SQLException If an error occurs.
367       */
368      String getDatabaseProductName() throws SQLException;
369    
370      /**
371       * This method returns the version of the database product.
372       *
373       * @return The version of the database product.
374       * @exception SQLException If an error occurs.
375       */
376      String getDatabaseProductVersion() throws SQLException;
377    
378      /**
379       * This method returns the name of the JDBC driver.
380       *
381       * @return The name of the JDBC driver.
382       * @exception SQLException If an error occurs.
383       */
384      String getDriverName() throws SQLException;
385    
386      /**
387       * This method returns the version of the JDBC driver.
388       *
389       * @return The version of the JDBC driver.
390       * @exception SQLException If an error occurs.
391       */
392      String getDriverVersion() throws SQLException;
393    
394      /**
395       * This method returns the major version number of the JDBC driver.
396       *
397       * @return The major version number of the JDBC driver.
398       */
399      int getDriverMajorVersion();
400    
401      /**
402       * This method returns the minor version number of the JDBC driver.
403       *
404       * @return The minor version number of the JDBC driver.
405       */
406      int getDriverMinorVersion();
407    
408      /**
409       * This method tests whether or not the database uses local files to
410       * store tables.
411       *
412       * @return <code>true</code> if the database uses local files,
413       * <code>false</code> otherwise.
414       *
415       * @exception SQLException If an error occurs.
416       */
417      boolean usesLocalFiles() throws SQLException;
418    
419      /**
420       * This method tests whether or not the database uses a separate file for
421       * each table.
422       *
423       * @return <code>true</code> if the database uses a separate file for each
424       * table <code>false</code> otherwise.
425       *
426       * @exception SQLException If an error occurs.
427       */
428      boolean usesLocalFilePerTable() throws SQLException;
429    
430      /**
431       * This method tests whether or not the database supports identifiers
432       * with mixed case.
433       *
434       * @return <code>true</code> if the database supports mixed case identifiers,
435       * <code>false</code> otherwise.
436       *
437       * @exception SQLException If an error occurs.
438       */
439      boolean supportsMixedCaseIdentifiers() throws SQLException;
440    
441      /**
442       * This method tests whether or not the database treats mixed case
443       * identifiers as all upper case.
444       *
445       * @return <code>true</code> if the database treats all identifiers as
446       *         upper case, <code>false</code> otherwise.
447       * @exception SQLException If an error occurs.
448       */
449      boolean storesUpperCaseIdentifiers() throws SQLException;
450    
451      /**
452       * This method tests whether or not the database treats mixed case
453       * identifiers as all lower case.
454       *
455       * @return <code>true</code> if the database treats all identifiers as
456       *         lower case, <code>false</code> otherwise.
457       * @exception SQLException If an error occurs.
458       */
459      boolean storesLowerCaseIdentifiers() throws SQLException;
460    
461      /**
462       * This method tests whether or not the database stores mixed case
463       * identifers even if it treats them as case insensitive.
464       *
465       * @return <code>true</code> if the database stores mixed case identifiers,
466       *         <code>false</code> otherwise.
467       * @exception SQLException If an error occurs.
468       */
469      boolean storesMixedCaseIdentifiers() throws SQLException;
470    
471      /**
472       * This method tests whether or not the database supports quoted identifiers
473       * with mixed case.
474       *
475       * @return <code>true</code> if the database supports mixed case quoted
476       *         identifiers, <code>false</code> otherwise.
477       * @exception SQLException If an error occurs.
478       */
479      boolean supportsMixedCaseQuotedIdentifiers() throws SQLException;
480    
481      /**
482       * This method tests whether or not the database treats mixed case
483       * quoted identifiers as all upper case.
484       *
485       * @return <code>true</code> if the database treats all quoted identifiers
486       *         as upper case, <code>false</code> otherwise.
487       * @exception SQLException If an error occurs.
488       */
489      boolean storesUpperCaseQuotedIdentifiers() throws SQLException;
490    
491      /**
492       * This method tests whether or not the database treats mixed case
493       * quoted identifiers as all lower case.
494       *
495       * @return <code>true</code> if the database treats all quoted identifiers
496       *         as lower case, <code>false</code> otherwise.
497       * @exception SQLException If an error occurs.
498       */
499      boolean storesLowerCaseQuotedIdentifiers() throws SQLException;
500    
501      /**
502       * This method tests whether or not the database stores mixed case
503       * quoted identifers even if it treats them as case insensitive.
504       *
505       * @return <code>true</code> if the database stores mixed case quoted
506       *         identifiers, <code>false</code> otherwise.
507       * @exception SQLException If an error occurs.
508       */
509      boolean storesMixedCaseQuotedIdentifiers() throws SQLException;
510    
511      /**
512       * This metohd returns the quote string for SQL identifiers.
513       *
514       * @return The quote string for SQL identifers, or a space if quoting
515       *         is not supported.
516       * @exception SQLException If an error occurs.
517       */
518      String getIdentifierQuoteString() throws SQLException;
519    
520      /**
521       * This method returns a comma separated list of all the SQL keywords in
522       * the database that are not in SQL92.
523       *
524       * @return The list of SQL keywords not in SQL92.
525       * @exception SQLException If an error occurs.
526       */
527      String getSQLKeywords() throws SQLException;
528    
529      /**
530       * This method returns a comma separated list of math functions.
531       *
532       * @return The list of math functions.
533       * @exception SQLException If an error occurs.
534       */
535      String getNumericFunctions() throws SQLException;
536    
537      /**
538       * This method returns a comma separated list of string functions.
539       *
540       * @return The list of string functions.
541       * @exception SQLException If an error occurs.
542       */
543      String getStringFunctions() throws SQLException;
544    
545      /**
546       * This method returns a comma separated list of of system functions.
547       *
548       * @return A comma separated list of system functions.
549       * @exception SQLException If an error occurs.
550       */
551      String getSystemFunctions() throws SQLException;
552    
553      /**
554       * This method returns comma separated list of time/date functions.
555       *
556       * @return The list of time/date functions.
557       * @exception SQLException If an error occurs.
558       */
559      String getTimeDateFunctions() throws SQLException;
560    
561      /**
562       * This method returns the string used to escape wildcards in search strings.
563       *
564       * @return The string used to escape wildcards in search strings.
565       * @exception SQLException If an error occurs.
566       */
567      String getSearchStringEscape() throws SQLException;
568    
569      /**
570       * This methods returns non-standard characters that can appear in
571       * unquoted identifiers.
572       *
573       * @return Non-standard characters that can appear in unquoted identifiers.
574       * @exception SQLException If an error occurs.
575       */
576      String getExtraNameCharacters() throws SQLException;
577    
578      /**
579       * This method tests whether or not the database supports
580       * "ALTER TABLE ADD COLUMN"
581       *
582       * @return <code>true</code> if column add supported, <code>false</code>
583       *         otherwise.
584       * @exception SQLException If an error occurs.
585       */
586      boolean supportsAlterTableWithAddColumn() throws SQLException;
587    
588      /**
589       * This method tests whether or not the database supports
590       * "ALTER TABLE DROP COLUMN"
591       *
592       * @return <code>true</code> if column drop supported, <code>false</code>
593       *         otherwise.
594       * @exception SQLException If an error occurs.
595       */
596      boolean supportsAlterTableWithDropColumn() throws SQLException;
597    
598      /**
599       * This method tests whether or not column aliasing is supported.
600       *
601       * @return <code>true</code> if column aliasing is supported,
602       *         <code>false</code> otherwise.
603       * @exception SQLException If an error occurs.
604       */
605      boolean supportsColumnAliasing() throws SQLException;
606    
607      /**
608       * This method tests whether the concatenation of a NULL and non-NULL
609       * value results in a NULL.  This will always be true in fully JDBC compliant
610       * drivers.
611       *
612       * @return <code>true</code> if concatenating NULL and a non-NULL value
613       *         returns a NULL, <code>false</code> otherwise.
614       * @exception SQLException If an error occurs.
615       */
616      boolean nullPlusNonNullIsNull() throws SQLException;
617    
618      /**
619       * Tests whether or not CONVERT is supported.
620       *
621       * @return <code>true</code> if CONVERT is supported, <code>false</code>
622       *         otherwise.
623       * @exception SQLException If an error occurs.
624       */
625      boolean supportsConvert() throws SQLException;
626    
627      /**
628       * This method tests whether or not CONVERT can be performed between the
629       * specified types.  The types are contants from <code>Types</code>.
630       *
631       * @param fromType The SQL type to convert from.
632       * @param toType The SQL type to convert to.
633       * @return <code>true</code> if the conversion can be performed,
634       *         <code>false</code> otherwise.
635       * @see Types
636       */
637      boolean supportsConvert(int fromType, int toType) throws
638          SQLException;
639    
640      /**
641       * This method tests whether or not table correlation names are
642       * supported.  This will be always be <code>true</code> in a fully JDBC
643       * compliant driver.
644       *
645       * @return <code>true</code> if table correlation names are supported,
646       *         <code>false</code> otherwise.
647       * @exception SQLException If an error occurs.
648       */
649      boolean supportsTableCorrelationNames() throws SQLException;
650    
651      /**
652       * This method tests whether correlation names must be different from the
653       * name of the table.
654       *
655       * @return <code>true</code> if the correlation name must be different from
656       *         the table name, <code>false</code> otherwise.
657       * @exception SQLException If an error occurs.
658       */
659      boolean supportsDifferentTableCorrelationNames() throws SQLException;
660    
661      /**
662       * This method tests whether or not expressions are allowed in an
663       * ORDER BY lists.
664       *
665       * @return <code>true</code> if expressions are allowed in ORDER BY
666       *         lists, <code>false</code> otherwise.
667       * @exception SQLException If an error occurs.
668       */
669      boolean supportsExpressionsInOrderBy() throws SQLException;
670    
671      /**
672       * This method tests whether or ORDER BY on a non-selected column is
673       * allowed.
674       *
675       * @return <code>true</code> if a non-selected column can be used in an
676       *         ORDER BY, <code>false</code> otherwise.
677       * @exception SQLException If an error occurs.
678       */
679      boolean supportsOrderByUnrelated() throws SQLException;
680    
681      /**
682       * This method tests whether or not GROUP BY is supported.
683       *
684       * @return <code>true</code> if GROUP BY is supported, <code>false</code>
685       *         otherwise.
686       * @exception SQLException If an error occurs.
687       */
688      boolean supportsGroupBy() throws SQLException;
689    
690      /**
691       * This method tests whether GROUP BY on a non-selected column is
692       * allowed.
693       *
694       * @return <code>true</code> if a non-selected column can be used in a
695       *         GROUP BY, <code>false</code> otherwise.
696       * @exception SQLException If an error occurs.
697       */
698      boolean supportsGroupByUnrelated() throws SQLException;
699    
700      /**
701       * This method tests whether or not a GROUP BY can add columns not in the
702       * select if it includes all the columns in the select.
703       *
704       * @return <code>true</code> if GROUP BY an add columns provided it includes
705       *         all columns in the select, <code>false</code> otherwise.
706       * @exception SQLException If an error occurs.
707       */
708      boolean supportsGroupByBeyondSelect() throws SQLException;
709    
710      /**
711       * This method tests whether or not the escape character is supported in
712       * LIKE expressions.  A fully JDBC compliant driver will always return
713       * <code>true</code>.
714       *
715       * @return <code>true</code> if escapes are supported in LIKE expressions,
716       *         <code>false</code> otherwise.
717       * @exception SQLException If an error occurs.
718       */
719      boolean supportsLikeEscapeClause() throws SQLException;
720    
721      /**
722       * This method tests whether multiple result sets for a single statement are
723       * supported.
724       *
725       * @return <code>true</code> if multiple result sets are supported for a
726       *         single statement, <code>false</code> otherwise.
727       * @exception SQLException If an error occurs.
728       */
729      boolean supportsMultipleResultSets() throws SQLException;
730    
731      /**
732       * This method test whether or not multiple transactions may be open
733       * at once, as long as they are on different connections.
734       *
735       * @return <code>true</code> if multiple transactions on different
736       *         connections are supported, <code>false</code> otherwise.
737       * @exception SQLException If an error occurs.
738       */
739      boolean supportsMultipleTransactions() throws SQLException;
740    
741      /**
742       * This method tests whether or not columns can be defined as NOT NULL.  A
743       * fully JDBC compliant driver always returns <code>true</code>.
744       *
745       * @return <code>true</code> if NOT NULL columns are supported,
746       *         <code>false</code> otherwise.
747       * @exception SQLException If an error occurs.
748       */
749      boolean supportsNonNullableColumns() throws SQLException;
750    
751      /**
752       * This method tests whether or not the minimum grammer for ODBC is supported.
753       * A fully JDBC compliant driver will always return <code>true</code>.
754       *
755       * @return <code>true</code> if the ODBC minimum grammar is supported,
756       *         <code>false</code> otherwise.
757       * @exception SQLException If an error occurs.
758       */
759      boolean supportsMinimumSQLGrammar() throws SQLException;
760    
761      /**
762       * This method tests whether or not the core grammer for ODBC is supported.
763       *
764       * @return <code>true</code> if the ODBC core grammar is supported,
765       *         <code>false</code> otherwise.
766       * @exception SQLException If an error occurs.
767       */
768      boolean supportsCoreSQLGrammar() throws SQLException;
769    
770      /**
771       * This method tests whether or not the extended grammer for ODBC is supported.
772       *
773       * @return <code>true</code> if the ODBC extended grammar is supported,
774       *         <code>false</code> otherwise.
775       * @exception SQLException If an error occurs.
776       */
777      boolean supportsExtendedSQLGrammar() throws SQLException;
778    
779      /**
780       * This method tests whether or not the ANSI92 entry level SQL
781       * grammar is supported.  A fully JDBC compliant drivers must return
782       * <code>true</code>.
783       *
784       * @return <code>true</code> if the ANSI92 entry level SQL grammar is
785       *         supported, <code>false</code> otherwise.
786       * @exception SQLException If an error occurs.
787       */
788      boolean supportsANSI92EntryLevelSQL() throws SQLException;
789    
790      /**
791       * This method tests whether or not the ANSI92 intermediate SQL
792       * grammar is supported.
793       *
794       * @return <code>true</code> if the ANSI92 intermediate SQL grammar is
795       *         supported, <code>false</code> otherwise.
796       * @exception SQLException If an error occurs.
797       */
798      boolean supportsANSI92IntermediateSQL() throws SQLException;
799    
800      /**
801       * This method tests whether or not the ANSI92 full SQL
802       * grammar is supported.
803       *
804       * @return <code>true</code> if the ANSI92 full SQL grammar is
805       *         supported, <code>false</code> otherwise.
806       * @exception SQLException If an error occurs.
807       */
808      boolean supportsANSI92FullSQL() throws SQLException;
809    
810      /**
811       * This method tests whether or not the SQL integrity enhancement
812       * facility is supported.
813       *
814       * @return <code>true</code> if the integrity enhancement facility is
815       *         supported, <code>false</code> otherwise.
816       * @exception SQLException If an error occurs.
817       */
818      boolean supportsIntegrityEnhancementFacility() throws SQLException;
819    
820      /**
821       * This method tests whether or not the database supports outer joins.
822       *
823       * @return <code>true</code> if outer joins are supported, <code>false</code>
824       *         otherwise.
825       * @exception SQLException If an error occurs.
826       */
827      boolean supportsOuterJoins() throws SQLException;
828    
829      /**
830       * This method tests whether or not the database supports full outer joins.
831       *
832       * @return <code>true</code> if full outer joins are supported,
833       *         <code>false</code> otherwise.
834       * @exception SQLException If an error occurs.
835       */
836      boolean supportsFullOuterJoins() throws SQLException;
837    
838      /**
839       * This method tests whether or not the database supports limited outer joins.
840       *
841       * @return <code>true</code> if limited outer joins are supported,
842       *         <code>false</code> otherwise.
843       * @exception SQLException If an error occurs.
844       */
845      boolean supportsLimitedOuterJoins() throws SQLException;
846    
847      /**
848       * This method returns the vendor's term for "schema".
849       *
850       * @return The vendor's term for schema.
851       * @exception SQLException if an error occurs.
852       */
853      String getSchemaTerm() throws SQLException;
854    
855      /**
856       * This method returns the vendor's term for "procedure".
857       *
858       * @return The vendor's term for procedure.
859       * @exception SQLException if an error occurs.
860       */
861      String getProcedureTerm() throws SQLException;
862    
863      /**
864       * This method returns the vendor's term for "catalog".
865       *
866       * @return The vendor's term for catalog.
867       * @exception SQLException if an error occurs.
868       */
869      String getCatalogTerm() throws SQLException;
870    
871      /**
872       * This method tests whether a catalog name appears at the beginning of
873       * a fully qualified table name.
874       *
875       * @return <code>true</code> if the catalog name appears at the beginning,
876       *         <code>false</code> if it appears at the end.
877       * @exception SQLException If an error occurs.
878       */
879      boolean isCatalogAtStart() throws SQLException;
880    
881      /**
882       * This method returns the separator between the catalog name and the
883       * table name.
884       *
885       * @return The separator between the catalog name and the table name.
886       * @exception SQLException If an error occurs.
887       */
888      String getCatalogSeparator() throws SQLException;
889    
890      /**
891       * This method tests whether a catalog name can appear in a data
892       * manipulation statement.
893       *
894       * @return <code>true</code> if a catalog name can appear in a data
895       *         manipulation statement, <code>false</code> otherwise.
896       * @exception SQLException If an error occurs.
897       */
898      boolean supportsSchemasInDataManipulation() throws SQLException;
899    
900      /**
901       * This method tests whether a catalog name can appear in a procedure
902       * call
903       *
904       * @return <code>true</code> if a catalog name can appear in a procedure
905       *         call, <code>false</code> otherwise.
906       * @exception SQLException If an error occurs.
907       */
908      boolean supportsSchemasInProcedureCalls() throws SQLException;
909    
910      /**
911       * This method tests whether a catalog name can appear in a table definition.
912       *
913       * @return <code>true</code> if a catalog name can appear in a table
914       *         definition, <code>false</code> otherwise.
915       * @exception SQLException If an error occurs.
916       */
917      boolean supportsSchemasInTableDefinitions() throws SQLException;
918    
919      /**
920       * This method tests whether a catalog name can appear in an index definition.
921       *
922       * @return <code>true</code> if a catalog name can appear in an index
923       *         definition, <code>false</code> otherwise.
924       * @exception SQLException If an error occurs.
925       */
926      boolean supportsSchemasInIndexDefinitions() throws SQLException;
927    
928      /**
929       * This method tests whether a catalog name can appear in privilege definitions.
930       *
931       * @return <code>true</code> if a catalog name can appear in privilege
932       *         definition, <code>false</code> otherwise.
933       * @exception SQLException If an error occurs.
934       */
935      boolean supportsSchemasInPrivilegeDefinitions() throws SQLException;
936    
937      /**
938       * This method tests whether a catalog name can appear in a data
939       * manipulation statement.
940       *
941       * @return <code>true</code> if a catalog name can appear in a data
942       *         manipulation statement, <code>false</code> otherwise.
943       * @exception SQLException If an error occurs.
944       */
945      boolean supportsCatalogsInDataManipulation() throws SQLException;
946    
947      /**
948       * This method tests whether a catalog name can appear in a procedure
949       * call
950       *
951       * @return <code>true</code> if a catalog name can appear in a procedure
952       *         call, <code>false</code> otherwise.
953       * @exception SQLException If an error occurs.
954       */
955      boolean supportsCatalogsInProcedureCalls() throws SQLException;
956    
957      /**
958       * This method tests whether a catalog name can appear in a table definition.
959       *
960       * @return <code>true</code> if a catalog name can appear in a table
961       *         definition, <code>false</code> otherwise.
962       * @exception SQLException If an error occurs.
963       */
964      boolean supportsCatalogsInTableDefinitions() throws SQLException;
965    
966      /**
967       * This method tests whether a catalog name can appear in an index definition.
968       *
969       * @return <code>true</code> if a catalog name can appear in an index
970       *         definition, <code>false</code> otherwise.
971       * @exception SQLException If an error occurs.
972       */
973      boolean supportsCatalogsInIndexDefinitions() throws SQLException;
974    
975      /**
976       * This method tests whether a catalog name can appear in privilege definitions.
977       *
978       * @return <code>true</code> if a catalog name can appear in privilege
979       *         definition, <code>false</code> otherwise.
980       * @exception SQLException If an error occurs.
981       */
982      boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException;
983    
984      /**
985       * This method tests whether or not that database supports positioned
986       * deletes.
987       *
988       * @return <code>true</code> if positioned deletes are supported,
989       *         <code>false</code> otherwise.
990       * @exception SQLException If an error occurs.
991       */
992      boolean supportsPositionedDelete() throws SQLException;
993    
994      /**
995       * This method tests whether or not that database supports positioned
996       * updates.
997       *
998       * @return <code>true</code> if positioned updates are supported,
999       *         <code>false</code> otherwise.
1000       * @exception SQLException If an error occurs.
1001       */
1002      boolean supportsPositionedUpdate() throws SQLException;
1003    
1004      /**
1005       * This method tests whether or not SELECT FOR UPDATE is supported by the
1006       * database.
1007       *
1008       * @return <code>true</code> if SELECT FOR UPDATE is supported
1009       *         <code>false</code> otherwise.
1010       * @exception SQLException If an error occurs.
1011       */
1012      boolean supportsSelectForUpdate() throws SQLException;
1013    
1014      /**
1015       * This method tests whether or not stored procedures are supported on
1016       * this database.
1017       *
1018       * @return <code>true</code> if stored procedures are supported,
1019       *         <code>false</code> otherwise.
1020       * @exception SQLException If an error occurs.
1021       */
1022      boolean supportsStoredProcedures() throws SQLException;
1023    
1024      /**
1025       * This method tests whether or not subqueries are allowed in comparisons.
1026       * A fully JDBC compliant driver will always return <code>true</code>.
1027       *
1028       * @return <code>true</code> if subqueries are allowed in comparisons,
1029       *         <code>false</code> otherwise.
1030       * @exception SQLException If an error occurs.
1031       */
1032      boolean supportsSubqueriesInComparisons() throws SQLException;
1033    
1034      /**
1035       * This method tests whether or not subqueries are allowed in exists
1036       * expressions.  A fully JDBC compliant driver will always return
1037       * <code>true</code>.
1038       *
1039       * @return <code>true</code> if subqueries are allowed in exists
1040       *         expressions, <code>false</code> otherwise.
1041       * @exception SQLException If an error occurs.
1042       */
1043      boolean supportsSubqueriesInExists() throws SQLException;
1044    
1045      /**
1046       * This method tests whether subqueries are allowed in IN statements.
1047       * A fully JDBC compliant driver will always return <code>true</code>.
1048       *
1049       * @return <code>true</code> if the driver supports subqueries in IN
1050       *         statements, <code>false</code> otherwise.
1051       * @exception SQLException If an error occurs.
1052       */
1053      boolean supportsSubqueriesInIns() throws SQLException;
1054    
1055      /**
1056       * This method tests whether or not subqueries are allowed in quantified
1057       * expressions.  A fully JDBC compliant driver will always return
1058       * <code>true</code>.
1059       *
1060       * @return <code>true</code> if subqueries are allowed in quantified
1061       *         expressions, <code>false</code> otherwise.
1062       * @exception SQLException If an error occurs.
1063       */
1064      boolean supportsSubqueriesInQuantifieds() throws SQLException;
1065    
1066      /**
1067       * This method test whether or not correlated subqueries are allowed. A
1068       * fully JDBC compliant driver will always return <code>true</code>.
1069       *
1070       * @return <code>true</code> if correlated subqueries are allowed,
1071       *         <code>false</code> otherwise.
1072       * @exception SQLException If an error occurs.
1073       */
1074      boolean supportsCorrelatedSubqueries() throws SQLException;
1075    
1076      /**
1077       * This method tests whether or not the UNION statement is supported.
1078       *
1079       * @return <code>true</code> if UNION is supported, <code>false</code>
1080       *         otherwise.
1081       * @exception SQLException If an error occurs.
1082       */
1083      boolean supportsUnion() throws SQLException;
1084    
1085      /**
1086       * This method tests whether or not the UNION ALL statement is supported.
1087       *
1088       * @return <code>true</code> if UNION ALL is supported, <code>false</code>
1089       *         otherwise.
1090       * @exception SQLException If an error occurs.
1091       */
1092      boolean supportsUnionAll() throws SQLException;
1093    
1094      /**
1095       * This method tests whether or not the database supports cursors
1096       * remaining open across commits.
1097       *
1098       * @return <code>true</code> if cursors can remain open across commits,
1099       *         <code>false</code> otherwise.
1100       * @exception SQLException If an error occurs.
1101       */
1102      boolean supportsOpenCursorsAcrossCommit() throws SQLException;
1103    
1104      /**
1105       * This method tests whether or not the database supports cursors
1106       * remaining open across rollbacks.
1107       *
1108       * @return <code>true</code> if cursors can remain open across rollbacks,
1109       *         <code>false</code> otherwise.
1110       * @exception SQLException If an error occurs.
1111       */
1112      boolean supportsOpenCursorsAcrossRollback() throws SQLException;
1113    
1114      /**
1115       * This method tests whether or not the database supports statements
1116       * remaining open across commits.
1117       *
1118       * @return <code>true</code> if statements can remain open across commits,
1119       *         <code>false</code> otherwise.
1120       * @exception SQLException If an error occurs.
1121       */
1122      boolean supportsOpenStatementsAcrossCommit() throws SQLException;
1123    
1124      /**
1125       * This method tests whether or not the database supports statements
1126       * remaining open across rollbacks.
1127       *
1128       * @return <code>true</code> if statements can remain open across rollbacks,
1129       *         <code>false</code> otherwise.
1130       * @exception SQLException If an error occurs.
1131       */
1132      boolean supportsOpenStatementsAcrossRollback() throws SQLException;
1133    
1134      /**
1135       * This method returns the number of hex characters allowed in an inline
1136       * binary literal.
1137       *
1138       * @return The number of hex characters allowed in a binary literal, 0 meaning
1139       *         either an unknown or unlimited number.
1140       * @exception SQLException If an error occurs.
1141       */
1142      int getMaxBinaryLiteralLength() throws SQLException;
1143    
1144      /**
1145       * This method returns the maximum length of a character literal.
1146       *
1147       * @return The maximum length of a character literal.
1148       * @exception SQLException If an error occurs.
1149       */
1150      int getMaxCharLiteralLength() throws SQLException;
1151    
1152      /**
1153       * This method returns the maximum length of a column name.
1154       *
1155       * @return The maximum length of a column name.
1156       * @exception SQLException If an error occurs.
1157       */
1158      int getMaxColumnNameLength() throws SQLException;
1159    
1160      /**
1161       * This method returns the maximum number of columns in a GROUP BY statement.
1162       *
1163       * @return The maximum number of columns in a GROUP BY statement.
1164       * @exception SQLException If an error occurs.
1165       */
1166      int getMaxColumnsInGroupBy() throws SQLException;
1167    
1168      /**
1169       * This method returns the maximum number of columns in an index.
1170       *
1171       * @return The maximum number of columns in an index.
1172       * @exception SQLException If an error occurs.
1173       */
1174      int getMaxColumnsInIndex() throws SQLException;
1175    
1176      /**
1177       * This method returns the maximum number of columns in an ORDER BY statement.
1178       *
1179       * @return The maximum number of columns in an ORDER BY statement.
1180       * @exception SQLException If an error occurs.
1181       */
1182      int getMaxColumnsInOrderBy() throws SQLException;
1183    
1184      /**
1185       * This method returns the maximum number of columns in a SELECT statement.
1186       *
1187       * @return The maximum number of columns in a SELECT statement.
1188       * @exception SQLException If an error occurs.
1189       */
1190      int getMaxColumnsInSelect() throws SQLException;
1191    
1192      /**
1193       * This method returns the maximum number of columns in a table.
1194       *
1195       * @return The maximum number of columns in a table.
1196       * @exception SQLException If an error occurs.
1197       */
1198      int getMaxColumnsInTable() throws SQLException;
1199    
1200      /**
1201       * This method returns the maximum number of connections this client
1202       * can have to the database.
1203       *
1204       * @return The maximum number of database connections.
1205       * @SQLException If an error occurs.
1206       */
1207      int getMaxConnections() throws SQLException;
1208    
1209      /**
1210       * This method returns the maximum length of a cursor name.
1211       *
1212       * @return The maximum length of a cursor name.
1213       * @exception SQLException If an error occurs.
1214       */
1215      int getMaxCursorNameLength() throws SQLException;
1216    
1217      /**
1218       * This method returns the maximum length of an index.
1219       *
1220       * @return The maximum length of an index.
1221       * @exception SQLException If an error occurs.
1222       */
1223      int getMaxIndexLength() throws SQLException;
1224    
1225      /**
1226       * This method returns the maximum length of a schema name.
1227       *
1228       * @return The maximum length of a schema name.
1229       * @exception SQLException If an error occurs.
1230       */
1231      int getMaxSchemaNameLength() throws SQLException;
1232    
1233      /**
1234       * This method returns the maximum length of a procedure name.
1235       *
1236       * @return The maximum length of a procedure name.
1237       * @exception SQLException If an error occurs.
1238       */
1239      int getMaxProcedureNameLength() throws SQLException;
1240    
1241      /**
1242       * This method returns the maximum length of a catalog name.
1243       *
1244       * @return The maximum length of a catalog name.
1245       * @exception SQLException If an error occurs.
1246       */
1247      int getMaxCatalogNameLength() throws SQLException;
1248    
1249      /**
1250       * This method returns the maximum size of a row in bytes.
1251       *
1252       * @return The maximum size of a row.
1253       * @exception SQLException If an error occurs.
1254       */
1255      int getMaxRowSize() throws SQLException;
1256    
1257      /**
1258       * This method tests whether or not the maximum row size includes BLOB's
1259       *
1260       * @return <code>true</code> if the maximum row size includes BLOB's,
1261       *         <code>false</code> otherwise.
1262       * @exception SQLException If an error occurs.
1263       */
1264      boolean doesMaxRowSizeIncludeBlobs() throws SQLException;
1265    
1266      /**
1267       * This method includes the maximum length of a SQL statement.
1268       *
1269       * @return The maximum length of a SQL statement.
1270       * @exception SQLException If an error occurs.
1271       */
1272      int getMaxStatementLength() throws SQLException;
1273    
1274      /**
1275       * This method returns the maximum number of statements that can be
1276       * active at any time.
1277       *
1278       * @return The maximum number of statements that can be active at any time.
1279       * @exception SQLException If an error occurs.
1280       */
1281      int getMaxStatements() throws SQLException;
1282    
1283      /**
1284       * This method returns the maximum length of a table name.
1285       *
1286       * @return The maximum length of a table name.
1287       * @exception SQLException If an error occurs.
1288       */
1289      int getMaxTableNameLength() throws SQLException;
1290    
1291      /**
1292       * This method returns the maximum number of tables that may be referenced
1293       * in a SELECT statement.
1294       *
1295       * @return The maximum number of tables allowed in a SELECT statement.
1296       * @exception SQLException If an error occurs.
1297       */
1298      int getMaxTablesInSelect() throws SQLException;
1299    
1300      /**
1301       * This method returns the maximum length of a user name.
1302       *
1303       * @return The maximum length of a user name.
1304       * @exception SQLException If an error occurs.
1305       */
1306      int getMaxUserNameLength() throws SQLException;
1307    
1308      /**
1309       * This method returns the default transaction isolation level of the
1310       * database.
1311       *
1312       * @return The default transaction isolation level of the database.
1313       * @exception SQLException If an error occurs.
1314       * @see Connection
1315       */
1316      int getDefaultTransactionIsolation() throws SQLException;
1317    
1318      /**
1319       * This method tests whether or not the database supports transactions.
1320       *
1321       * @return <code>true</code> if the database supports transactions,
1322       *         <code>false</code> otherwise.
1323       * @exception SQLException If an error occurs.
1324       */
1325      boolean supportsTransactions() throws SQLException;
1326    
1327      /**
1328       * This method tests whether or not the database supports the specified
1329       * transaction isolation level.
1330       *
1331       * @param level The transaction isolation level.
1332       *
1333       * @return <code>true</code> if the specified transaction isolation level
1334       *         is supported, <code>false</code> otherwise.
1335       * @exception SQLException If an error occurs.
1336       */
1337      boolean supportsTransactionIsolationLevel(int level) throws
1338          SQLException;
1339    
1340      /**
1341       * This method tests whether or not DDL and DML statements allowed within
1342       * the same transaction.
1343       *
1344       * @return <code>true</code> if DDL and DML statements are allowed in the
1345       *         same transaction, <code>false</code> otherwise.
1346       * @exception SQLException If an error occurs.
1347       */
1348      boolean supportsDataDefinitionAndDataManipulationTransactions()
1349          throws SQLException;
1350    
1351      /**
1352       * This method tests whether or not only DML statement are allowed
1353       * inside a transaction.
1354       *
1355       * @return <code>true</code> if only DML statements are allowed in
1356       *         transactions, <code>false</code> otherwise.
1357       * @exception SQLException If an error occurs.
1358       */
1359      boolean supportsDataManipulationTransactionsOnly() throws
1360          SQLException;
1361    
1362      /**
1363       * This method tests whether or not a DDL statement will cause the
1364       * current transaction to be automatically committed.
1365       *
1366       * @return <code>true</code> if DDL causes an immediate transaction commit,
1367       *         <code>false</code> otherwise.
1368       * @exception SQLException If an error occurs.
1369       */
1370      boolean dataDefinitionCausesTransactionCommit() throws SQLException;
1371    
1372      /**
1373       * This method tests whether or not DDL statements are ignored in
1374       * transactions.
1375       *
1376       * @return <code>true</code> if DDL statements are ignored in transactions,
1377       *         <code>false</code> otherwise.
1378       * @exception SQLException If an error occurs.
1379       */
1380      boolean dataDefinitionIgnoredInTransactions() throws SQLException;
1381    
1382      /**
1383       * This method returns a list of all the stored procedures matching the
1384       * specified pattern in the given schema and catalog.  This is returned
1385       * a <code>ResultSet</code> with the following columns:
1386       * <p>
1387       * <ol>
1388       * <li>PROCEDURE_CAT - The catalog the procedure is in, which may be
1389       * <code>null</code>.</li>
1390       * <li>PROCEDURE_SCHEM - The schema the procedures is in, which may be
1391       * <code>null</code>.</li>
1392       * <li>PROCEDURE_NAME - The name of the procedure.</li>
1393       * <li>Unused</li>
1394       * <li>Unused</li>
1395       * <li>Unused</li>
1396       * <li>REMARKS - A description of the procedure</li>
1397       * <li>PROCEDURE_TYPE - Indicates the return type of the procedure, which
1398       * is one of the contstants defined in this class
1399       * (<code>procedureResultUnknown</code>, <code>procedureNoResult</code>, or
1400       * <code>procedureReturnsResult</code>).</li>
1401       * </ol>
1402       *
1403       * @param catalog The name of the catalog to return stored procedured from,
1404       *        or "" to return procedures from all catalogs.
1405       * @param schemaPattern A schema pattern for the schemas to return stored
1406       *        procedures from, or "" to return procedures from all schemas.
1407       * @param procedurePattern The pattern of procedure names to return.
1408       * @returns A <code>ResultSet</code> with all the requested procedures.
1409       * @exception SQLException If an error occurs.
1410       */
1411      ResultSet getProcedures(String catalog, String schemaPattern, String
1412          procedurePattern) throws SQLException;
1413    
1414      /**
1415       * This method returns a list of the parameter and result columns for
1416       * the requested stored procedures.  This is returned in the form of a
1417       * <code>ResultSet</code> with the following columns:
1418       * <p>
1419       * <ol>
1420       * <li>PROCEDURE_CAT - The catalog the procedure is in, which may be
1421       * <code>null</code>.</li>
1422       * <li>PROCEDURE_SCHEM - The schema the procedures is in, which may be
1423       * <code>null</code>.</li>
1424       * <li>PROCEDURE_NAME - The name of the procedure.</li>
1425       * <li>COLUMN_NAME - The name of the column</li>
1426       * <li>COLUMN_TYPE - The type of the column, which will be one of the
1427       * contants defined in this class (<code>procedureColumnUnknown</code>,
1428       * <code>procedureColumnIn</code>, <code>procedureColumnInOut</code>,
1429       * <code>procedureColumnOut</code>, <code>procedureColumnReturn</code>,
1430       * or <code>procedureColumnResult</code>).</li>
1431       * <li>DATA_TYPE - The SQL type of the column. This is one of the constants
1432       * defined in <code>Types</code>.</li>
1433       * <li>TYPE_NAME - The string name of the data type for this column.</li>
1434       * <li>PRECISION - The precision of the column.</li>
1435       * <li>LENGTH - The length of the column in bytes</li>
1436       * <li>SCALE - The scale of the column.</li>
1437       * <li>RADIX - The radix of the column.</li>
1438       * <li>NULLABLE - Whether or not the column is NULLABLE.  This is one of
1439       * the constants defined in this class (<code>procedureNoNulls</code>,
1440       * <code>procedureNullable</code>, or <code>procedureNullableUnknown</code>)</li>
1441       * <li>REMARKS - A description of the column.</li>
1442       * </ol>
1443       *
1444       * @param catalog The name of the catalog to return stored procedured from,
1445       *        or "" to return procedures from all catalogs.
1446       * @param schemaPattern A schema pattern for the schemas to return stored
1447       *        procedures from, or "" to return procedures from all schemas.
1448       * @param procedurePattern The pattern of procedures names to return.
1449       * @param columnPattern The pattern of column names to return.
1450       * @returns A <code>ResultSet</code> with all the requested procedures.
1451       * @exception SQLException If an error occurs.
1452       */
1453      ResultSet getProcedureColumns(String catalog, String schemaPattern,
1454          String procedurePattern, String columnPattern) throws
1455          SQLException;
1456    
1457      /**
1458       * This method returns a list of the requested table as a
1459       * <code>ResultSet</code> with the following columns:
1460       *
1461       * <ol>
1462       * <li>TABLE_CAT - The catalog the table is in, which may be <code>null</code>.</li>
1463       * <li>TABLE_SCHEM - The schema the table is in, which may be <code>null</code>.</li>
1464       * <li>TABLE_NAME - The name of the table.</li>
1465       * <li>TABLE_TYPE - A string describing the table type.  This will be one
1466       * of the values returned by the <code>getTableTypes()</code> method.</li>
1467       * <li>REMARKS - Comments about the table.</li>
1468       * </ol>
1469       *
1470       * @param catalog The name of the catalog to return tables from,
1471       *        or "" to return tables from all catalogs.
1472       * @param schemaPattern A schema pattern for the schemas to return tables
1473       *        from, or "" to return tables from all schemas.
1474       * @param tablePattern The pattern of table names to return.
1475       * @param types The list of table types to include; null returns all types.
1476       * @returns A <code>ResultSet</code> with all the requested tables.
1477       * @exception SQLException If an error occurs.
1478       */
1479      ResultSet getTables(String catalog, String schemaPattern, String
1480          tablePattern, String[] types) throws SQLException;
1481    
1482      /**
1483       * This method returns the list of database schemas as a
1484       * <code>ResultSet</code>, with one column - TABLE_SCHEM - that is the
1485       * name of the schema.
1486       *
1487       * @return A <code>ResultSet</code> with all the requested schemas.
1488       * @exception SQLException If an error occurs.
1489       */
1490      ResultSet getSchemas() throws SQLException;
1491    
1492      /**
1493       * This method returns the list of database catalogs as a
1494       * <code>ResultSet</code> with one column - TABLE_CAT - that is the
1495       * name of the catalog.
1496       *
1497       * @return A <code>ResultSet</code> with all the requested catalogs.
1498       * @exception SQLException If an error occurs.
1499       */
1500      ResultSet getCatalogs() throws SQLException;
1501    
1502      /**
1503       * This method returns the list of database table types as a
1504       * <code>ResultSet</code> with one column - TABLE_TYPE - that is the
1505       * name of the table type.
1506       *
1507       * @return A <code>ResultSet</code> with all the requested table types.
1508       * @exception SQLException If an error occurs.
1509       */
1510      ResultSet getTableTypes() throws SQLException;
1511    
1512      /**
1513       * This method returns a list of the tables columns for
1514       * the requested tables.  This is returned in the form of a
1515       * <code>ResultSet</code> with the following columns:
1516       * <p>
1517       * <ol>
1518       * <li>TABLE_CAT - The catalog the table is in, which may be
1519       * <code>null</code>.</li>
1520       * <li>TABLE_SCHEM - The schema the tables is in, which may be
1521       * <code>null</code>.</li>
1522       * <li>TABLE_NAME - The name of the table.</li>
1523       * <li>COLUMN_NAME - The name of the column</li>
1524       * <li>DATA_TYPE - The SQL type of the column. This is one of the constants
1525       * defined in <code>Types</code>.</li>
1526       * <li>TYPE_NAME - The string name of the data type for this column.</li>
1527       * <li>COLUMN_SIZE - The size of the column.</li>
1528       * <li>Unused</li>
1529       * <li>NUM_PREC_RADIX - The radix of the column.</li>
1530       * <li>NULLABLE - Whether or not the column is NULLABLE.  This is one of
1531       * the constants defined in this class (<code>tableNoNulls</code>,
1532       * <code>tableNullable</code>, or <code>tableNullableUnknown</code>)</li>
1533       * <li>REMARKS - A description of the column.</li>
1534       * <li>COLUMN_DEF - The default value for the column, may be <code>null</code>.</li>
1535       * <li>SQL_DATA_TYPE - Unused</li>
1536       * <li>SQL_DATETIME_SUB - Unused</li>
1537       * <li>CHAR_OCTET_LENGTH - For character columns, the maximum number of bytes
1538       * in the column.</li>
1539       * <li>ORDINAL_POSITION - The index of the column in the table.</li>
1540       * <li>IS_NULLABLE - "NO" means no, "YES" means maybe, and an empty string
1541       * means unknown.</li>
1542       * </ol>
1543       *
1544       * @param catalog The name of the catalog to return table from,
1545       * or "" to return tables from all catalogs.
1546       * @param schemaPattern A schema pattern for the schemas to return
1547       * tables from, or "" to return tables from all schemas.
1548       * @param tablePattern The pattern of table names to return.
1549       * @param columnPattern The pattern of column names to return.
1550       * @returns A <code>ResultSet</code> with all the requested tables.
1551       * @exception SQLException If an error occurs.
1552       */
1553      ResultSet getColumns(String catalog, String schemaPattern, String
1554          tablePattern, String columnPattern) throws SQLException;
1555    
1556      /**
1557       * This method returns the access rights that have been granted to the
1558       * requested columns.  This information is returned as a <code>ResultSet</code>
1559       * with the following columns:
1560       *
1561       * <ol>
1562       * <li>TABLE_CAT - The catalog the table is in, which may be
1563       * <code>null</code>.</li>
1564       * <li>TABLE_SCHEM - The schema the tables is in, which may be
1565       * <code>null</code>.</li>
1566       * <li>TABLE_NAME - The name of the table.</li>
1567       * <li>COLUMN_NAME - The name of the column.</li>
1568       * <li>GRANTOR - The entity that granted the access.</li>
1569       * <li>GRANTEE - The entity granted the access.</li>
1570       * <li>PRIVILEGE - The name of the privilege granted.</li>
1571       * <li>IS_GRANTABLE - "YES" if the grantee can grant the privilege to
1572       * others, "NO" if not, and <code>null</code> if unknown.</li>
1573       * </ol>
1574       *
1575       * @param catalog The catalog to retrieve information from, or the empty string
1576       *        to return entities not associated with a catalog, or <code>null</code>
1577       *        to return information from all catalogs.
1578       * @param schema The schema to retrieve information from, or the empty string
1579       *        to return entities not associated with a schema.
1580       * @param tableName The table name to return information for.
1581       * @param columnPattern A pattern of column names to return information for.
1582       * @return A <code>ResultSet</code> with all the requested privileges.
1583       * @exception SQLException If an error occurs.
1584       */
1585      ResultSet getColumnPrivileges(String catalog, String schema, String
1586          tableName, String columnPattern) throws SQLException;
1587    
1588      /**
1589       * This method returns the access rights that have been granted to the
1590       * requested tables.  This information is returned as a <code>ResultSet</code>
1591       * with the following columns:
1592       *
1593       * <ol>
1594       * <li>TABLE_CAT - The catalog the table is in, which may be
1595       * <code>null</code>.</li>
1596       * <li>TABLE_SCHEM - The schema the tables is in, which may be
1597       * <code>null</code>.</li>
1598       * <li>TABLE_NAME - The name of the table.</li>
1599       * <li>GRANTOR - The entity that granted the access.</li>
1600       * <li>GRANTEE - The entity granted the access.</li>
1601       * <li>PRIVILEGE - The name of the privilege granted.</li>
1602       * <li>IS_GRANTABLE - "YES" if the grantee can grant the privilege to
1603       * others, "NO" if not, and <code>null</code> if unknown.</li>
1604       * </ol>
1605       *
1606       * @param catalog The catalog to retrieve information from, or the empty string
1607       *        to return entities not associated with a catalog, or <code>null</code>
1608       *        to return information from all catalogs.
1609       * @param schemaPattern The schema to retrieve information from, or the empty string
1610       *        to return entities not associated with a schema.
1611       * @param tablePattern The table name pattern of tables to return
1612       *        information for.
1613       * @return A <code>ResultSet</code> with all the requested privileges.
1614       * @exception SQLException If an error occurs.
1615       */
1616      ResultSet getTablePrivileges(String catalog, String schemaPattern,
1617          String tablePattern) throws SQLException;
1618    
1619      /**
1620       * This method returns the best set of columns for uniquely identifying
1621       * a row.  It returns this information as a <code>ResultSet</code> with
1622       * the following columns:
1623       *
1624       * <ol>
1625       * <li>SCOPE - The scope of the results returned.  This is one of the
1626       * constants defined in this class (<code>bestRowTemporary</code>,
1627       * <code>bestRowTransaction</code>, or <code>bestRowSession</code>).</li>
1628       * <li>COLUMN_NAME - The name of the column.</li>
1629       * <li>DATA_TYPE - The SQL type of the column. This is one of the constants
1630       * defined in <code>Types</code>.</li>
1631       * <li>TYPE_NAME - The string name of the data type for this column.</li>
1632       * <li>COLUMN_SIZE - The precision of the columns</li>
1633       * <li>BUFFER_LENGTH - Unused</li>
1634       * <li>DECIMAL_DIGITS - The scale of the column.</li>
1635       * <li>PSEUDO_COLUMN - Whether or not the best row identifier is a
1636       * pseudo_column.  This is one of the constants defined in this class
1637       * (<code>bestRowUnknown</code>, <code>bestRowNotPseudo</code>, or
1638       * <code>bestRowPseudo</code>).</li>
1639       * </ol>
1640       *
1641       * @param catalog The catalog to retrieve information from, or the empty string
1642       * to return entities not associated with a catalog, or <code>null</code>
1643       * to return information from all catalogs.
1644       * @param schema The schema to retrieve information from, or the empty string
1645       * to return entities not associated with a schema.
1646       * @param tableName The table name to return information for.
1647       * @param scope One of the best row id scope constants from this class.
1648       * @param nullable <code>true</code> to include columns that are nullable,
1649       * <code>false</code> otherwise.
1650       * @return A <code>ResultSet</code> with the best row identifier.
1651       * @exception SQLException If an error occurs.
1652       */
1653      ResultSet getBestRowIdentifier(String catalog, String schema,
1654        String tableName, int scope, boolean nullable) throws SQLException;
1655    
1656      /**
1657       * This method returns the set of columns that are automatically updated
1658       * when the row is update. It returns this information as a
1659       * <code>ResultSet</code> with the following columns:
1660       *
1661       * <ol>
1662       * <li>SCOPE - Unused</li>
1663       * <li>COLUMN_NAME - The name of the column.</li>
1664       * <li>DATA_TYPE - The SQL type of the column. This is one of the constants
1665       * defined in <code>Types</code>.</li>
1666       * <li>TYPE_NAME - The string name of the data type for this column.</li>
1667       * <li>COLUMN_SIZE - The precision of the columns</li>
1668       * <li>BUFFER_LENGTH - Unused</li>
1669       * <li>DECIMAL_DIGITS - The scale of the column.</li>
1670       * <li>PSEUDO_COLUMN - Whether or not the best row identifier is a
1671       * pseudo_column.  This is one of the constants defined in this class
1672       * (<code>versionRowUnknown</code>, <code>versionRowNotPseudo</code>, or
1673       * <code>versionRowPseudo</code>).</li>
1674       * </ol>
1675       *
1676       * @param catalog The catalog to retrieve information from, or the empty string
1677       *        to return entities not associated with a catalog, or <code>null</code>
1678       *        to return information from all catalogs.
1679       * @param schema The schema to retrieve information from, or the empty string
1680       *        to return entities not associated with a schema.
1681       * @param tableName The table name to return information for
1682       * @return A <code>ResultSet</code> with the version columns.
1683       * @exception SQLException If an error occurs.
1684       */
1685      ResultSet getVersionColumns(String catalog, String schema,
1686        String tableName) throws SQLException;
1687    
1688      /**
1689       * This method returns a list of a table's primary key columns.  These
1690       * are returned as a <code>ResultSet</code> with the following columns.
1691       *
1692       * <ol>
1693       * <li>TABLE_CAT - The catalog of the table, which may be <code>null</code>.</li>
1694       * <li>TABLE_SCHEM - The schema of the table, which may be <code>null</code>.</li>
1695       * <li>TABLE_NAME - The name of the table.</li>
1696       * <li>COLUMN_NAME - The name of the column.</li>
1697       * <li>KEY_SEQ - The sequence number of the column within the primary key.</li>
1698       * <li>PK_NAME - The name of the primary key, which may be <code>null</code>.</li>
1699       * </ol>
1700       *
1701       * @param catalog The catalog to retrieve information from, or the empty string
1702       *        to return entities not associated with a catalog, or <code>null</code>
1703       *        to return information from all catalogs.
1704       * @param schema The schema to retrieve information from, or the empty string
1705       *        to return entities not associated with a schema.
1706       * @param tableName The table name to return information for.
1707       * @return A <code>ResultSet</code> with the primary key columns.
1708       * @exception SQLException If an error occurs.
1709       */
1710      ResultSet getPrimaryKeys(String catalog, String schema, String tableName)
1711          throws SQLException;
1712    
1713      /**
1714       * This method returns a list of the table's foreign keys.  These are
1715       * returned as a <code>ResultSet</code> with the following columns:
1716       *
1717       * <ol>
1718       * <li>PKTABLE_CAT - The catalog of the table the key was imported from.</li>
1719       * <li>PKTABLE_SCHEM - The schema of the table the key was imported from.</li>
1720       * <li>PKTABLE_NAME - The name of the table the key was imported from.</li>
1721       * <li>PKCOLUMN_NAME - The name of the column that was imported.</li>
1722       * <li>FKTABLE_CAT - The foreign key catalog name.</li>
1723       * <li>FKTABLE_SCHEM - The foreign key schema name.</li>
1724       * <li>FKTABLE_NAME - The foreign key table name.</li>
1725       * <li>FKCOLUMN_NAME - The foreign key column name.</li>
1726       * <li>KEY_SEQ - The sequence number of the column within the foreign key.</li>
1727       * <li>UPDATE_RULE - How the foreign key behaves when the primary key is
1728       * updated.  This is one of the constants defined in this class
1729       * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1730       * <code>importedKeySetNull</code>, <code>importedKeySetDefault</code>, or
1731       * <code>importedKeyRestrict</code>).</li>
1732       * <li>DELETE_RULE - How the foreign key behaves when the primary key is
1733       * deleted.  This is one of the constants defined in this class
1734       * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1735       * <code>importedKeySetNull</code>, or <code>importedKeySetDefault</code>)</li>
1736       * <li>FK_NAME - The name of the foreign key.</li>
1737       * <li>PK_NAME - The name of the primary key.</li>
1738       * <li>DEFERRABILITY - The deferrability value.  This is one of the
1739       * constants defined in this table (<code>importedKeyInitiallyDeferred</code>,
1740       * <code>importedKeyInitiallyImmediate</code>, or
1741       * <code>importedKeyNotDeferrable</code>).</li>
1742       * </ol>
1743       *
1744       * @param catalog The catalog to retrieve information from, or the empty string
1745       *        to return entities not associated with a catalog, or <code>null</code>
1746       *        to return information from all catalogs.
1747       * @param schema The schema to retrieve information from, or the empty string
1748       *        to return entities not associated with a schema.
1749       * @param tableName The table name to return information for.
1750       * @return A <code>ResultSet</code> with the foreign key columns.
1751       * @exception SQLException If an error occurs.
1752       */
1753      ResultSet getImportedKeys(String catalog, String schema,
1754        String tableName) throws SQLException;
1755    
1756      /**
1757       * This method returns a list of the table's which use this table's
1758       * primary key as a foreign key.  The information is
1759       * returned as a <code>ResultSet</code> with the following columns:
1760       *
1761       * <ol>
1762       * <li>PKTABLE_CAT - The catalog of the table the key was imported from.</li>
1763       * <li>PKTABLE_SCHEM - The schema of the table the key was imported from.</li>
1764       * <li>PKTABLE_NAME - The name of the table the key was imported from.</li>
1765       * <li>PKCOLUMN_NAME - The name of the column that was imported.</li>
1766       * <li>FKTABLE_CAT - The foreign key catalog name.</li>
1767       * <li>FKTABLE_SCHEM - The foreign key schema name.</li>
1768       * <li>FKTABLE_NAME - The foreign key table name.</li>
1769       * <li>FKCOLUMN_NAME - The foreign key column name.</li>
1770       * <li>KEY_SEQ - The sequence number of the column within the foreign key.</li>
1771       * <li>UPDATE_RULE - How the foreign key behaves when the primary key is
1772       * updated.  This is one of the constants defined in this class
1773       * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1774       * <code>importedKeySetNull</code>, <code>importedKeySetDefault</code>, or
1775       * <code>importedKeyRestrict</code>).</li>
1776       * <li>DELETE_RULE - How the foreign key behaves when the primary key is
1777       * deleted.  This is one of the constants defined in this class
1778       * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1779       * <code>importedKeySetNull</code>, or <code>importedKeySetDefault</code>)</li>
1780       * <li>FK_NAME - The name of the foreign key.</li>
1781       * <li>PK_NAME - The name of the primary key.</li>
1782       * <li>DEFERRABILITY - The deferrability value.  This is one of the
1783       * constants defined in this table (<code>importedKeyInitiallyDeferred</code>,
1784       * <code>importedKeyInitiallyImmediate</code>, or
1785       * <code>importedKeyNotDeferrable</code>).</li>
1786       * </ol>
1787       *
1788       * @param catalog The catalog to retrieve information from, or the empty string
1789       *        to return entities not associated with a catalog, or <code>null</code>
1790       *        to return information from all catalogs.
1791       * @param schema The schema to retrieve information from, or the empty string
1792       *        to return entities not associated with a schema.
1793       * @param tableName The table name to return information for.
1794       * @return A <code>ResultSet</code> with the requested information
1795       * @exception SQLException If an error occurs.
1796       */
1797      ResultSet getExportedKeys(String catalog, String schema,
1798        String tableName) throws SQLException;
1799    
1800      /**
1801       * This method returns a description of how one table imports another
1802       * table's primary key as a foreign key.  The information is
1803       * returned as a <code>ResultSet</code> with the following columns:
1804       *
1805       * <ol>
1806       * <li>PKTABLE_CAT - The catalog of the table the key was imported from.</li>
1807       * <li>PKTABLE_SCHEM - The schema of the table the key was imported from.</li>
1808       * <li>PKTABLE_NAME - The name of the table the key was imported from.</li>
1809       * <li>PKCOLUMN_NAME - The name of the column that was imported.</li>
1810       * <li>FKTABLE_CAT - The foreign key catalog name.</li>
1811       * <li>FKTABLE_SCHEM - The foreign key schema name.</li>
1812       * <li>FKTABLE_NAME - The foreign key table name.</li>
1813       * <li>FKCOLUMN_NAME - The foreign key column name.</li>
1814       * <li>KEY_SEQ - The sequence number of the column within the foreign key.</li>
1815       * <li>UPDATE_RULE - How the foreign key behaves when the primary key is
1816       * updated.  This is one of the constants defined in this class
1817       * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1818       * <code>importedKeySetNull</code>, <code>importedKeySetDefault</code>, or
1819       * <code>importedKeyRestrict</code>).</li>
1820       * <li>DELETE_RULE - How the foreign key behaves when the primary key is
1821       * deleted.  This is one of the constants defined in this class
1822       * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1823       * <code>importedKeySetNull</code>, or <code>importedKeySetDefault</code>)</li>
1824       * <li>FK_NAME - The name of the foreign key.</li>
1825       * <li>PK_NAME - The name of the primary key.</li>
1826       * <li>DEFERRABILITY - The deferrability value.  This is one of the
1827       * constants defined in this table (<code>importedKeyInitiallyDeferred</code>,
1828       * <code>importedKeyInitiallyImmediate</code>, or
1829       * <code>importedKeyNotDeferrable</code>).</li>
1830       * </ol>
1831       *
1832       * @param primaryCatalog The catalog to retrieve information from, or the
1833       *        empty string to return entities not associated with a catalog, or
1834       *        <code>null</code> to return information from all catalogs, on the
1835       *         exporting side.
1836       * @param primarySchema The schema to retrieve information from, or the empty
1837       *        string to return entities not associated with a schema, on the
1838       *        exporting side.
1839       * @param primaryTableName The table name to return information for, on the
1840       *        exporting side.
1841       * @param foreignCatalog The catalog to retrieve information from, or the
1842       *        empty string to return entities not associated with a catalog,
1843       *        or <code>null</code> to return information from all catalogs, on
1844       *        the importing side.
1845       * @param foreignSchema The schema to retrieve information from, or the
1846       *        empty string to return entities not associated with a schema on
1847       *        the importing side.
1848       * @param foreignTableName The table name to return information for on the
1849       *        importing side.
1850       * @return A <code>ResultSet</code> with the requested information
1851       * @exception SQLException If an error occurs.
1852       */
1853      ResultSet getCrossReference(String primaryCatalog, String
1854        primarySchema, String primaryTableName, String foreignCatalog, String
1855        foreignSchema, String foreignTableName) throws SQLException;
1856    
1857      /**
1858       * This method returns a list of the SQL types supported by this
1859       * database.  The information is returned as a <code>ResultSet</code>
1860       * with the following columns:
1861       *
1862       * <ol>
1863       * <li>TYPE_NAME - The name of the data type.</li>
1864       * <li>DATA_TYPE - A data type constant from <code>Types</code> for this
1865       * type.</li>
1866       * <li>PRECISION - The maximum precision of this type.</li>
1867       * <li>LITERAL_PREFIX - Prefix value used to quote a literal, which may be
1868       * <code>null</code>.</li>
1869       * <li>LITERAL_SUFFIX - Suffix value used to quote a literal, which may be
1870       * <code>null</code>.</li>
1871       * <li>CREATE_PARAMS - The parameters used to create the type, which may be
1872       * <code>null</code>.</li>
1873       * <li>NULLABLE - Whether or not this type supports NULL values.  This will
1874       * be one of the constants defined in this interface
1875       * (<code>typeNoNulls</code>, <code>typeNullable</code>, or
1876       * <code>typeNullableUnknown</code>).</li>
1877       * <li>CASE_SENSITIVE - Whether or not the value is case sensitive.</li>
1878       * <li>SEARCHABLE - Whether or not "LIKE" expressions are supported in
1879       * WHERE clauses for this type.  This will be one of the constants defined
1880       * in this interface (<code>typePredNone</code>, <code>typePredChar</code>,
1881       * <code>typePredBasic</code>, or <code>typeSearchable</code>).</li>
1882       * <li>UNSIGNED_ATTRIBUTE - Is the value of this type unsigned.</li>
1883       * <li>FIXED_PREC_SCALE - Whether or not this type can be used for money.</li>
1884       * <li>AUTO_INCREMENT - Whether or not this type supports auto-incrementing.</li>
1885       * <li>LOCAL_TYPE_NAME - A localized name for this data type.</li>
1886       * <li>MINIMUM_SCALE - The minimum scale supported by this type.</li>
1887       * <li>MAXIMUM_SCALE - The maximum scale supported by this type.</li>
1888       * <li>SQL_DATA_TYPE - Unused.</li>
1889       * <li>SQL_DATETIME_SUB - Unused.</li>
1890       * <li>NUM_PREC_RADIX - The radix of this data type.</li>
1891       * </ol>
1892       *
1893       * @return A <code>ResultSet</code> with the list of available data types.
1894       * @exception SQLException If an error occurs.
1895       */
1896      ResultSet getTypeInfo() throws SQLException;
1897    
1898      /**
1899       * This method returns information about a tables indices and statistics.
1900       * It is returned as a <code>ResultSet</code> with the following columns:
1901       *
1902       * <ol>
1903       * <li>TABLE_CAT - The catalog of the table, which may be <code>null</code>.</li>
1904       * <li>TABLE_SCHEM - The schema of the table, which may be <code>null</code>.</li>
1905       * <li>TABLE_NAME - The name of the table.</li>
1906       * <li>NON_UNIQUE - Are index values non-unique?</li>
1907       * <li>INDEX_QUALIFIER The index catalog, which may be <code>null</code></li>
1908       * <li>INDEX_NAME - The name of the index.</li>
1909       * <li>TYPE - The type of index, which will be one of the constants defined
1910       * in this interface (<code>tableIndexStatistic</code>,
1911       * <code>tableIndexClustered</code>, <code>tableIndexHashed</code>, or
1912       * <code>tableIndexOther</code>).</li>
1913       * <li>ORDINAL_POSITION - The sequence number of this column in the index.
1914       * This will be 0 when the index type is <code>tableIndexStatistic</code>.</li>
1915       * <li>COLUMN_NAME - The name of this column in the index.</li>
1916       * <li>ASC_OR_DESC - "A" for an ascending sort sequence, "D" for a
1917       * descending sort sequence or <code>null</code> if a sort sequence is not
1918       * supported.</li>
1919       * <li>CARDINALITY - The number of unique rows in the index, or the number
1920       * of rows in the table if the index type is <code>tableIndexStatistic</code>.</li>
1921       * <li>PAGES - The number of pages used for the index, or the number of pages
1922       * in the table if the index type is <code>tableIndexStatistic</code>.</li>
1923       * <li>FILTER_CONDITION - The filter condition for this index, which may be
1924       * <code>null</code>.</li>
1925       * </ol>
1926       *
1927       * @param catalog The catalog to retrieve information from, or the empty string
1928       *        to return entities not associated with a catalog, or
1929       *        <code>null</code> to return information from all catalogs.
1930       * @param schema The schema to retrieve information from, or the empty string
1931       *        to return entities not associated with a schema.
1932       * @param tableName The table name to return information for.
1933       * @param unique <code>true</code> to return only unique indexes,
1934       *        <code>false</code> otherwise.
1935       * @param approximate <code>true</code> if data values can be approximations,
1936       *        <code>false</code> otherwise.
1937       * @return A <code>ResultSet</code> with the requested index information
1938       * @exception SQLException If an error occurs.
1939       */
1940      ResultSet getIndexInfo(String catalog, String schema, String tableName,
1941        boolean unique, boolean approximate) throws SQLException;
1942    
1943      /**
1944       * This method tests whether or not the datbase supports the specified
1945       * result type.
1946       *
1947       * @param type The desired result type, which is one of the constants
1948       * defined in <code>ResultSet</code>.
1949       *
1950       * @return <code>true</code> if the result set type is supported,
1951       * <code>false</code> otherwise.
1952       *
1953       * @exception SQLException If an error occurs.
1954       *
1955       * @see ResultSet
1956       */
1957      boolean supportsResultSetType(int type) throws SQLException;
1958    
1959      /**
1960       * This method tests whether the specified result set type and result set
1961       * concurrency type are supported by the database.
1962       *
1963       * @param type The desired result type, which is one of the constants
1964       *        defined in <code>ResultSet</code>.
1965       * @param concurrency The desired concurrency type, which is one of the
1966       *                    constants defined in <code>ResultSet</code>.
1967       * @return <code>true</code> if the result set type is supported,
1968       *         <code>false</code> otherwise.
1969       * @exception SQLException If an error occurs.
1970       * @see ResultSet
1971       */
1972      boolean supportsResultSetConcurrency(int type, int concurrency)
1973          throws SQLException;
1974    
1975      /**
1976       * This method tests whether or not the specified result set type sees its
1977       * own updates.
1978       *
1979       * @param type The desired result type, which is one of the constants
1980       *        defined in <code>ResultSet</code>.
1981       * @return <code>true</code> if the result set type sees its own updates,
1982       *         <code>false</code> otherwise.
1983       * @exception SQLException If an error occurs.
1984       * @see ResultSet
1985       */
1986      boolean ownUpdatesAreVisible(int type) throws SQLException;
1987    
1988     /**
1989       * This method tests whether or not the specified result set type sees its
1990       * own deletes.
1991       *
1992       * @param type The desired result type, which is one of the constants
1993       *        defined in <code>ResultSet</code>.
1994       * @return <code>true</code> if the result set type sees its own deletes,
1995       *         <code>false</code> otherwise.
1996       * @exception SQLException If an error occurs.
1997       * @see ResultSet
1998       */
1999      boolean ownDeletesAreVisible(int type) throws SQLException;
2000    
2001      /**
2002       * This method tests whether or not the specified result set type sees its
2003       * own inserts.
2004       *
2005       * @param type The desired result type, which is one of the constants
2006       *        defined in <code>ResultSet</code>.
2007       * @return <code>true</code> if the result set type sees its own inserts,
2008       *         <code>false</code> otherwise.
2009       * @exception SQLException If an error occurs.
2010       * @see ResultSet
2011       */
2012      boolean ownInsertsAreVisible(int type) throws SQLException;
2013    
2014      /**
2015       * This method tests whether or not the specified result set type sees
2016       * updates committed by others.
2017       *
2018       * @param type The desired result type, which is one of the constants
2019       *        defined in <code>ResultSet</code>.
2020       * @return <code>true</code> if the result set type sees other updates,
2021       *         <code>false</code> otherwise.
2022       * @exception SQLException If an error occurs.
2023       * @see ResultSet
2024       */
2025      boolean othersUpdatesAreVisible(int type) throws SQLException;
2026    
2027      /**
2028       * This method tests whether or not the specified result set type sees
2029       * deletes committed by others.
2030       *
2031       * @param type The desired result type, which is one of the constants
2032       *        defined in <code>ResultSet</code>.
2033       * @return <code>true</code> if the result set type sees other deletes,
2034       *         <code>false</code> otherwise.
2035       * @exception SQLException If an error occurs.
2036       * @see ResultSet
2037       */
2038      boolean othersDeletesAreVisible(int type) throws SQLException;
2039    
2040      /**
2041       * This method tests whether or not the specified result set type sees
2042       * inserts committed by others.
2043       *
2044       * @param type The desired result type, which is one of the constants
2045       *        defined in <code>ResultSet</code>.
2046       * @return <code>true</code> if the result set type sees other inserts,
2047       *         <code>false</code> otherwise.
2048       * @exception SQLException If an error occurs.
2049       * @see ResultSet
2050       */
2051      boolean othersInsertsAreVisible(int type) throws SQLException;
2052    
2053      /**
2054       * This method tests whether or not the specified result set type can detect
2055       * a visible update by calling the <code>rowUpdated</code> method.
2056       *
2057       * @param type The desired result type, which is one of the constants
2058       *        defined in <code>ResultSet</code>.
2059       * @return <code>true</code> if the result set type can detect visible updates
2060       *         using <code>rowUpdated</code>, <code>false</code> otherwise.
2061       * @exception SQLException If an error occurs.
2062       * @see ResultSet
2063       */
2064      boolean updatesAreDetected(int type) throws SQLException;
2065    
2066      /**
2067       * This method tests whether or not the specified result set type can detect
2068       * a visible delete by calling the <code>rowUpdated</code> method.
2069       *
2070       * @param type The desired result type, which is one of the constants
2071       *        defined in <code>ResultSet</code>.
2072       * @return <code>true</code> if the result set type can detect visible deletes
2073       *         using <code>rowUpdated</code>, <code>false</code> otherwise.
2074       * @exception SQLException If an error occurs.
2075       * @see ResultSet
2076       */
2077      boolean deletesAreDetected(int type) throws SQLException;
2078    
2079      /**
2080       * This method tests whether or not the specified result set type can detect
2081       * a visible insert by calling the <code>rowUpdated</code> method.
2082       *
2083       * @param type The desired result type, which is one of the constants
2084       *        defined in <code>ResultSet</code>.
2085       * @return <code>true</code> if the result set type can detect visible inserts
2086       *         using <code>rowUpdated</code>, <code>false</code> otherwise.
2087       * @exception SQLException If an error occurs.
2088       * @see ResultSet
2089       */
2090      boolean insertsAreDetected(int type) throws SQLException;
2091    
2092      /**
2093       * This method tests whether or not the database supports batch updates.
2094       *
2095       * @return <code>true</code> if batch updates are supported,
2096       *         <code>false</code> otherwise.
2097       * @exception SQLException If an error occurs.
2098       */
2099      boolean supportsBatchUpdates() throws SQLException;
2100    
2101      /**
2102       * This method returns the list of user defined data types in use.  These
2103       * are returned as a <code>ResultSet</code> with the following columns:
2104       *
2105       * <ol>
2106       * <li>TYPE_CAT - The catalog name, which may be <code>null</code>.</li>
2107       * <li>TYPE_SCEHM - The schema name, which may be <code>null</code>.</li>
2108       * <li>TYPE_NAME - The user defined data type name.</li>
2109       * <li>CLASS_NAME - The Java class name this type maps to.</li>
2110       * <li>DATA_TYPE - A type identifier from <code>Types</code> for this type.
2111       * This will be one of <code>JAVA_OBJECT</code>, <code>STRUCT</code>, or
2112       * <code>DISTINCT</code>.</li>
2113       * <li>REMARKS - Comments about this data type.</li>
2114       * </ol>
2115       *
2116       * @param catalog The catalog to retrieve information from, or the empty string
2117       *        to return entities not associated with a catalog, or <code>null</code>
2118       *        to return information from all catalogs.
2119       * @param schemaPattern The schema to retrieve information from, or the
2120       *        empty string to return entities not associated with a schema.
2121       * @param typePattern The type name pattern to match.
2122       * @param types The type identifier patterns (from <code>Types</code>) to
2123       *        match.
2124       * @return A <code>ResultSet</code> with the requested type information
2125       * @exception SQLException If an error occurs.
2126       */
2127      ResultSet getUDTs(String catalog, String schemaPattern, String
2128          typePattern, int[] types) throws SQLException;
2129    
2130      /**
2131       * This method returns the <code>Connection</code> object that was used
2132       * to generate the metadata in this object.
2133       *
2134       * @return The connection for this object.
2135       * @exception SQLException If an error occurs.
2136       */
2137      Connection getConnection() throws SQLException;
2138    
2139      /**
2140       * This method tests whether the databse supports savepoints.
2141       *
2142       * @return <code>true</code> if the database supports savepoints,
2143       *         <code>false</code> if it does not.
2144       * @exception SQLException If an error occurs.
2145       * @see Savepoint
2146       * @since 1.4
2147       */
2148      boolean supportsSavepoints() throws SQLException;
2149    
2150      /**
2151       * This method tests whether the database supports named parameters.
2152       *
2153       * @return <code>true</code> if the database supports named parameters,
2154       *         <code>false</code> if it does not.
2155       * @exception SQLException If an error occurs.
2156       * @since 1.4
2157       */
2158      boolean supportsNamedParameters() throws SQLException;
2159    
2160      /**
2161       * This method tests whether the database supports returning multiple
2162       * <code>ResultSet</code>S from a <code>CallableStatement</code> at once.
2163       *
2164       * @return <code>true</code> if the database supports returnig multiple
2165       *         results at once, <code>false</code> if it does not.
2166       * @exception SQLException If an error occurs.
2167       * @since 1.4
2168       */
2169      boolean supportsMultipleOpenResults() throws SQLException;
2170    
2171      /**
2172       * @since 1.4
2173       */
2174      boolean supportsGetGeneratedKeys() throws SQLException;
2175    
2176      /**
2177       * @since 1.4
2178       */
2179      ResultSet getSuperTypes(String catalog, String schemaPattern,
2180        String typePattern) throws SQLException;
2181    
2182      /**
2183       * @since 1.4
2184       */
2185      ResultSet getSuperTables(String catalog, String schemaPattern,
2186        String tablePattern) throws SQLException;
2187    
2188      /**
2189       * @since 1.4
2190       */
2191      ResultSet getAttributes(String catalog, String schemaPattern, String
2192        typePattern, String attributePattern) throws SQLException;
2193    
2194      /**
2195       * This method tests if the database supports the specified holdability type.
2196       * Valid values for this parameter are specified in the
2197       * <code>ResultSet</code> class.
2198       *
2199       * @param holdability The holdability type to test.
2200       * @return <code>true</code> if the database supports the holdability type,
2201       *         <code>false</code> if it does not.
2202       * @exception SQLException If an error occurs.
2203       * @see ResultSet
2204       * @since 1.4
2205       */
2206      boolean supportsResultSetHoldability(int holdability)
2207        throws SQLException;
2208    
2209      /**
2210       * This method returns the default holdability type of <code>ResultSet</code>S
2211       * retrieved from this database. The possible values are specified in the
2212       * <code>ResultSet</code> class.
2213       *
2214       * @return The default holdability type.
2215       * @exception SQLException If an error occurs.
2216       * @since 1.4
2217       */
2218      int getResultSetHoldability() throws SQLException;
2219    
2220      /**
2221       * This method returns the major version number of the database.
2222       *
2223       * @return The major version number of the database.
2224       * @exception SQLException If an error occurs.
2225       * @since 1.4
2226       */
2227      int getDatabaseMajorVersion() throws SQLException;
2228    
2229      /**
2230       * This method returns the minor version number of the database.
2231       *
2232       * @return The minor version number of the database.
2233       * @exception SQLException If an error occurs.
2234       * @since 1.4
2235       */
2236      int getDatabaseMinorVersion() throws SQLException;
2237    
2238      /**
2239       * This method returns the major version number of the JDBC driver.
2240       *
2241       * @return The major version number of the JDBC driver.
2242       * @exception  SQLException If an error occurs.
2243       * @since 1.4
2244       */
2245      int getJDBCMajorVersion() throws SQLException;
2246    
2247      /**
2248       * This method returns the minor version number of the JDBC driver.
2249       *
2250       * @return The minor version number of the database.
2251       * @exception SQLException If an error occurs.
2252       * @since 1.4
2253       */
2254      int getJDBCMinorVersion() throws SQLException;
2255    
2256      /**
2257       * @since 1.4
2258       */
2259      int getSQLStateType() throws SQLException;
2260    
2261      /**
2262       * @since 1.4
2263       */
2264      boolean locatorsUpdateCopy() throws SQLException;
2265    
2266      /**
2267       * @since 1.4
2268       */
2269      boolean supportsStatementPooling() throws SQLException;
2270    }