/[classpath]/classpath/java/sql/DatabaseMetaData.java
ViewVC logotype

Diff of /classpath/java/sql/DatabaseMetaData.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.10 by bryce, Fri Jun 21 05:34:12 2002 UTC revision 1.11 by mkoch, Sun Oct 12 16:38:16 2003 UTC
# Line 37  exception statement from your version. * Line 37  exception statement from your version. *
37    
38  package java.sql;  package java.sql;
39    
40  public interface DatabaseMetaData  interface DatabaseMetaData
41  {  {
42    /**    /**
43     * It is unknown whether or not the procedure returns a result.     * It is unknown whether or not the procedure returns a result.
44     */     */
45    public static final int procedureResultUnknown = 0;    int procedureResultUnknown = 0;
46    
47    /**    /**
48     * The procedure does not return a result.     * The procedure does not return a result.
49     */     */
50    public static final int procedureNoResult = 1;    int procedureNoResult = 1;
51    
52    /**    /**
53     * The procedure returns a result.     * The procedure returns a result.
54     */     */
55    public static final int procedureReturnsResult = 2;    int procedureReturnsResult = 2;
56    
57    /**    /**
58     * The column type is unknown.     * The column type is unknown.
59     */     */
60    public static final int procedureColumnUnknown = 0;    int procedureColumnUnknown = 0;
61    
62    /**    /**
63     * The column type is input.     * The column type is input.
64     */     */
65    public static final int procedureColumnIn = 1;    int procedureColumnIn = 1;
66    
67    /**    /**
68     * The column type is input/output.     * The column type is input/output.
69     */     */
70    public static final int procedureColumnInOut = 2;    int procedureColumnInOut = 2;
71    
72    /**    /**
73     * The column type is output     * The column type is output
74     */     */
75    public static final int procedureColumnOut = 4;    int procedureColumnOut = 4;
76    
77    /**    /**
78     * The column is used for return values.     * The column is used for return values.
79     */     */
80    public static final int procedureColumnReturn = 5;    int procedureColumnReturn = 5;
81    
82    /**    /**
83     * The column is used for storing results     * The column is used for storing results
84     */     */
85    public static final int procedureColumnResult = 3;    int procedureColumnResult = 3;
86    
87    /**    /**
88     * NULL values are not allowed.     * NULL values are not allowed.
89     */     */
90    public static final int procedureNoNulls = 0;    int procedureNoNulls = 0;
91    
92    /**    /**
93     * NULL values are allowed.     * NULL values are allowed.
94     */     */
95    public static final int procedureNullable = 1;    int procedureNullable = 1;
96    
97    /**    /**
98     * It is unknown whether or not NULL values are allowed.     * It is unknown whether or not NULL values are allowed.
99     */     */
100    public static final int procedureNullableUnknown = 2;    int procedureNullableUnknown = 2;
101    
102    /**    /**
103     * The column does not allow NULL     * The column does not allow NULL
104     */     */
105    public static final int columnNoNulls = 0;    int columnNoNulls = 0;
106    
107    /**    /**
108     * The column does allow NULL     * The column does allow NULL
109     */     */
110    public static final int columnNullable = 1;    int columnNullable = 1;
111    
112    /**    /**
113     * It is unknown whether or not the column allows NULL     * It is unknown whether or not the column allows NULL
114     */     */
115    public static final int columnNullableUnknown = 2;    int columnNullableUnknown = 2;
116    
117    /**    /**
118     * The best row's scope is only guaranteed to be valid so long as the     * The best row's scope is only guaranteed to be valid so long as the
119     * row is actually being used.     * row is actually being used.
120     */     */
121    public static final int bestRowTemporary = 0;    int bestRowTemporary = 0;
122    
123    /**    /**
124     * The best row identifier is valid to the end of the transaction.     * The best row identifier is valid to the end of the transaction.
125     */     */
126    public static final int bestRowTransaction = 1;    int bestRowTransaction = 1;
127    
128    /**    /**
129     * The best row identifier is valid to the end of the session.     * The best row identifier is valid to the end of the session.
130     */     */
131    public static final int bestRowSession = 2;    int bestRowSession = 2;
132    
133    /**    /**
134     * The best row may or may not be a pseudo-column.     * The best row may or may not be a pseudo-column.
135     */     */
136    public static final int bestRowUnknown = 0;    int bestRowUnknown = 0;
137    
138    /**    /**
139     * The best row identifier is not a pseudo-column.     * The best row identifier is not a pseudo-column.
140     */     */
141    public static final int bestRowNotPseudo = 1;    int bestRowNotPseudo = 1;
142    
143    /**    /**
144     * The best row identifier is a pseudo-column.     * The best row identifier is a pseudo-column.
145     */     */
146    public static final int bestRowPseudo = 2;    int bestRowPseudo = 2;
147    
148    /**    /**
149     * It is unknown whether or not the version column is a pseudo-column.     * It is unknown whether or not the version column is a pseudo-column.
150     */     */
151    public static final int versionColumnUnknown = 0;    int versionColumnUnknown = 0;
152    
153    /**    /**
154     * The version column is not a pseudo-column     * The version column is not a pseudo-column
155     */     */
156    public static final int versionColumnNotPseudo = 1;    int versionColumnNotPseudo = 1;
157    
158    /**    /**
159     * The version column is a pseudo-column     * The version column is a pseudo-column
160     */     */
161    public static final int versionColumnPseudo = 2;    int versionColumnPseudo = 2;
162    
163    /**    /**
164     * Foreign key changes are cascaded in updates or deletes.     * Foreign key changes are cascaded in updates or deletes.
165     */     */
166    public static final int importedKeyCascade = 0;    int importedKeyCascade = 0;
167    
168    /**    /**
169     * Column may not be updated or deleted in use as a foreign key.     * Column may not be updated or deleted in use as a foreign key.
170     */     */
171    public static final int importedKeyRestrict = 1;    int importedKeyRestrict = 1;
172    
173    /**    /**
174     * When primary key is updated or deleted, the foreign key is set to NULL.     * When primary key is updated or deleted, the foreign key is set to NULL.
175     */     */
176    public static final int importedKeySetNull = 2;    int importedKeySetNull = 2;
177    
178    /**    /**
179     * If the primary key is a foreign key, it cannot be udpated or deleted.     * If the primary key is a foreign key, it cannot be udpated or deleted.
180     */     */
181    public static final int importedKeyNoAction = 3;    int importedKeyNoAction = 3;
182    
183    /**    /**
184     * If the primary key is updated or deleted, the foreign key is set to     * If the primary key is updated or deleted, the foreign key is set to
185     * a default value.     * a default value.
186     */     */
187    public static final int importedKeySetDefault = 4;    int importedKeySetDefault = 4;
188    
189    /**    /**
190     * Wish I knew what this meant.     * Wish I knew what this meant.
191     */     */
192    public static final int importedKeyInitiallyDeferred = 5;    int importedKeyInitiallyDeferred = 5;
193    
194    /**    /**
195     * Wish I knew what this meant.     * Wish I knew what this meant.
196     */     */
197    public static final int importedKeyInitiallyImmediate = 6;    int importedKeyInitiallyImmediate = 6;
198    
199    /**    /**
200     * Wish I knew what this meant.     * Wish I knew what this meant.
201     */     */
202    public static final int importedKeyNotDeferrable = 7;    int importedKeyNotDeferrable = 7;
203    
204    /**    /**
205     * A NULL value is not allowed for this data type.     * A NULL value is not allowed for this data type.
206     */     */
207    public static final int typeNoNulls = 0;    int typeNoNulls = 0;
208    
209    /**    /**
210     * A NULL value is allowed for this data type.     * A NULL value is allowed for this data type.
211     */     */
212    public static final int typeNullable = 1;    int typeNullable = 1;
213    
214    /**    /**
215     * It is unknown whether or not NULL values are allowed for this data type.     * It is unknown whether or not NULL values are allowed for this data type.
216     */     */
217    public static final int typeNullableUnknown = 2;    int typeNullableUnknown = 2;
218    
219    /**    /**
220     * Where clauses are not supported for this type.     * Where clauses are not supported for this type.
221     */     */
222    public static final int typePredNone = 0;    int typePredNone = 0;
223    
224    /**    /**
225     * Only "WHERE..LIKE" style WHERE clauses are allowed on this data type.     * Only "WHERE..LIKE" style WHERE clauses are allowed on this data type.
226     */     */
227    public static final int typePredChar = 1;    int typePredChar = 1;
228    
229    /**    /**
230     * All WHERE clauses except "WHERE..LIKE" style are allowed on this data type.     * All WHERE clauses except "WHERE..LIKE" style are allowed on this data type.
231     */     */
232    public static final int typePredBasic = 2;    int typePredBasic = 2;
233    
234    /**    /**
235     * Any type of WHERE clause is allowed for this data type.     * Any type of WHERE clause is allowed for this data type.
236     */     */
237    public static final int typeSearchable = 3;    int typeSearchable = 3;
238    
239    /**    /**
240     * This column contains table statistics.     * This column contains table statistics.
241     */     */
242    public static final short tableIndexStatistic = 0;    short tableIndexStatistic = 0;
243    
244    /**    /**
245     * This table index is clustered.     * This table index is clustered.
246     */     */
247    public static final short tableIndexClustered = 1;    short tableIndexClustered = 1;
248    
249    /**    /**
250     * This table index is hashed.     * This table index is hashed.
251     */     */
252    public static final short tableIndexHashed = 2;    short tableIndexHashed = 2;
253    
254    /**    /**
255     * This table index is of another type.     * This table index is of another type.
256     */     */
257    public static final short tableIndexOther = 3;    short tableIndexOther = 3;
258    
259    public static final short attributeNoNulls = 0;    short attributeNoNulls = 0;
260    
261    public static final short attributeNullable = 1;    short attributeNullable = 1;
262    
263    public static final short attributeNullableUnknown = 2;    short attributeNullableUnknown = 2;
264    
265    public static final int sqlStateXOpen = 1;    int sqlStateXOpen = 1;
266    
267    public static final int sqlStateSQL99 = 2;    int sqlStateSQL99 = 2;
268    
269    /**    /**
270     * This method tests whether or not all the procedures returned by     * This method tests whether or not all the procedures returned by
# Line 274  public interface DatabaseMetaData Line 274  public interface DatabaseMetaData
274     * <code>false</code> otherwise.     * <code>false</code> otherwise.
275     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
276     */     */
277    public boolean allProceduresAreCallable() throws SQLException;    boolean allProceduresAreCallable() throws SQLException;
278    
279    /**    /**
280     * This method tests whether or not all the table returned by the     * This method tests whether or not all the table returned by the
# Line 285  public interface DatabaseMetaData Line 285  public interface DatabaseMetaData
285     *     *
286     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
287     */     */
288    public boolean allTablesAreSelectable() throws SQLException;    boolean allTablesAreSelectable() throws SQLException;
289    
290    /**    /**
291     * This method returns the URL for this database.     * This method returns the URL for this database.
# Line 294  public interface DatabaseMetaData Line 294  public interface DatabaseMetaData
294     *         is not known.     *         is not known.
295     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
296     */     */
297    public String getURL() throws SQLException;    String getURL() throws SQLException;
298    
299    /**    /**
300     * This method returns the database username for this connection.     * This method returns the database username for this connection.
# Line 302  public interface DatabaseMetaData Line 302  public interface DatabaseMetaData
302     * @return The database username.     * @return The database username.
303     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
304     */     */
305    public String getUserName() throws SQLException;    String getUserName() throws SQLException;
306    
307    /**    /**
308     * This method tests whether or not the database is in read only mode.     * This method tests whether or not the database is in read only mode.
# Line 311  public interface DatabaseMetaData Line 311  public interface DatabaseMetaData
311     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
312     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
313     */     */
314    public boolean isReadOnly() throws SQLException;    boolean isReadOnly() throws SQLException;
315    
316    /**    /**
317     * This method tests whether or not NULL's sort as high values.     * This method tests whether or not NULL's sort as high values.
# Line 320  public interface DatabaseMetaData Line 320  public interface DatabaseMetaData
320     *         otherwise.     *         otherwise.
321     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
322     */     */
323    public boolean nullsAreSortedHigh() throws SQLException;    boolean nullsAreSortedHigh() throws SQLException;
324    
325    /**    /**
326     * This method tests whether or not NULL's sort as low values.     * This method tests whether or not NULL's sort as low values.
# Line 329  public interface DatabaseMetaData Line 329  public interface DatabaseMetaData
329     * otherwise.     * otherwise.
330     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
331     */     */
332    public boolean nullsAreSortedLow() throws SQLException;    boolean nullsAreSortedLow() throws SQLException;
333    
334    /**    /**
335     * This method tests whether or not NULL's sort as high values.     * This method tests whether or not NULL's sort as high values.
# Line 338  public interface DatabaseMetaData Line 338  public interface DatabaseMetaData
338     * otherwise.     * otherwise.
339     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
340     */     */
341    public boolean nullsAreSortedAtStart() throws SQLException;    boolean nullsAreSortedAtStart() throws SQLException;
342    
343    /**    /**
344     * This method test whether or not NULL's are sorted to the end     * This method test whether or not NULL's are sorted to the end
# Line 348  public interface DatabaseMetaData Line 348  public interface DatabaseMetaData
348     * <code>false</code> otherwise.     * <code>false</code> otherwise.
349     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
350     */     */
351    public boolean nullsAreSortedAtEnd() throws SQLException;    boolean nullsAreSortedAtEnd() throws SQLException;
352    
353    /**    /**
354     * This method returns the name of the database product.     * This method returns the name of the database product.
# Line 356  public interface DatabaseMetaData Line 356  public interface DatabaseMetaData
356     * @return The database product.     * @return The database product.
357     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
358     */     */
359    public String getDatabaseProductName() throws SQLException;    String getDatabaseProductName() throws SQLException;
360    
361    /**    /**
362     * This method returns the version of the database product.     * This method returns the version of the database product.
# Line 364  public interface DatabaseMetaData Line 364  public interface DatabaseMetaData
364     * @return The version of the database product.     * @return The version of the database product.
365     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
366     */     */
367    public String getDatabaseProductVersion() throws SQLException;    String getDatabaseProductVersion() throws SQLException;
368    
369    /**    /**
370     * This method returns the name of the JDBC driver.     * This method returns the name of the JDBC driver.
# Line 372  public interface DatabaseMetaData Line 372  public interface DatabaseMetaData
372     * @return The name of the JDBC driver.     * @return The name of the JDBC driver.
373     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
374     */     */
375    public String getDriverName() throws SQLException;    String getDriverName() throws SQLException;
376    
377    /**    /**
378     * This method returns the version of the JDBC driver.     * This method returns the version of the JDBC driver.
# Line 380  public interface DatabaseMetaData Line 380  public interface DatabaseMetaData
380     * @return The version of the JDBC driver.     * @return The version of the JDBC driver.
381     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
382     */     */
383    public String getDriverVersion() throws SQLException;    String getDriverVersion() throws SQLException;
384    
385    /**    /**
386     * This method returns the major version number of the JDBC driver.     * This method returns the major version number of the JDBC driver.
387     *     *
388     * @return The major version number of the JDBC driver.     * @return The major version number of the JDBC driver.
389     */     */
390    public int getDriverMajorVersion();    int getDriverMajorVersion();
391    
392    /**    /**
393     * This method returns the minor version number of the JDBC driver.     * This method returns the minor version number of the JDBC driver.
394     *     *
395     * @return The minor version number of the JDBC driver.     * @return The minor version number of the JDBC driver.
396     */     */
397    public int getDriverMinorVersion();    int getDriverMinorVersion();
398    
399    /**    /**
400     * This method tests whether or not the database uses local files to     * This method tests whether or not the database uses local files to
# Line 405  public interface DatabaseMetaData Line 405  public interface DatabaseMetaData
405     *     *
406     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
407     */     */
408    public boolean usesLocalFiles() throws SQLException;    boolean usesLocalFiles() throws SQLException;
409    
410    /**    /**
411     * This method tests whether or not the database uses a separate file for     * This method tests whether or not the database uses a separate file for
# Line 416  public interface DatabaseMetaData Line 416  public interface DatabaseMetaData
416     *     *
417     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
418     */     */
419    public boolean usesLocalFilePerTable() throws SQLException;    boolean usesLocalFilePerTable() throws SQLException;
420    
421    /**    /**
422     * This method tests whether or not the database supports identifiers     * This method tests whether or not the database supports identifiers
# Line 427  public interface DatabaseMetaData Line 427  public interface DatabaseMetaData
427     *     *
428     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
429     */     */
430    public boolean supportsMixedCaseIdentifiers() throws SQLException;    boolean supportsMixedCaseIdentifiers() throws SQLException;
431    
432    /**    /**
433     * This method tests whether or not the database treats mixed case     * This method tests whether or not the database treats mixed case
# Line 437  public interface DatabaseMetaData Line 437  public interface DatabaseMetaData
437     *            upper case, <code>false</code> otherwise.     *            upper case, <code>false</code> otherwise.
438     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
439     */     */
440    public boolean storesUpperCaseIdentifiers() throws SQLException;    boolean storesUpperCaseIdentifiers() throws SQLException;
441    
442    /**    /**
443     * This method tests whether or not the database treats mixed case     * This method tests whether or not the database treats mixed case
# Line 447  public interface DatabaseMetaData Line 447  public interface DatabaseMetaData
447     *            lower case, <code>false</code> otherwise.     *            lower case, <code>false</code> otherwise.
448     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
449     */     */
450    public boolean storesLowerCaseIdentifiers() throws SQLException;    boolean storesLowerCaseIdentifiers() throws SQLException;
451    
452    /**    /**
453     * This method tests whether or not the database stores mixed case     * This method tests whether or not the database stores mixed case
# Line 457  public interface DatabaseMetaData Line 457  public interface DatabaseMetaData
457     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
458     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
459     */     */
460    public boolean storesMixedCaseIdentifiers() throws SQLException;    boolean storesMixedCaseIdentifiers() throws SQLException;
461    
462    /**    /**
463     * This method tests whether or not the database supports quoted identifiers     * This method tests whether or not the database supports quoted identifiers
# Line 467  public interface DatabaseMetaData Line 467  public interface DatabaseMetaData
467     *         identifiers, <code>false</code> otherwise.     *         identifiers, <code>false</code> otherwise.
468     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
469     */     */
470    public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException;    boolean supportsMixedCaseQuotedIdentifiers() throws SQLException;
471    
472    /**    /**
473     * This method tests whether or not the database treats mixed case     * This method tests whether or not the database treats mixed case
# Line 477  public interface DatabaseMetaData Line 477  public interface DatabaseMetaData
477     *            as upper case, <code>false</code> otherwise.     *            as upper case, <code>false</code> otherwise.
478     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
479     */     */
480    public boolean storesUpperCaseQuotedIdentifiers() throws SQLException;    boolean storesUpperCaseQuotedIdentifiers() throws SQLException;
481    
482    /**    /**
483     * This method tests whether or not the database treats mixed case     * This method tests whether or not the database treats mixed case
# Line 487  public interface DatabaseMetaData Line 487  public interface DatabaseMetaData
487     *            as lower case, <code>false</code> otherwise.     *            as lower case, <code>false</code> otherwise.
488     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
489     */     */
490    public boolean storesLowerCaseQuotedIdentifiers() throws SQLException;    boolean storesLowerCaseQuotedIdentifiers() throws SQLException;
491    
492    /**    /**
493     * This method tests whether or not the database stores mixed case     * This method tests whether or not the database stores mixed case
# Line 497  public interface DatabaseMetaData Line 497  public interface DatabaseMetaData
497     *         identifiers, <code>false</code> otherwise.     *         identifiers, <code>false</code> otherwise.
498     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
499     */     */
500    public boolean storesMixedCaseQuotedIdentifiers() throws SQLException;    boolean storesMixedCaseQuotedIdentifiers() throws SQLException;
501    
502    /**    /**
503     * This metohd returns the quote string for SQL identifiers.     * This metohd returns the quote string for SQL identifiers.
# Line 506  public interface DatabaseMetaData Line 506  public interface DatabaseMetaData
506     *         is not supported.     *         is not supported.
507     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
508     */     */
509    public String getIdentifierQuoteString() throws SQLException;    String getIdentifierQuoteString() throws SQLException;
510    
511    /**    /**
512     * This method returns a comma separated list of all the SQL keywords in     * This method returns a comma separated list of all the SQL keywords in
# Line 515  public interface DatabaseMetaData Line 515  public interface DatabaseMetaData
515     * @return The list of SQL keywords not in SQL92.     * @return The list of SQL keywords not in SQL92.
516     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
517     */     */
518    public String getSQLKeywords() throws SQLException;    String getSQLKeywords() throws SQLException;
519    
520    /**    /**
521     * This method returns a comma separated list of math functions.     * This method returns a comma separated list of math functions.
# Line 523  public interface DatabaseMetaData Line 523  public interface DatabaseMetaData
523     * @return The list of math functions.     * @return The list of math functions.
524     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
525     */     */
526    public String getNumericFunctions() throws SQLException;    String getNumericFunctions() throws SQLException;
527    
528    /**    /**
529     * This method returns a comma separated list of string functions.     * This method returns a comma separated list of string functions.
# Line 531  public interface DatabaseMetaData Line 531  public interface DatabaseMetaData
531     * @return The list of string functions.     * @return The list of string functions.
532     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
533     */     */
534    public String getStringFunctions() throws SQLException;    String getStringFunctions() throws SQLException;
535    
536    /**    /**
537     * This method returns a comma separated list of of system functions.     * This method returns a comma separated list of of system functions.
# Line 539  public interface DatabaseMetaData Line 539  public interface DatabaseMetaData
539     * @return A comma separated list of system functions.     * @return A comma separated list of system functions.
540     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
541     */     */
542    public String getSystemFunctions() throws SQLException;    String getSystemFunctions() throws SQLException;
543    
544    /**    /**
545     * This method returns comma separated list of time/date functions.     * This method returns comma separated list of time/date functions.
# Line 547  public interface DatabaseMetaData Line 547  public interface DatabaseMetaData
547     * @return The list of time/date functions.     * @return The list of time/date functions.
548     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
549     */     */
550    public String getTimeDateFunctions() throws SQLException;    String getTimeDateFunctions() throws SQLException;
551    
552    /**    /**
553     * This method returns the string used to escape wildcards in search strings.     * This method returns the string used to escape wildcards in search strings.
# Line 555  public interface DatabaseMetaData Line 555  public interface DatabaseMetaData
555     * @return The string used to escape wildcards in search strings.     * @return The string used to escape wildcards in search strings.
556     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
557     */     */
558    public String getSearchStringEscape() throws SQLException;    String getSearchStringEscape() throws SQLException;
559    
560    /**    /**
561     * This methods returns non-standard characters that can appear in     * This methods returns non-standard characters that can appear in
# Line 564  public interface DatabaseMetaData Line 564  public interface DatabaseMetaData
564     * @return Non-standard characters that can appear in unquoted identifiers.     * @return Non-standard characters that can appear in unquoted identifiers.
565     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
566     */     */
567    public String getExtraNameCharacters() throws SQLException;    String getExtraNameCharacters() throws SQLException;
568    
569    /**    /**
570     * This method tests whether or not the database supports     * This method tests whether or not the database supports
# Line 574  public interface DatabaseMetaData Line 574  public interface DatabaseMetaData
574     *         otherwise.     *         otherwise.
575     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
576     */     */
577    public boolean supportsAlterTableWithAddColumn() throws SQLException;    boolean supportsAlterTableWithAddColumn() throws SQLException;
578    
579    /**    /**
580     * This method tests whether or not the database supports     * This method tests whether or not the database supports
# Line 584  public interface DatabaseMetaData Line 584  public interface DatabaseMetaData
584     *         otherwise.     *         otherwise.
585     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
586     */     */
587    public boolean supportsAlterTableWithDropColumn() throws SQLException;    boolean supportsAlterTableWithDropColumn() throws SQLException;
588    
589    /**    /**
590     * This method tests whether or not column aliasing is supported.     * This method tests whether or not column aliasing is supported.
# Line 593  public interface DatabaseMetaData Line 593  public interface DatabaseMetaData
593     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
594     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
595     */     */
596    public boolean supportsColumnAliasing() throws SQLException;    boolean supportsColumnAliasing() throws SQLException;
597    
598    /**    /**
599     * This method tests whether the concatenation of a NULL and non-NULL     * This method tests whether the concatenation of a NULL and non-NULL
# Line 604  public interface DatabaseMetaData Line 604  public interface DatabaseMetaData
604     *         returns a NULL, <code>false</code> otherwise.     *         returns a NULL, <code>false</code> otherwise.
605     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
606     */     */
607    public boolean nullPlusNonNullIsNull() throws SQLException;    boolean nullPlusNonNullIsNull() throws SQLException;
608    
609    /**    /**
610     * Tests whether or not CONVERT is supported.     * Tests whether or not CONVERT is supported.
# Line 613  public interface DatabaseMetaData Line 613  public interface DatabaseMetaData
613     *         otherwise.     *         otherwise.
614     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
615     */     */
616    public boolean supportsConvert() throws SQLException;    boolean supportsConvert() throws SQLException;
617    
618    /**    /**
619     * This method tests whether or not CONVERT can be performed between the     * This method tests whether or not CONVERT can be performed between the
# Line 625  public interface DatabaseMetaData Line 625  public interface DatabaseMetaData
625     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
626     * @see Types     * @see Types
627     */     */
628    public boolean supportsConvert(int fromType, int toType) throws    boolean supportsConvert(int fromType, int toType) throws
629        SQLException;        SQLException;
630    
631    /**    /**
# Line 637  public interface DatabaseMetaData Line 637  public interface DatabaseMetaData
637     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
638     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
639     */     */
640    public boolean supportsTableCorrelationNames() throws SQLException;    boolean supportsTableCorrelationNames() throws SQLException;
641    
642    /**    /**
643     * This method tests whether correlation names must be different from the     * This method tests whether correlation names must be different from the
# Line 647  public interface DatabaseMetaData Line 647  public interface DatabaseMetaData
647     *         the table name, <code>false</code> otherwise.     *         the table name, <code>false</code> otherwise.
648     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
649     */     */
650    public boolean supportsDifferentTableCorrelationNames() throws SQLException;    boolean supportsDifferentTableCorrelationNames() throws SQLException;
651    
652    /**    /**
653     * This method tests whether or not expressions are allowed in an     * This method tests whether or not expressions are allowed in an
# Line 657  public interface DatabaseMetaData Line 657  public interface DatabaseMetaData
657     *         lists, <code>false</code> otherwise.     *         lists, <code>false</code> otherwise.
658     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
659     */     */
660    public boolean supportsExpressionsInOrderBy() throws SQLException;    boolean supportsExpressionsInOrderBy() throws SQLException;
661    
662    /**    /**
663     * This method tests whether or ORDER BY on a non-selected column is     * This method tests whether or ORDER BY on a non-selected column is
# Line 667  public interface DatabaseMetaData Line 667  public interface DatabaseMetaData
667     *         ORDER BY, <code>false</code> otherwise.     *         ORDER BY, <code>false</code> otherwise.
668     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
669     */     */
670    public boolean supportsOrderByUnrelated() throws SQLException;    boolean supportsOrderByUnrelated() throws SQLException;
671    
672    /**    /**
673     * This method tests whether or not GROUP BY is supported.     * This method tests whether or not GROUP BY is supported.
# Line 676  public interface DatabaseMetaData Line 676  public interface DatabaseMetaData
676     *         otherwise.     *         otherwise.
677     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
678     */     */
679    public boolean supportsGroupBy() throws SQLException;    boolean supportsGroupBy() throws SQLException;
680    
681    /**    /**
682     * This method tests whether GROUP BY on a non-selected column is     * This method tests whether GROUP BY on a non-selected column is
# Line 686  public interface DatabaseMetaData Line 686  public interface DatabaseMetaData
686     *         GROUP BY, <code>false</code> otherwise.     *         GROUP BY, <code>false</code> otherwise.
687     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
688     */     */
689    public boolean supportsGroupByUnrelated() throws SQLException;    boolean supportsGroupByUnrelated() throws SQLException;
690    
691    /**    /**
692     * This method tests whether or not a GROUP BY can add columns not in the     * This method tests whether or not a GROUP BY can add columns not in the
# Line 696  public interface DatabaseMetaData Line 696  public interface DatabaseMetaData
696     *         all columns in the select, <code>false</code> otherwise.     *         all columns in the select, <code>false</code> otherwise.
697     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
698     */     */
699    public boolean supportsGroupByBeyondSelect() throws SQLException;    boolean supportsGroupByBeyondSelect() throws SQLException;
700    
701    /**    /**
702     * This method tests whether or not the escape character is supported in     * This method tests whether or not the escape character is supported in
# Line 707  public interface DatabaseMetaData Line 707  public interface DatabaseMetaData
707     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
708     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
709     */     */
710    public boolean supportsLikeEscapeClause() throws SQLException;    boolean supportsLikeEscapeClause() throws SQLException;
711    
712    /**    /**
713     * This method tests whether multiple result sets for a single statement are     * This method tests whether multiple result sets for a single statement are
# Line 717  public interface DatabaseMetaData Line 717  public interface DatabaseMetaData
717     *         single statement, <code>false</code> otherwise.     *         single statement, <code>false</code> otherwise.
718     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
719     */     */
720    public boolean supportsMultipleResultSets() throws SQLException;    boolean supportsMultipleResultSets() throws SQLException;
721    
722    /**    /**
723     * This method test whether or not multiple transactions may be open     * This method test whether or not multiple transactions may be open
# Line 727  public interface DatabaseMetaData Line 727  public interface DatabaseMetaData
727     *         connections are supported, <code>false</code> otherwise.     *         connections are supported, <code>false</code> otherwise.
728     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
729     */     */
730    public boolean supportsMultipleTransactions() throws SQLException;    boolean supportsMultipleTransactions() throws SQLException;
731    
732    /**    /**
733     * This method tests whether or not columns can be defined as NOT NULL.  A     * This method tests whether or not columns can be defined as NOT NULL.  A
# Line 737  public interface DatabaseMetaData Line 737  public interface DatabaseMetaData
737     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
738     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
739     */     */
740    public boolean supportsNonNullableColumns() throws SQLException;    boolean supportsNonNullableColumns() throws SQLException;
741    
742    /**    /**
743     * This method tests whether or not the minimum grammer for ODBC is supported.     * This method tests whether or not the minimum grammer for ODBC is supported.
# Line 747  public interface DatabaseMetaData Line 747  public interface DatabaseMetaData
747     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
748     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
749     */     */
750    public boolean supportsMinimumSQLGrammar() throws SQLException;    boolean supportsMinimumSQLGrammar() throws SQLException;
751    
752    /**    /**
753     * This method tests whether or not the core grammer for ODBC is supported.     * This method tests whether or not the core grammer for ODBC is supported.
# Line 756  public interface DatabaseMetaData Line 756  public interface DatabaseMetaData
756     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
757     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
758     */     */
759    public boolean supportsCoreSQLGrammar() throws SQLException;    boolean supportsCoreSQLGrammar() throws SQLException;
760    
761    /**    /**
762     * This method tests whether or not the extended grammer for ODBC is supported.     * This method tests whether or not the extended grammer for ODBC is supported.
# Line 765  public interface DatabaseMetaData Line 765  public interface DatabaseMetaData
765     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
766     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
767     */     */
768    public boolean supportsExtendedSQLGrammar() throws SQLException;    boolean supportsExtendedSQLGrammar() throws SQLException;
769    
770    /**    /**
771     * This method tests whether or not the ANSI92 entry level SQL     * This method tests whether or not the ANSI92 entry level SQL
# Line 776  public interface DatabaseMetaData Line 776  public interface DatabaseMetaData
776     *         supported, <code>false</code> otherwise.     *         supported, <code>false</code> otherwise.
777     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
778     */     */
779    public boolean supportsANSI92EntryLevelSQL() throws SQLException;    boolean supportsANSI92EntryLevelSQL() throws SQLException;
780    
781    /**    /**
782     * This method tests whether or not the ANSI92 intermediate SQL     * This method tests whether or not the ANSI92 intermediate SQL
# Line 786  public interface DatabaseMetaData Line 786  public interface DatabaseMetaData
786     *         supported, <code>false</code> otherwise.     *         supported, <code>false</code> otherwise.
787     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
788     */     */
789    public boolean supportsANSI92IntermediateSQL() throws SQLException;    boolean supportsANSI92IntermediateSQL() throws SQLException;
790    
791    /**    /**
792     * This method tests whether or not the ANSI92 full SQL     * This method tests whether or not the ANSI92 full SQL
# Line 796  public interface DatabaseMetaData Line 796  public interface DatabaseMetaData
796     *         supported, <code>false</code> otherwise.     *         supported, <code>false</code> otherwise.
797     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
798     */     */
799    public boolean supportsANSI92FullSQL() throws SQLException;    boolean supportsANSI92FullSQL() throws SQLException;
800    
801    /**    /**
802     * This method tests whether or not the SQL integrity enhancement     * This method tests whether or not the SQL integrity enhancement
# Line 806  public interface DatabaseMetaData Line 806  public interface DatabaseMetaData
806     *         supported, <code>false</code> otherwise.     *         supported, <code>false</code> otherwise.
807     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
808     */     */
809    public boolean supportsIntegrityEnhancementFacility() throws SQLException;    boolean supportsIntegrityEnhancementFacility() throws SQLException;
810    
811    /**    /**
812     * This method tests whether or not the database supports outer joins.     * This method tests whether or not the database supports outer joins.
# Line 815  public interface DatabaseMetaData Line 815  public interface DatabaseMetaData
815     *         otherwise.     *         otherwise.
816     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
817     */     */
818    public boolean supportsOuterJoins() throws SQLException;    boolean supportsOuterJoins() throws SQLException;
819    
820    /**    /**
821     * This method tests whether or not the database supports full outer joins.     * This method tests whether or not the database supports full outer joins.
# Line 824  public interface DatabaseMetaData Line 824  public interface DatabaseMetaData
824     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
825     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
826     */     */
827    public boolean supportsFullOuterJoins() throws SQLException;    boolean supportsFullOuterJoins() throws SQLException;
828    
829    /**    /**
830     * This method tests whether or not the database supports limited outer joins.     * This method tests whether or not the database supports limited outer joins.
# Line 833  public interface DatabaseMetaData Line 833  public interface DatabaseMetaData
833     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
834     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
835     */     */
836    public boolean supportsLimitedOuterJoins() throws SQLException;    boolean supportsLimitedOuterJoins() throws SQLException;
837    
838    /**    /**
839     * This method returns the vendor's term for "schema".     * This method returns the vendor's term for "schema".
# Line 841  public interface DatabaseMetaData Line 841  public interface DatabaseMetaData
841     * @return The vendor's term for schema.     * @return The vendor's term for schema.
842     * @exception SQLException if an error occurs.     * @exception SQLException if an error occurs.
843     */     */
844    public String getSchemaTerm() throws SQLException;    String getSchemaTerm() throws SQLException;
845    
846    /**    /**
847     * This method returns the vendor's term for "procedure".     * This method returns the vendor's term for "procedure".
# Line 849  public interface DatabaseMetaData Line 849  public interface DatabaseMetaData
849     * @return The vendor's term for procedure.     * @return The vendor's term for procedure.
850     * @exception SQLException if an error occurs.     * @exception SQLException if an error occurs.
851     */     */
852    public String getProcedureTerm() throws SQLException;    String getProcedureTerm() throws SQLException;
853    
854    /**    /**
855     * This method returns the vendor's term for "catalog".     * This method returns the vendor's term for "catalog".
# Line 857  public interface DatabaseMetaData Line 857  public interface DatabaseMetaData
857     * @return The vendor's term for catalog.     * @return The vendor's term for catalog.
858     * @exception SQLException if an error occurs.     * @exception SQLException if an error occurs.
859     */     */
860    public String getCatalogTerm() throws SQLException;    String getCatalogTerm() throws SQLException;
861    
862    /**    /**
863     * This method tests whether a catalog name appears at the beginning of     * This method tests whether a catalog name appears at the beginning of
# Line 867  public interface DatabaseMetaData Line 867  public interface DatabaseMetaData
867     *         <code>false</code> if it appears at the end.     *         <code>false</code> if it appears at the end.
868     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
869     */     */
870    public boolean isCatalogAtStart() throws SQLException;    boolean isCatalogAtStart() throws SQLException;
871    
872    /**    /**
873     * This method returns the separator between the catalog name and the     * This method returns the separator between the catalog name and the
# Line 876  public interface DatabaseMetaData Line 876  public interface DatabaseMetaData
876     * @return The separator between the catalog name and the table name.     * @return The separator between the catalog name and the table name.
877     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
878     */     */
879    public String getCatalogSeparator() throws SQLException;    String getCatalogSeparator() throws SQLException;
880    
881    /**    /**
882     * This method tests whether a catalog name can appear in a data     * This method tests whether a catalog name can appear in a data
# Line 886  public interface DatabaseMetaData Line 886  public interface DatabaseMetaData
886     *         manipulation statement, <code>false</code> otherwise.     *         manipulation statement, <code>false</code> otherwise.
887     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
888     */     */
889    public boolean supportsSchemasInDataManipulation() throws SQLException;    boolean supportsSchemasInDataManipulation() throws SQLException;
890    
891    /**    /**
892     * This method tests whether a catalog name can appear in a procedure     * This method tests whether a catalog name can appear in a procedure
# Line 896  public interface DatabaseMetaData Line 896  public interface DatabaseMetaData
896     *         call, <code>false</code> otherwise.     *         call, <code>false</code> otherwise.
897     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
898     */     */
899    public boolean supportsSchemasInProcedureCalls() throws SQLException;    boolean supportsSchemasInProcedureCalls() throws SQLException;
900    
901    /**    /**
902     * This method tests whether a catalog name can appear in a table definition.     * This method tests whether a catalog name can appear in a table definition.
# Line 905  public interface DatabaseMetaData Line 905  public interface DatabaseMetaData
905     *         definition, <code>false</code> otherwise.     *         definition, <code>false</code> otherwise.
906     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
907     */     */
908    public boolean supportsSchemasInTableDefinitions() throws SQLException;    boolean supportsSchemasInTableDefinitions() throws SQLException;
909    
910    /**    /**
911     * This method tests whether a catalog name can appear in an index definition.     * This method tests whether a catalog name can appear in an index definition.
# Line 914  public interface DatabaseMetaData Line 914  public interface DatabaseMetaData
914     *         definition, <code>false</code> otherwise.     *         definition, <code>false</code> otherwise.
915     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
916     */     */
917    public boolean supportsSchemasInIndexDefinitions() throws SQLException;    boolean supportsSchemasInIndexDefinitions() throws SQLException;
918    
919    /**    /**
920     * This method tests whether a catalog name can appear in privilege definitions.     * This method tests whether a catalog name can appear in privilege definitions.
# Line 923  public interface DatabaseMetaData Line 923  public interface DatabaseMetaData
923     *         definition, <code>false</code> otherwise.     *         definition, <code>false</code> otherwise.
924     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
925     */     */
926    public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException;    boolean supportsSchemasInPrivilegeDefinitions() throws SQLException;
927    
928    /**    /**
929     * This method tests whether a catalog name can appear in a data     * This method tests whether a catalog name can appear in a data
# Line 933  public interface DatabaseMetaData Line 933  public interface DatabaseMetaData
933     *         manipulation statement, <code>false</code> otherwise.     *         manipulation statement, <code>false</code> otherwise.
934     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
935     */     */
936    public boolean supportsCatalogsInDataManipulation() throws SQLException;    boolean supportsCatalogsInDataManipulation() throws SQLException;
937    
938    /**    /**
939     * This method tests whether a catalog name can appear in a procedure     * This method tests whether a catalog name can appear in a procedure
# Line 943  public interface DatabaseMetaData Line 943  public interface DatabaseMetaData
943     *         call, <code>false</code> otherwise.     *         call, <code>false</code> otherwise.
944     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
945     */     */
946    public boolean supportsCatalogsInProcedureCalls() throws SQLException;    boolean supportsCatalogsInProcedureCalls() throws SQLException;
947    
948    /**    /**
949     * This method tests whether a catalog name can appear in a table definition.     * This method tests whether a catalog name can appear in a table definition.
# Line 952  public interface DatabaseMetaData Line 952  public interface DatabaseMetaData
952     *         definition, <code>false</code> otherwise.     *         definition, <code>false</code> otherwise.
953     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
954     */     */
955    public boolean supportsCatalogsInTableDefinitions() throws SQLException;    boolean supportsCatalogsInTableDefinitions() throws SQLException;
956    
957    /**    /**
958     * This method tests whether a catalog name can appear in an index definition.     * This method tests whether a catalog name can appear in an index definition.
# Line 961  public interface DatabaseMetaData Line 961  public interface DatabaseMetaData
961     *         definition, <code>false</code> otherwise.     *         definition, <code>false</code> otherwise.
962     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
963     */     */
964    public boolean supportsCatalogsInIndexDefinitions() throws SQLException;    boolean supportsCatalogsInIndexDefinitions() throws SQLException;
965    
966    /**    /**
967     * This method tests whether a catalog name can appear in privilege definitions.     * This method tests whether a catalog name can appear in privilege definitions.
# Line 970  public interface DatabaseMetaData Line 970  public interface DatabaseMetaData
970     *         definition, <code>false</code> otherwise.     *         definition, <code>false</code> otherwise.
971     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
972     */     */
973    public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException;    boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException;
974    
975    /**    /**
976     * This method tests whether or not that database supports positioned     * This method tests whether or not that database supports positioned
# Line 980  public interface DatabaseMetaData Line 980  public interface DatabaseMetaData
980     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
981     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
982     */     */
983    public boolean supportsPositionedDelete() throws SQLException;    boolean supportsPositionedDelete() throws SQLException;
984    
985    /**    /**
986     * This method tests whether or not that database supports positioned     * This method tests whether or not that database supports positioned
# Line 990  public interface DatabaseMetaData Line 990  public interface DatabaseMetaData
990     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
991     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
992     */     */
993    public boolean supportsPositionedUpdate() throws SQLException;    boolean supportsPositionedUpdate() throws SQLException;
994    
995    /**    /**
996     * This method tests whether or not SELECT FOR UPDATE is supported by the     * This method tests whether or not SELECT FOR UPDATE is supported by the
# Line 1000  public interface DatabaseMetaData Line 1000  public interface DatabaseMetaData
1000     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1001     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1002     */     */
1003    public boolean supportsSelectForUpdate() throws SQLException;    boolean supportsSelectForUpdate() throws SQLException;
1004    
1005    /**    /**
1006     * This method tests whether or not stored procedures are supported on     * This method tests whether or not stored procedures are supported on
# Line 1010  public interface DatabaseMetaData Line 1010  public interface DatabaseMetaData
1010     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1011     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1012     */     */
1013    public boolean supportsStoredProcedures() throws SQLException;    boolean supportsStoredProcedures() throws SQLException;
1014    
1015    /**    /**
1016     * This method tests whether or not subqueries are allowed in comparisons.     * This method tests whether or not subqueries are allowed in comparisons.
# Line 1020  public interface DatabaseMetaData Line 1020  public interface DatabaseMetaData
1020     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1021     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1022     */     */
1023    public boolean supportsSubqueriesInComparisons() throws SQLException;    boolean supportsSubqueriesInComparisons() throws SQLException;
1024    
1025    /**    /**
1026     * This method tests whether or not subqueries are allowed in exists     * This method tests whether or not subqueries are allowed in exists
# Line 1031  public interface DatabaseMetaData Line 1031  public interface DatabaseMetaData
1031     *         expressions, <code>false</code> otherwise.     *         expressions, <code>false</code> otherwise.
1032     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1033     */     */
1034    public boolean supportsSubqueriesInExists() throws SQLException;    boolean supportsSubqueriesInExists() throws SQLException;
1035    
1036    /**    /**
1037     * This method tests whether subqueries are allowed in IN statements.     * This method tests whether subqueries are allowed in IN statements.
# Line 1041  public interface DatabaseMetaData Line 1041  public interface DatabaseMetaData
1041     *         statements, <code>false</code> otherwise.     *         statements, <code>false</code> otherwise.
1042     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1043     */     */
1044    public boolean supportsSubqueriesInIns() throws SQLException;    boolean supportsSubqueriesInIns() throws SQLException;
1045    
1046    /**    /**
1047     * This method tests whether or not subqueries are allowed in quantified     * This method tests whether or not subqueries are allowed in quantified
# Line 1052  public interface DatabaseMetaData Line 1052  public interface DatabaseMetaData
1052     *         expressions, <code>false</code> otherwise.     *         expressions, <code>false</code> otherwise.
1053     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1054     */     */
1055    public boolean supportsSubqueriesInQuantifieds() throws SQLException;    boolean supportsSubqueriesInQuantifieds() throws SQLException;
1056    
1057    /**    /**
1058     * This method test whether or not correlated subqueries are allowed. A     * This method test whether or not correlated subqueries are allowed. A
# Line 1062  public interface DatabaseMetaData Line 1062  public interface DatabaseMetaData
1062     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1063     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1064     */     */
1065    public boolean supportsCorrelatedSubqueries() throws SQLException;    boolean supportsCorrelatedSubqueries() throws SQLException;
1066    
1067    /**    /**
1068     * This method tests whether or not the UNION statement is supported.     * This method tests whether or not the UNION statement is supported.
# Line 1071  public interface DatabaseMetaData Line 1071  public interface DatabaseMetaData
1071     *         otherwise.     *         otherwise.
1072     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1073     */     */
1074    public boolean supportsUnion() throws SQLException;    boolean supportsUnion() throws SQLException;
1075    
1076    /**    /**
1077     * This method tests whether or not the UNION ALL statement is supported.     * This method tests whether or not the UNION ALL statement is supported.
# Line 1080  public interface DatabaseMetaData Line 1080  public interface DatabaseMetaData
1080     *         otherwise.     *         otherwise.
1081     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1082     */     */
1083    public boolean supportsUnionAll() throws SQLException;    boolean supportsUnionAll() throws SQLException;
1084    
1085    /**    /**
1086     * This method tests whether or not the database supports cursors     * This method tests whether or not the database supports cursors
# Line 1090  public interface DatabaseMetaData Line 1090  public interface DatabaseMetaData
1090     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1091     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1092     */     */
1093    public boolean supportsOpenCursorsAcrossCommit() throws SQLException;    boolean supportsOpenCursorsAcrossCommit() throws SQLException;
1094    
1095    /**    /**
1096     * This method tests whether or not the database supports cursors     * This method tests whether or not the database supports cursors
# Line 1100  public interface DatabaseMetaData Line 1100  public interface DatabaseMetaData
1100     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1101     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1102     */     */
1103    public boolean supportsOpenCursorsAcrossRollback() throws SQLException;    boolean supportsOpenCursorsAcrossRollback() throws SQLException;
1104    
1105    /**    /**
1106     * This method tests whether or not the database supports statements     * This method tests whether or not the database supports statements
# Line 1110  public interface DatabaseMetaData Line 1110  public interface DatabaseMetaData
1110     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1111     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1112     */     */
1113    public boolean supportsOpenStatementsAcrossCommit() throws SQLException;    boolean supportsOpenStatementsAcrossCommit() throws SQLException;
1114    
1115    /**    /**
1116     * This method tests whether or not the database supports statements     * This method tests whether or not the database supports statements
# Line 1120  public interface DatabaseMetaData Line 1120  public interface DatabaseMetaData
1120     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1121     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1122     */     */
1123    public boolean supportsOpenStatementsAcrossRollback() throws SQLException;    boolean supportsOpenStatementsAcrossRollback() throws SQLException;
1124    
1125    /**    /**
1126     * This method returns the number of hex characters allowed in an inline     * This method returns the number of hex characters allowed in an inline
# Line 1130  public interface DatabaseMetaData Line 1130  public interface DatabaseMetaData
1130     *         either an unknown or unlimited number.     *         either an unknown or unlimited number.
1131     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1132     */     */
1133    public int getMaxBinaryLiteralLength() throws SQLException;    int getMaxBinaryLiteralLength() throws SQLException;
1134    
1135    /**    /**
1136     * This method returns the maximum length of a character literal.     * This method returns the maximum length of a character literal.
# Line 1138  public interface DatabaseMetaData Line 1138  public interface DatabaseMetaData
1138     * @return The maximum length of a character literal.     * @return The maximum length of a character literal.
1139     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1140     */     */
1141    public int getMaxCharLiteralLength() throws SQLException;    int getMaxCharLiteralLength() throws SQLException;
1142    
1143    /**    /**
1144     * This method returns the maximum length of a column name.     * This method returns the maximum length of a column name.
# Line 1146  public interface DatabaseMetaData Line 1146  public interface DatabaseMetaData
1146     * @return The maximum length of a column name.     * @return The maximum length of a column name.
1147     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1148     */     */
1149    public int getMaxColumnNameLength() throws SQLException;    int getMaxColumnNameLength() throws SQLException;
1150    
1151    /**    /**
1152     * This method returns the maximum number of columns in a GROUP BY statement.     * This method returns the maximum number of columns in a GROUP BY statement.
# Line 1154  public interface DatabaseMetaData Line 1154  public interface DatabaseMetaData
1154     * @return The maximum number of columns in a GROUP BY statement.     * @return The maximum number of columns in a GROUP BY statement.
1155     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1156     */     */
1157    public int getMaxColumnsInGroupBy() throws SQLException;    int getMaxColumnsInGroupBy() throws SQLException;
1158    
1159    /**    /**
1160     * This method returns the maximum number of columns in an index.     * This method returns the maximum number of columns in an index.
# Line 1162  public interface DatabaseMetaData Line 1162  public interface DatabaseMetaData
1162     * @return The maximum number of columns in an index.     * @return The maximum number of columns in an index.
1163     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1164     */     */
1165    public int getMaxColumnsInIndex() throws SQLException;    int getMaxColumnsInIndex() throws SQLException;
1166    
1167    /**    /**
1168     * This method returns the maximum number of columns in an ORDER BY statement.     * This method returns the maximum number of columns in an ORDER BY statement.
# Line 1170  public interface DatabaseMetaData Line 1170  public interface DatabaseMetaData
1170     * @return The maximum number of columns in an ORDER BY statement.     * @return The maximum number of columns in an ORDER BY statement.
1171     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1172     */     */
1173    public int getMaxColumnsInOrderBy() throws SQLException;    int getMaxColumnsInOrderBy() throws SQLException;
1174    
1175    /**    /**
1176     * This method returns the maximum number of columns in a SELECT statement.     * This method returns the maximum number of columns in a SELECT statement.
# Line 1178  public interface DatabaseMetaData Line 1178  public interface DatabaseMetaData
1178     * @return The maximum number of columns in a SELECT statement.     * @return The maximum number of columns in a SELECT statement.
1179     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1180     */     */
1181    public int getMaxColumnsInSelect() throws SQLException;    int getMaxColumnsInSelect() throws SQLException;
1182    
1183    /**    /**
1184     * This method returns the maximum number of columns in a table.     * This method returns the maximum number of columns in a table.
# Line 1186  public interface DatabaseMetaData Line 1186  public interface DatabaseMetaData
1186     * @return The maximum number of columns in a table.     * @return The maximum number of columns in a table.
1187     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1188     */     */
1189    public int getMaxColumnsInTable() throws SQLException;    int getMaxColumnsInTable() throws SQLException;
1190    
1191    /**    /**
1192     * This method returns the maximum number of connections this client     * This method returns the maximum number of connections this client
# Line 1195  public interface DatabaseMetaData Line 1195  public interface DatabaseMetaData
1195     * @return The maximum number of database connections.     * @return The maximum number of database connections.
1196     * @SQLException If an error occurs.     * @SQLException If an error occurs.
1197     */     */
1198    public int getMaxConnections() throws SQLException;    int getMaxConnections() throws SQLException;
1199    
1200    /**    /**
1201     * This method returns the maximum length of a cursor name.     * This method returns the maximum length of a cursor name.
# Line 1203  public interface DatabaseMetaData Line 1203  public interface DatabaseMetaData
1203     * @return The maximum length of a cursor name.     * @return The maximum length of a cursor name.
1204     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1205     */     */
1206    public int getMaxCursorNameLength() throws SQLException;    int getMaxCursorNameLength() throws SQLException;
1207    
1208    /**    /**
1209     * This method returns the maximum length of an index.     * This method returns the maximum length of an index.
# Line 1211  public interface DatabaseMetaData Line 1211  public interface DatabaseMetaData
1211     * @return The maximum length of an index.     * @return The maximum length of an index.
1212     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1213     */     */
1214    public int getMaxIndexLength() throws SQLException;    int getMaxIndexLength() throws SQLException;
1215    
1216    /**    /**
1217     * This method returns the maximum length of a schema name.     * This method returns the maximum length of a schema name.
# Line 1219  public interface DatabaseMetaData Line 1219  public interface DatabaseMetaData
1219     * @return The maximum length of a schema name.     * @return The maximum length of a schema name.
1220     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1221     */     */
1222    public int getMaxSchemaNameLength() throws SQLException;    int getMaxSchemaNameLength() throws SQLException;
1223    
1224    /**    /**
1225     * This method returns the maximum length of a procedure name.     * This method returns the maximum length of a procedure name.
# Line 1227  public interface DatabaseMetaData Line 1227  public interface DatabaseMetaData
1227     * @return The maximum length of a procedure name.     * @return The maximum length of a procedure name.
1228     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1229     */     */
1230    public int getMaxProcedureNameLength() throws SQLException;    int getMaxProcedureNameLength() throws SQLException;
1231    
1232    /**    /**
1233     * This method returns the maximum length of a catalog name.     * This method returns the maximum length of a catalog name.
# Line 1235  public interface DatabaseMetaData Line 1235  public interface DatabaseMetaData
1235     * @return The maximum length of a catalog name.     * @return The maximum length of a catalog name.
1236     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1237     */     */
1238    public int getMaxCatalogNameLength() throws SQLException;    int getMaxCatalogNameLength() throws SQLException;
1239    
1240    /**    /**
1241     * This method returns the maximum size of a row in bytes.     * This method returns the maximum size of a row in bytes.
# Line 1243  public interface DatabaseMetaData Line 1243  public interface DatabaseMetaData
1243     * @return The maximum size of a row.     * @return The maximum size of a row.
1244     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1245     */     */
1246    public int getMaxRowSize() throws SQLException;    int getMaxRowSize() throws SQLException;
1247    
1248    /**    /**
1249     * This method tests whether or not the maximum row size includes BLOB's     * This method tests whether or not the maximum row size includes BLOB's
# Line 1252  public interface DatabaseMetaData Line 1252  public interface DatabaseMetaData
1252     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1253     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1254     */     */
1255    public boolean doesMaxRowSizeIncludeBlobs() throws SQLException;    boolean doesMaxRowSizeIncludeBlobs() throws SQLException;
1256    
1257    /**    /**
1258     * This method includes the maximum length of a SQL statement.     * This method includes the maximum length of a SQL statement.
# Line 1260  public interface DatabaseMetaData Line 1260  public interface DatabaseMetaData
1260     * @return The maximum length of a SQL statement.     * @return The maximum length of a SQL statement.
1261     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1262     */     */
1263    public int getMaxStatementLength() throws SQLException;    int getMaxStatementLength() throws SQLException;
1264    
1265    /**    /**
1266     * This method returns the maximum number of statements that can be     * This method returns the maximum number of statements that can be
# Line 1269  public interface DatabaseMetaData Line 1269  public interface DatabaseMetaData
1269     * @return The maximum number of statements that can be active at any time.     * @return The maximum number of statements that can be active at any time.
1270     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1271     */     */
1272    public int getMaxStatements() throws SQLException;    int getMaxStatements() throws SQLException;
1273    
1274    /**    /**
1275     * This method returns the maximum length of a table name.     * This method returns the maximum length of a table name.
# Line 1277  public interface DatabaseMetaData Line 1277  public interface DatabaseMetaData
1277     * @return The maximum length of a table name.     * @return The maximum length of a table name.
1278     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1279     */     */
1280    public int getMaxTableNameLength() throws SQLException;    int getMaxTableNameLength() throws SQLException;
1281    
1282    /**    /**
1283     * This method returns the maximum number of tables that may be referenced     * This method returns the maximum number of tables that may be referenced
# Line 1286  public interface DatabaseMetaData Line 1286  public interface DatabaseMetaData
1286     * @return The maximum number of tables allowed in a SELECT statement.     * @return The maximum number of tables allowed in a SELECT statement.
1287     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1288     */     */
1289    public int getMaxTablesInSelect() throws SQLException;    int getMaxTablesInSelect() throws SQLException;
1290    
1291    /**    /**
1292     * This method returns the maximum length of a user name.     * This method returns the maximum length of a user name.
# Line 1294  public interface DatabaseMetaData Line 1294  public interface DatabaseMetaData
1294     * @return The maximum length of a user name.     * @return The maximum length of a user name.
1295     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1296     */     */
1297    public int getMaxUserNameLength() throws SQLException;    int getMaxUserNameLength() throws SQLException;
1298    
1299    /**    /**
1300     * This method returns the default transaction isolation level of the     * This method returns the default transaction isolation level of the
# Line 1304  public interface DatabaseMetaData Line 1304  public interface DatabaseMetaData
1304     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1305     * @see Connection     * @see Connection
1306     */     */
1307    public int getDefaultTransactionIsolation() throws SQLException;    int getDefaultTransactionIsolation() throws SQLException;
1308    
1309    /**    /**
1310     * This method tests whether or not the database supports transactions.     * This method tests whether or not the database supports transactions.
# Line 1313  public interface DatabaseMetaData Line 1313  public interface DatabaseMetaData
1313     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1314     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1315     */     */
1316    public boolean supportsTransactions() throws SQLException;    boolean supportsTransactions() throws SQLException;
1317    
1318    /**    /**
1319     * This method tests whether or not the database supports the specified     * This method tests whether or not the database supports the specified
# Line 1325  public interface DatabaseMetaData Line 1325  public interface DatabaseMetaData
1325     *         is supported, <code>false</code> otherwise.     *         is supported, <code>false</code> otherwise.
1326     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1327     */     */
1328    public boolean supportsTransactionIsolationLevel(int level) throws    boolean supportsTransactionIsolationLevel(int level) throws
1329        SQLException;        SQLException;
1330    
1331    /**    /**
# Line 1336  public interface DatabaseMetaData Line 1336  public interface DatabaseMetaData
1336     *         same transaction, <code>false</code> otherwise.     *         same transaction, <code>false</code> otherwise.
1337     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1338     */     */
1339    public boolean supportsDataDefinitionAndDataManipulationTransactions()    boolean supportsDataDefinitionAndDataManipulationTransactions()
1340        throws SQLException;        throws SQLException;
1341    
1342    /**    /**
# Line 1347  public interface DatabaseMetaData Line 1347  public interface DatabaseMetaData
1347     *         transactions, <code>false</code> otherwise.     *         transactions, <code>false</code> otherwise.
1348     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1349     */     */
1350    public boolean supportsDataManipulationTransactionsOnly() throws    boolean supportsDataManipulationTransactionsOnly() throws
1351        SQLException;        SQLException;
1352    
1353    /**    /**
# Line 1358  public interface DatabaseMetaData Line 1358  public interface DatabaseMetaData
1358     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1359     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1360     */     */
1361    public boolean dataDefinitionCausesTransactionCommit() throws SQLException;    boolean dataDefinitionCausesTransactionCommit() throws SQLException;
1362    
1363    /**    /**
1364     * This method tests whether or not DDL statements are ignored in     * This method tests whether or not DDL statements are ignored in
# Line 1368  public interface DatabaseMetaData Line 1368  public interface DatabaseMetaData
1368     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
1369     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1370     */     */
1371    public boolean dataDefinitionIgnoredInTransactions() throws SQLException;    boolean dataDefinitionIgnoredInTransactions() throws SQLException;
1372    
1373    /**    /**
1374     * This method returns a list of all the stored procedures matching the     * This method returns a list of all the stored procedures matching the
# Line 1399  public interface DatabaseMetaData Line 1399  public interface DatabaseMetaData
1399     * @returns A <code>ResultSet</code> with all the requested procedures.     * @returns A <code>ResultSet</code> with all the requested procedures.
1400     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1401     */     */
1402    public ResultSet getProcedures(String catalog, String schemaPattern, String    ResultSet getProcedures(String catalog, String schemaPattern, String
1403        procedureNamePattern) throws SQLException;        procedureNamePattern) throws SQLException;
1404    
1405    /**    /**
# Line 1441  public interface DatabaseMetaData Line 1441  public interface DatabaseMetaData
1441     * @returns A <code>ResultSet</code> with all the requested procedures.     * @returns A <code>ResultSet</code> with all the requested procedures.
1442     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1443     */     */
1444    public ResultSet getProcedureColumns(String catalog, String schemaPattern,    ResultSet getProcedureColumns(String catalog, String schemaPattern,
1445        String procedureNamePattern, String columnNamePattern) throws        String procedureNamePattern, String columnNamePattern) throws
1446        SQLException;        SQLException;
1447    
# Line 1467  public interface DatabaseMetaData Line 1467  public interface DatabaseMetaData
1467     * @returns A <code>ResultSet</code> with all the requested tables.     * @returns A <code>ResultSet</code> with all the requested tables.
1468     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1469     */     */
1470    public ResultSet getTables(String catalog, String schemaPattern, String    ResultSet getTables(String catalog, String schemaPattern, String
1471        tableNamePattern, String[] types) throws SQLException;        tableNamePattern, String[] types) throws SQLException;
1472    
1473    /**    /**
# Line 1478  public interface DatabaseMetaData Line 1478  public interface DatabaseMetaData
1478     * @return A <code>ResultSet</code> with all the requested schemas.     * @return A <code>ResultSet</code> with all the requested schemas.
1479     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1480     */     */
1481    public ResultSet getSchemas() throws SQLException;    ResultSet getSchemas() throws SQLException;
1482    
1483    /**    /**
1484     * This method returns the list of database catalogs as a     * This method returns the list of database catalogs as a
# Line 1488  public interface DatabaseMetaData Line 1488  public interface DatabaseMetaData
1488     * @return A <code>ResultSet</code> with all the requested catalogs.     * @return A <code>ResultSet</code> with all the requested catalogs.
1489     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1490     */     */
1491    public ResultSet getCatalogs() throws SQLException;    ResultSet getCatalogs() throws SQLException;
1492    
1493    /**    /**
1494     * This method returns the list of database table types as a     * This method returns the list of database table types as a
# Line 1498  public interface DatabaseMetaData Line 1498  public interface DatabaseMetaData
1498     * @return A <code>ResultSet</code> with all the requested table types.     * @return A <code>ResultSet</code> with all the requested table types.
1499     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1500     */     */
1501    public ResultSet getTableTypes() throws SQLException;    ResultSet getTableTypes() throws SQLException;
1502    
1503    /**    /**
1504     * This method returns a list of the tables columns for     * This method returns a list of the tables columns for
# Line 1541  public interface DatabaseMetaData Line 1541  public interface DatabaseMetaData
1541     * @returns A <code>ResultSet</code> with all the requested tables.     * @returns A <code>ResultSet</code> with all the requested tables.
1542     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1543     */     */
1544    public ResultSet getColumns(String catalog, String schemaPattern, String    ResultSet getColumns(String catalog, String schemaPattern, String
1545        tableNamePattern, String columnNamePattern) throws SQLException;        tableNamePattern, String columnNamePattern) throws SQLException;
1546    
1547    /**    /**
# Line 1573  public interface DatabaseMetaData Line 1573  public interface DatabaseMetaData
1573     * @return A <code>ResultSet</code> with all the requested privileges.     * @return A <code>ResultSet</code> with all the requested privileges.
1574     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1575     */     */
1576    public ResultSet getColumnPrivileges(String catalog, String schema, String    ResultSet getColumnPrivileges(String catalog, String schema, String
1577        table, String columnNamePattern) throws SQLException;        table, String columnNamePattern) throws SQLException;
1578    
1579    /**    /**
# Line 1604  public interface DatabaseMetaData Line 1604  public interface DatabaseMetaData
1604     * @return A <code>ResultSet</code> with all the requested privileges.     * @return A <code>ResultSet</code> with all the requested privileges.
1605     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1606     */     */
1607    public ResultSet getTablePrivileges(String catalog, String schemaPattern,    ResultSet getTablePrivileges(String catalog, String schemaPattern,
1608        String tableNamePattern) throws SQLException;        String tableNamePattern) throws SQLException;
1609    
1610    /**    /**
# Line 1642  public interface DatabaseMetaData Line 1642  public interface DatabaseMetaData
1642     * @return A <code>ResultSet</code> with the best row identifier.     * @return A <code>ResultSet</code> with the best row identifier.
1643     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1644     */     */
1645    public ResultSet getBestRowIdentifier(String catalog, String schema,    ResultSet getBestRowIdentifier(String catalog, String schema,
1646      String table, int scope, boolean nullable) throws SQLException;      String table, int scope, boolean nullable) throws SQLException;
1647    
1648    /**    /**
# Line 1675  public interface DatabaseMetaData Line 1675  public interface DatabaseMetaData
1675     * @return A <code>ResultSet</code> with the version columns.     * @return A <code>ResultSet</code> with the version columns.
1676     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1677     */     */
1678    public ResultSet getVersionColumns(String catalog, String schema,    ResultSet getVersionColumns(String catalog, String schema,
1679      String table) throws SQLException;      String table) throws SQLException;
1680    
1681    /**    /**
# Line 1701  public interface DatabaseMetaData Line 1701  public interface DatabaseMetaData
1701     * @return A <code>ResultSet</code> with the primary key columns.     * @return A <code>ResultSet</code> with the primary key columns.
1702     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1703     */     */
1704    public ResultSet getPrimaryKeys(String catalog, String schema, String table)    ResultSet getPrimaryKeys(String catalog, String schema, String table)
1705        throws SQLException;        throws SQLException;
1706    
1707    /**    /**
# Line 1746  public interface DatabaseMetaData Line 1746  public interface DatabaseMetaData
1746     *     *
1747     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1748     */     */
1749    public ResultSet getImportedKeys(String catalog, String schema,    ResultSet getImportedKeys(String catalog, String schema,
1750      String table) throws SQLException;      String table) throws SQLException;
1751    
1752    /**    /**
# Line 1790  public interface DatabaseMetaData Line 1790  public interface DatabaseMetaData
1790     * @return A <code>ResultSet</code> with the requested information     * @return A <code>ResultSet</code> with the requested information
1791     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1792     */     */
1793    public ResultSet getExportedKeys(String catalog, String schema,    ResultSet getExportedKeys(String catalog, String schema,
1794      String table) throws SQLException;      String table) throws SQLException;
1795    
1796    /**    /**
# Line 1842  public interface DatabaseMetaData Line 1842  public interface DatabaseMetaData
1842     * @return A <code>ResultSet</code> with the requested information     * @return A <code>ResultSet</code> with the requested information
1843     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1844     */     */
1845    public ResultSet getCrossReference(String primaryCatalog, String    ResultSet getCrossReference(String primaryCatalog, String
1846      primarySchema, String primaryTable, String foreignCatalog, String      primarySchema, String primaryTable, String foreignCatalog, String
1847      foreignSchema, String foreignTable) throws SQLException;      foreignSchema, String foreignTable) throws SQLException;
1848    
# Line 1885  public interface DatabaseMetaData Line 1885  public interface DatabaseMetaData
1885     * @return A <code>ResultSet</code> with the list of available data types.     * @return A <code>ResultSet</code> with the list of available data types.
1886     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1887     */     */
1888    public ResultSet getTypeInfo() throws SQLException;    ResultSet getTypeInfo() throws SQLException;
1889    
1890    /**    /**
1891     * This method returns information about a tables indices and statistics.     * This method returns information about a tables indices and statistics.
# Line 1929  public interface DatabaseMetaData Line 1929  public interface DatabaseMetaData
1929     * @return A <code>ResultSet</code> with the requested index information     * @return A <code>ResultSet</code> with the requested index information
1930     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1931     */     */
1932    public ResultSet getIndexInfo(String catalog, String schema, String table,    ResultSet getIndexInfo(String catalog, String schema, String table,
1933      boolean unique, boolean approximate) throws SQLException;      boolean unique, boolean approximate) throws SQLException;
1934    
1935    /**    /**
# Line 1946  public interface DatabaseMetaData Line 1946  public interface DatabaseMetaData
1946     *     *
1947     * @see ResultSet     * @see ResultSet
1948     */     */
1949    public boolean supportsResultSetType(int type) throws SQLException;    boolean supportsResultSetType(int type) throws SQLException;
1950    
1951    /**    /**
1952     * This method tests whether the specified result set type and result set     * This method tests whether the specified result set type and result set
# Line 1961  public interface DatabaseMetaData Line 1961  public interface DatabaseMetaData
1961     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1962     * @see ResultSet     * @see ResultSet
1963     */     */
1964    public boolean supportsResultSetConcurrency(int type, int concurrency)    boolean supportsResultSetConcurrency(int type, int concurrency)
1965        throws SQLException;        throws SQLException;
1966    
1967    /**    /**
# Line 1975  public interface DatabaseMetaData Line 1975  public interface DatabaseMetaData
1975     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1976     * @see ResultSet     * @see ResultSet
1977     */     */
1978    public boolean ownUpdatesAreVisible(int type) throws SQLException;    boolean ownUpdatesAreVisible(int type) throws SQLException;
1979    
1980   /**   /**
1981     * This method tests whether or not the specified result set type sees its     * This method tests whether or not the specified result set type sees its
# Line 1988  public interface DatabaseMetaData Line 1988  public interface DatabaseMetaData
1988     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
1989     * @see ResultSet     * @see ResultSet
1990     */     */
1991    public boolean ownDeletesAreVisible(int type) throws SQLException;    boolean ownDeletesAreVisible(int type) throws SQLException;
1992    
1993    /**    /**
1994     * This method tests whether or not the specified result set type sees its     * This method tests whether or not the specified result set type sees its
# Line 2001  public interface DatabaseMetaData Line 2001  public interface DatabaseMetaData
2001     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
2002     * @see ResultSet     * @see ResultSet
2003     */     */
2004    public boolean ownInsertsAreVisible(int type) throws SQLException;    boolean ownInsertsAreVisible(int type) throws SQLException;
2005    
2006    /**    /**
2007     * This method tests whether or not the specified result set type sees     * This method tests whether or not the specified result set type sees
# Line 2014  public interface DatabaseMetaData Line 2014  public interface DatabaseMetaData
2014     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
2015     * @see ResultSet     * @see ResultSet
2016     */     */
2017    public boolean othersUpdatesAreVisible(int type) throws SQLException;    boolean othersUpdatesAreVisible(int type) throws SQLException;
2018    
2019    /**    /**
2020     * This method tests whether or not the specified result set type sees     * This method tests whether or not the specified result set type sees
# Line 2027  public interface DatabaseMetaData Line 2027  public interface DatabaseMetaData
2027     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
2028     * @see ResultSet     * @see ResultSet
2029     */     */
2030    public boolean othersDeletesAreVisible(int type) throws SQLException;    boolean othersDeletesAreVisible(int type) throws SQLException;
2031    
2032    /**    /**
2033     * This method tests whether or not the specified result set type sees     * This method tests whether or not the specified result set type sees
# Line 2040  public interface DatabaseMetaData Line 2040  public interface DatabaseMetaData
2040     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
2041     * @see ResultSet     * @see ResultSet
2042     */     */
2043    public boolean othersInsertsAreVisible(int type) throws SQLException;    boolean othersInsertsAreVisible(int type) throws SQLException;
2044    
2045    /**    /**
2046     * This method tests whether or not the specified result set type can detect     * This method tests whether or not the specified result set type can detect
# Line 2053  public interface DatabaseMetaData Line 2053  public interface DatabaseMetaData
2053     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
2054     * @see ResultSet     * @see ResultSet
2055     */     */
2056    public boolean updatesAreDetected(int type) throws SQLException;    boolean updatesAreDetected(int type) throws SQLException;
2057    
2058    /**    /**
2059     * This method tests whether or not the specified result set type can detect     * This method tests whether or not the specified result set type can detect
# Line 2066  public interface DatabaseMetaData Line 2066  public interface DatabaseMetaData
2066     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
2067     * @see ResultSet     * @see ResultSet
2068     */     */
2069    public boolean deletesAreDetected(int type) throws SQLException;    boolean deletesAreDetected(int type) throws SQLException;
2070        
2071    /**    /**
2072     * This method tests whether or not the specified result set type can detect     * This method tests whether or not the specified result set type can detect
# Line 2079  public interface DatabaseMetaData Line 2079  public interface DatabaseMetaData
2079     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
2080     * @see ResultSet     * @see ResultSet
2081     */     */
2082    public boolean insertsAreDetected(int type) throws SQLException;    boolean insertsAreDetected(int type) throws SQLException;
2083    
2084    /**    /**
2085     * This method tests whether or not the database supports batch updates.     * This method tests whether or not the database supports batch updates.
# Line 2088  public interface DatabaseMetaData Line 2088  public interface DatabaseMetaData
2088     *         <code>false</code> otherwise.     *         <code>false</code> otherwise.
2089     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
2090     */     */
2091    public boolean supportsBatchUpdates() throws SQLException;    boolean supportsBatchUpdates() throws SQLException;
2092    
2093    /**    /**
2094     * This method returns the list of user defined data types in use.  These     * This method returns the list of user defined data types in use.  These
# Line 2116  public interface DatabaseMetaData Line 2116  public interface DatabaseMetaData
2116     * @return A <code>ResultSet</code> with the requested type information     * @return A <code>ResultSet</code> with the requested type information
2117     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
2118     */     */
2119    public ResultSet getUDTs(String catalog, String schemaPattern, String    ResultSet getUDTs(String catalog, String schemaPattern, String
2120        typeNamePattern, int[] types) throws SQLException;        typeNamePattern, int[] types) throws SQLException;
2121    
2122    /**    /**
# Line 2126  public interface DatabaseMetaData Line 2126  public interface DatabaseMetaData
2126     * @return The connection for this object.     * @return The connection for this object.
2127     * @exception SQLException If an error occurs.     * @exception SQLException If an error occurs.
2128     */     */
2129    public Connection getConnection() throws SQLException;    Connection getConnection() throws SQLException;
2130    
2131    /**    /**
2132     * @since 1.4     * @since 1.4
2133     */     */
2134    public boolean supportsSavepoints() throws SQLException;    boolean supportsSavepoints() throws SQLException;
2135    
2136    /**    /**
2137     * @since 1.4     * @since 1.4
2138     */     */
2139    public boolean supportsNamedParameters() throws SQLException;    boolean supportsNamedParameters() throws SQLException;
2140    
2141    /**    /**
2142     * @since 1.4     * @since 1.4
2143     */     */
2144    public boolean supportsMultipleOpenResults() throws SQLException;    boolean supportsMultipleOpenResults() throws SQLException;
2145    
2146    /**    /**
2147     * @since 1.4     * @since 1.4
2148     */     */
2149    public boolean supportsGetGeneratedKeys() throws SQLException;    boolean supportsGetGeneratedKeys() throws SQLException;
2150    
2151    /**    /**
2152     * @since 1.4     * @since 1.4
2153     */     */
2154    public ResultSet getSuperTypes(String catalog, String schemaPattern,    ResultSet getSuperTypes(String catalog, String schemaPattern,
2155      String typeNamePattern) throws SQLException;      String typeNamePattern) throws SQLException;
2156    
2157    /**    /**
2158     * @since 1.4     * @since 1.4
2159     */     */
2160    public ResultSet getSuperTables(String catalog, String schemaPattern,    ResultSet getSuperTables(String catalog, String schemaPattern,
2161      String tableNamePattern) throws SQLException;      String tableNamePattern) throws SQLException;
2162    
2163    /**    /**
2164     * @since 1.4     * @since 1.4
2165     */     */
2166    public ResultSet getAttributes(String catalog, String schemaPattern, String    ResultSet getAttributes(String catalog, String schemaPattern, String
2167      typeNamePattern, String attributeNamePattern) throws SQLException;      typeNamePattern, String attributeNamePattern) throws SQLException;
2168    
2169    /**    /**
2170     * @since 1.4     * @since 1.4
2171     */     */
2172    public boolean supportsResultSetHoldability(int holdability)    boolean supportsResultSetHoldability(int holdability)
2173      throws SQLException;      throws SQLException;
2174    
2175    /**    /**
2176     * @since 1.4     * @since 1.4
2177     */     */
2178    public int getResultSetHoldability() throws SQLException;    int getResultSetHoldability() throws SQLException;
2179    
2180    /**    /**
2181     * @since 1.4     * @since 1.4
2182     */     */
2183    public int getDatabaseMajorVersion() throws SQLException;    int getDatabaseMajorVersion() throws SQLException;
2184    
2185    /**    /**
2186     * @since 1.4     * @since 1.4
2187     */     */
2188    public int getDatabaseMinorVersion() throws SQLException;    int getDatabaseMinorVersion() throws SQLException;
2189    
2190    /**    /**
2191     * @since 1.4     * @since 1.4
2192     */     */
2193    public int getJDBCMajorVersion() throws SQLException;    int getJDBCMajorVersion() throws SQLException;
2194    
2195    /**    /**
2196     * @since 1.4     * @since 1.4
2197     */     */
2198    public int getJDBCMinorVersion() throws SQLException;    int getJDBCMinorVersion() throws SQLException;
2199    
2200    /**    /**
2201     * @since 1.4     * @since 1.4
2202     */     */
2203    public int getSQLStateType() throws SQLException;    int getSQLStateType() throws SQLException;
2204    
2205    /**    /**
2206     * @since 1.4     * @since 1.4
2207     */     */
2208    public boolean locatorsUpdateCopy() throws SQLException;    boolean locatorsUpdateCopy() throws SQLException;
2209    
2210    /**    /**
2211     * @since 1.4     * @since 1.4
2212     */     */
2213    public boolean supportsStatementPooling() throws SQLException;    boolean supportsStatementPooling() throws SQLException;
2214  }  }

Legend:
Removed from v.1.10  
changed lines
  Added in v.1.11

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26