001/* DatabaseMetaData.java -- Information about the database itself.
002   Copyright (C) 1999, 2000, 2001, 2002, 2006 Free Software Foundation, Inc.
003
004This file is part of GNU Classpath.
005
006GNU Classpath is free software; you can redistribute it and/or modify
007it under the terms of the GNU General Public License as published by
008the Free Software Foundation; either version 2, or (at your option)
009any later version.
010 
011GNU Classpath is distributed in the hope that it will be useful, but
012WITHOUT ANY WARRANTY; without even the implied warranty of
013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014General Public License for more details.
015
016You should have received a copy of the GNU General Public License
017along with GNU Classpath; see the file COPYING.  If not, write to the
018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
01902110-1301 USA.
020
021Linking this library statically or dynamically with other modules is
022making a combined work based on this library.  Thus, the terms and
023conditions of the GNU General Public License cover the whole
024combination.
025
026As a special exception, the copyright holders of this library give you
027permission to link this library with independent modules to produce an
028executable, regardless of the license terms of these independent
029modules, and to copy and distribute the resulting executable under
030terms of your choice, provided that you also meet, for each linked
031independent module, the terms and conditions of the license of that
032module.  An independent module is a module which is not derived from
033or based on this library.  If you modify this library, you may extend
034this exception to your version of the library, but you are not
035obligated to do so.  If you do not wish to do so, delete this
036exception statement from your version. */
037
038package java.sql;
039
040public 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}