001 /*
002 * JBoss DNA (http://www.jboss.org/dna)
003 * See the COPYRIGHT.txt file distributed with this work for information
004 * regarding copyright ownership. Some portions may be licensed
005 * to Red Hat, Inc. under one or more contributor license agreements.
006 * See the AUTHORS.txt file in the distribution for a full listing of
007 * individual contributors.
008 *
009 * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
010 * is licensed to you under the terms of the GNU Lesser General Public License as
011 * published by the Free Software Foundation; either version 2.1 of
012 * the License, or (at your option) any later version.
013 *
014 * JBoss DNA is distributed in the hope that it will be useful,
015 * but WITHOUT ANY WARRANTY; without even the implied warranty of
016 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
017 * Lesser General Public License for more details.
018 *
019 * You should have received a copy of the GNU Lesser General Public
020 * License along with this software; if not, write to the Free
021 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
022 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
023 */
024 package org.jboss.dna.common.jdbc.model.api;
025
026 import java.util.List;
027 import java.util.Set;
028
029 /**
030 * Provides RDBMS wide meta data retrieved from java.sql.DatabaseMetaData.
031 *
032 * @author <a href="mailto:litsenko_sergey@yahoo.com">Sergiy Litsenko</a>
033 */
034 public interface Database extends CoreMetaData {
035
036 /**
037 * Returns list of failed database metadata methods through the DatabaseMetaDataMethodExceptions
038 *
039 * @return list of failed database metadata methods through the DatabaseMetaDataMethodExceptions
040 */
041 List<DatabaseMetaDataMethodException> getExceptionList();
042
043 /**
044 * Adds the DatabaseMetaDataMethodException to the DatabaseMetadataProvider exception list
045 *
046 * @param exception the DatabaseMetaDataMethodException
047 */
048 void addException( DatabaseMetaDataMethodException exception );
049
050 /**
051 * Searches the DatabaseMetaDataMethodException by method name
052 *
053 * @param methodName the name of method that caused exception
054 * @return the DatabaseMetaDataMethodException if found, otherwise returns null
055 */
056 DatabaseMetaDataMethodException findException( String methodName );
057
058 /**
059 * Checks that specified database metadata method of provider is failed or not
060 *
061 * @param methodName the name of method that caused exception
062 * @return true if method failed; false otherwise
063 */
064 boolean isDatabaseMetaDataMethodFailed( String methodName );
065
066 /**
067 * Gets database name
068 *
069 * @return database name
070 */
071 String getName();
072
073 /**
074 * Sets database name
075 *
076 * @param name the database name
077 */
078 void setName( String name );
079
080 // ----------------------------------------------------------------------
081 // A variety of minor information about the target database.
082 // ----------------------------------------------------------------------
083
084 /**
085 * Retrieves whether the current user can call all the procedures returned by the method
086 * <code>DatabaseMetaData.getProcedures</code>.
087 *
088 * @return <code>true</code> if so; <code>false</code> otherwise
089 */
090 Boolean isAllProceduresAreCallable();
091
092 /**
093 * sets whether the current user can call all the procedures returned by the method
094 * <code>DatabaseMetaData.getProcedures</code>.
095 *
096 * @param allProceduresAreCallable <code>true</code> if so; <code>false</code> otherwise
097 */
098 void setAllProceduresAreCallable( Boolean allProceduresAreCallable );
099
100 /**
101 * Retrieves whether the current user can use all the tables returned by the method <code>DatabaseMetaData.getTables</code> in
102 * a <code>SELECT</code> statement.
103 *
104 * @return <code>true</code> if so; <code>false</code> otherwise
105 */
106 Boolean isAllTablesAreSelectable();
107
108 /**
109 * Sets whether the current user can use all the tables returned by the method <code>DatabaseMetaData.getTables</code> in a
110 * <code>SELECT</code> statement.
111 *
112 * @param allTablesAreSelectable <code>true</code> if so; <code>false</code> otherwise
113 */
114 void setAllTablesAreSelectable( Boolean allTablesAreSelectable );
115
116 /**
117 * Retrieves the URL for this DBMS.
118 *
119 * @return the URL for this DBMS or <code>null</code> if it cannot be generated
120 */
121 String getURL();
122
123 /**
124 * Sets the URL for this DBMS.
125 *
126 * @param url the URL for this DBMS or <code>null</code> if it cannot be generated
127 */
128 void setURL( String url );
129
130 /**
131 * Retrieves the user name as known to this database.
132 *
133 * @return the database user name
134 */
135 String getUserName();
136
137 /**
138 * Sets the user name as known to this database.
139 *
140 * @param userName the database user name
141 */
142 void setUserName( String userName );
143
144 /**
145 * Retrieves whether this database is in read-only mode.
146 *
147 * @return <code>true</code> if so; <code>false</code> otherwise
148 */
149 Boolean isReadOnly();
150
151 /**
152 * Sets whether this database is in read-only mode.
153 *
154 * @param readOnly <code>true</code> if so; <code>false</code> otherwise
155 */
156 void setReadOnly( Boolean readOnly );
157
158 /**
159 * Retrieves whether <code>NULL</code> values are sorted high. Sorted high means that <code>NULL</code> values sort higher
160 * than any other value in a domain. In an ascending order, if this method returns <code>true</code>, <code>NULL</code> values
161 * will appear at the end. By contrast, the method <code>DatabaseMetaData.nullsAreSortedAtEnd</code> indicates whether
162 * <code>NULL</code> values are sorted at the end regardless of sort order.
163 *
164 * @return <code>true</code> if so; <code>false</code> otherwise
165 */
166 Boolean isNullsAreSortedHigh();
167
168 /**
169 * Sets whether <code>NULL</code> values are sorted high. Sorted high means that <code>NULL</code> values sort higher than any
170 * other value in a domain. In an ascending order, if this method returns <code>true</code>, <code>NULL</code> values will
171 * appear at the end. By contrast, the method <code>DatabaseMetaData.nullsAreSortedAtEnd</code> indicates whether
172 * <code>NULL</code> values are sorted at the end regardless of sort order.
173 *
174 * @param nullsAreSortedHigh <code>true</code> if so; <code>false</code> otherwise
175 */
176 void setNullsAreSortedHigh( Boolean nullsAreSortedHigh );
177
178 /**
179 * Retrieves whether <code>NULL</code> values are sorted low. Sorted low means that <code>NULL</code> values sort lower than
180 * any other value in a domain. In an ascending order, if this method returns <code>true</code>, <code>NULL</code> values will
181 * appear at the beginning. By contrast, the method <code>DatabaseMetaData.nullsAreSortedAtStart</code> indicates whether
182 * <code>NULL</code> values are sorted at the beginning regardless of sort order.
183 *
184 * @return <code>true</code> if so; <code>false</code> otherwise
185 */
186 Boolean isNullsAreSortedLow();
187
188 /**
189 * Sets whether <code>NULL</code> values are sorted low. Sorted low means that <code>NULL</code> values sort lower than any
190 * other value in a domain. In an ascending order, if this method returns <code>true</code>, <code>NULL</code> values will
191 * appear at the beginning. By contrast, the method <code>DatabaseMetaData.nullsAreSortedAtStart</code> indicates whether
192 * <code>NULL</code> values are sorted at the beginning regardless of sort order.
193 *
194 * @param nullsAreSortedLow <code>true</code> if so; <code>false</code> otherwise
195 */
196 void setNullsAreSortedLow( Boolean nullsAreSortedLow );
197
198 /**
199 * Retrieves whether <code>NULL</code> values are sorted at the start regardless of sort order.
200 *
201 * @return <code>true</code> if so; <code>false</code> otherwise
202 */
203 Boolean isNullsAreSortedAtStart();
204
205 /**
206 * Sets whether <code>NULL</code> values are sorted at the start regardless of sort order.
207 *
208 * @param nullsAreSortedAtStart <code>true</code> if so; <code>false</code> otherwise
209 */
210 void setNullsAreSortedAtStart( Boolean nullsAreSortedAtStart );
211
212 /**
213 * Retrieves whether <code>NULL</code> values are sorted at the end regardless of sort order.
214 *
215 * @return <code>true</code> if so; <code>false</code> otherwise
216 */
217 Boolean isNullsAreSortedAtEnd();
218
219 /**
220 * Sets whether <code>NULL</code> values are sorted at the end regardless of sort order.
221 *
222 * @param nullsAreSortedAtEnd <code>true</code> if so; <code>false</code> otherwise
223 */
224 void setNullsAreSortedAtEnd( Boolean nullsAreSortedAtEnd );
225
226 /**
227 * Retrieves the name of this database product.
228 *
229 * @return database product name
230 */
231 String getDatabaseProductName();
232
233 /**
234 * Sets the name of this database product.
235 *
236 * @param databaseProductName database product name
237 */
238 void setDatabaseProductName( String databaseProductName );
239
240 /**
241 * Retrieves the version number of this database product.
242 *
243 * @return database version number
244 */
245 String getDatabaseProductVersion();
246
247 /**
248 * Sets the version number of this database product.
249 *
250 * @param databaseProductVersion database version number
251 */
252 void setDatabaseProductVersion( String databaseProductVersion );
253
254 /**
255 * Retrieves the name of this JDBC driver.
256 *
257 * @return JDBC driver name
258 */
259 String getDriverName();
260
261 /**
262 * Sets the name of this JDBC driver.
263 *
264 * @param driverName JDBC driver name
265 */
266 void setDriverName( String driverName );
267
268 /**
269 * Retrieves the version number of this JDBC driver as a <code>String</code>.
270 *
271 * @return JDBC driver version
272 */
273 String getDriverVersion();
274
275 /**
276 * Sets the version number of this JDBC driver as a <code>String</code>.
277 *
278 * @param driverVersion the JDBC driver version
279 */
280 void setDriverVersion( String driverVersion );
281
282 /**
283 * Retrieves this JDBC driver's minor version number.
284 *
285 * @return JDBC driver minor version number
286 */
287 Integer getDriverMajorVersion();
288
289 /**
290 * Sets this JDBC driver's major version number.
291 *
292 * @param driverMajorVersion the JDBC driver major version
293 */
294 void setDriverMajorVersion( Integer driverMajorVersion );
295
296 /**
297 * Retrieves this JDBC driver's minor version number.
298 *
299 * @return JDBC driver minor version number
300 */
301 Integer getDriverMinorVersion();
302
303 /**
304 * Sets this JDBC driver's minor version number.
305 *
306 * @param driverMinorVersion the JDBC driver minor version number
307 */
308 void setDriverMinorVersion( Integer driverMinorVersion );
309
310 /**
311 * Retrieves whether this database stores tables in a local file.
312 *
313 * @return <code>true</code> if so; <code>false</code> otherwise
314 */
315 Boolean isUsesLocalFiles();
316
317 /**
318 * Sets whether this database stores tables in a local file.
319 *
320 * @param usesLocalFiles <code>true</code> if so; <code>false</code> otherwise
321 */
322 void setUsesLocalFiles( Boolean usesLocalFiles );
323
324 /**
325 * Retrieves whether this database uses a file for each table.
326 *
327 * @return <code>true</code> if this database uses a local file for each table; <code>false</code> otherwise
328 */
329 Boolean isUsesLocalFilePerTable();
330
331 /**
332 * Sets whether this database uses a file for each table.
333 *
334 * @param usesLocalFilePerTable <code>true</code> if this database uses a local file for each table; <code>false</code>
335 * otherwise
336 */
337 void setUsesLocalFilePerTable( Boolean usesLocalFilePerTable );
338
339 /**
340 * Retrieves whether this database treats mixed case unquoted SQL identifiers as case sensitive and as a result stores them in
341 * mixed case.
342 *
343 * @return <code>true</code> if so; <code>false</code> otherwise
344 */
345 Boolean isSupportsMixedCaseIdentifiers();
346
347 /**
348 * Sets whether this database treats mixed case unquoted SQL identifiers as case sensitive and as a result stores them in
349 * mixed case.
350 *
351 * @param supportsMixedCaseIdentifiers <code>true</code> if so; <code>false</code> otherwise
352 */
353 void setSupportsMixedCaseIdentifiers( Boolean supportsMixedCaseIdentifiers );
354
355 /**
356 * Retrieves whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in upper
357 * case.
358 *
359 * @return <code>true</code> if so; <code>false</code> otherwise
360 */
361 Boolean isStoresUpperCaseIdentifiers();
362
363 /**
364 * Sets whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in upper case.
365 *
366 * @param storesUpperCaseIdentifiers <code>true</code> if so; <code>false</code> otherwise
367 */
368 void setStoresUpperCaseIdentifiers( Boolean storesUpperCaseIdentifiers );
369
370 /**
371 * Retrieves whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in lower
372 * case.
373 *
374 * @return <code>true</code> if so; <code>false</code> otherwise
375 */
376 Boolean isStoresLowerCaseIdentifiers();
377
378 /**
379 * sets whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in lower case.
380 *
381 * @param storesLowerCaseIdentifiers <code>true</code> if so; <code>false</code> otherwise
382 */
383 void setStoresLowerCaseIdentifiers( Boolean storesLowerCaseIdentifiers );
384
385 /**
386 * Retrieves whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in mixed
387 * case.
388 *
389 * @return <code>true</code> if so; <code>false</code> otherwise
390 */
391 Boolean isStoresMixedCaseIdentifiers();
392
393 /**
394 * Sets whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in mixed case.
395 *
396 * @param storesMixedCaseIdentifiers <code>true</code> if so; <code>false</code> otherwise
397 */
398 void setStoresMixedCaseIdentifiers( Boolean storesMixedCaseIdentifiers );
399
400 /**
401 * Retrieves whether this database treats mixed case quoted SQL identifiers as case sensitive and as a result stores them in
402 * mixed case.
403 *
404 * @return <code>true</code> if so; <code>false</code> otherwise
405 */
406 Boolean isSupportsMixedCaseQuotedIdentifiers();
407
408 /**
409 * Sets whether this database treats mixed case quoted SQL identifiers as case sensitive and as a result stores them in mixed
410 * case.
411 *
412 * @param supportsMixedCaseQuotedIdentifiers <code>true</code> if so; <code>false</code> otherwise
413 */
414 void setSupportsMixedCaseQuotedIdentifiers( Boolean supportsMixedCaseQuotedIdentifiers );
415
416 /**
417 * Retrieves whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in upper case.
418 *
419 * @return <code>true</code> if so; <code>false</code> otherwise
420 */
421 Boolean isStoresUpperCaseQuotedIdentifiers();
422
423 /**
424 * Sets whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in upper case.
425 *
426 * @param storesUpperCaseQuotedIdentifiers <code>true</code> if so; <code>false</code> otherwise
427 */
428 void setStoresUpperCaseQuotedIdentifiers( Boolean storesUpperCaseQuotedIdentifiers );
429
430 /**
431 * Retrieves whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in lower case.
432 *
433 * @return <code>true</code> if so; <code>false</code> otherwise
434 */
435 Boolean isStoresLowerCaseQuotedIdentifiers();
436
437 /**
438 * Sets whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in lower case.
439 *
440 * @param storesLowerCaseQuotedIdentifiers <code>true</code> if so; <code>false</code> otherwise
441 */
442 void setStoresLowerCaseQuotedIdentifiers( Boolean storesLowerCaseQuotedIdentifiers );
443
444 /**
445 * Retrieves whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in mixed case.
446 *
447 * @return <code>true</code> if so; <code>false</code> otherwise
448 */
449 Boolean isStoresMixedCaseQuotedIdentifiers();
450
451 /**
452 * Sets whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in mixed case.
453 *
454 * @param storesMixedCaseQuotedIdentifiers <code>true</code> if so; <code>false</code> otherwise
455 */
456 void setStoresMixedCaseQuotedIdentifiers( Boolean storesMixedCaseQuotedIdentifiers );
457
458 /**
459 * Retrieves the string used to quote SQL identifiers. This method returns a space " " if identifier quoting is not supported.
460 *
461 * @return the quoting string or a space if quoting is not supported
462 */
463 String getIdentifierQuoteString();
464
465 /**
466 * Sets the string used to quote SQL identifiers. This method returns a space " " if identifier quoting is not supported.
467 *
468 * @param identifierQuoteString the quoting string or a space if quoting is not supported
469 */
470 void setIdentifierQuoteString( String identifierQuoteString );
471
472 /**
473 * Retrieves a list of all of this database's SQL keywords that are NOT also SQL92 keywords.
474 *
475 * @return the list of this database's keywords that are not also SQL92 keywords
476 */
477 Set<String> getSQLKeywords();
478
479 /**
480 * Adds SQL keyword
481 *
482 * @param sqlKeyword the SQL keyword to add
483 */
484 void addSQLKeyword( String sqlKeyword );
485
486 /**
487 * Deletes SQL keyword
488 *
489 * @param sqlKeyword the SQL keyword to delete
490 */
491 void deleteSQLKeyword( String sqlKeyword );
492
493 /**
494 * Is SQL keyword supported
495 *
496 * @param sqlKeyword the SQL keyword to search
497 * @return true if supported; false otherwiose
498 */
499 Boolean isSQLKeywordSupported( String sqlKeyword );
500
501 /**
502 * Retrieves a list of math functions available with this database. These are the Open /Open CLI math function names used in
503 * the JDBC function escape clause.
504 *
505 * @return the list of math functions supported by this database
506 */
507 Set<String> getNumericFunctions();
508
509 /**
510 * Adds numeric function
511 *
512 * @param functionName the name of numeric function to add
513 */
514 void addNumericFunction( String functionName );
515
516 /**
517 * Deletes numeric function
518 *
519 * @param functionName the name of numeric function to delete
520 */
521 void deleteNumericFunction( String functionName );
522
523 /**
524 * Is Numeric function supported
525 *
526 * @param functionName the name of numeric function
527 * @return true is supported; false otherwise
528 */
529 Boolean isNumericFunctionSupported( String functionName );
530
531 /**
532 * Retrieves a list of string functions available with this database. These are the Open Group CLI string function names used
533 * in the JDBC function escape clause.
534 *
535 * @return the list of string functions supported by this database
536 */
537 Set<String> getStringFunctions();
538
539 /**
540 * Adds String function
541 *
542 * @param functionName the name of String function to add
543 */
544 void addStringFunction( String functionName );
545
546 /**
547 * Deletes String function
548 *
549 * @param functionName the name of String function to delete
550 */
551 void deleteStringFunction( String functionName );
552
553 /**
554 * Is String function supported
555 *
556 * @param functionName the name of String function
557 * @return true is supported; false otherwise
558 */
559 Boolean isStringFunctionSupported( String functionName );
560
561 /**
562 * Retrieves a list of system functions available with this database. These are the Open Group CLI system function names used
563 * in the JDBC function escape clause.
564 *
565 * @return a list of system functions supported by this database
566 */
567 Set<String> getSystemFunctions();
568
569 /**
570 * Adds System function
571 *
572 * @param functionName the name of System function to add
573 */
574 void addSystemFunction( String functionName );
575
576 /**
577 * deletes System function
578 *
579 * @param functionName the name of System function to delete
580 */
581 void deleteSystemFunction( String functionName );
582
583 /**
584 * Is System function supported
585 *
586 * @param functionName the name of System function
587 * @return true is supported; false otherwise
588 */
589 Boolean isSystemFunctionSupported( String functionName );
590
591 /**
592 * Retrieves a list of the time and date functions available with this database.
593 *
594 * @return the list of time and date functions supported by this database
595 */
596 Set<String> getTimeDateFunctions();
597
598 /**
599 * Adds Time/Date function
600 *
601 * @param functionName the name of Time/Date function to add
602 */
603 void addTimeDateFunction( String functionName );
604
605 /**
606 * deletes Time/Date function
607 *
608 * @param functionName the name of Time/Date function to delete
609 */
610 void deleteTimeDateFunction( String functionName );
611
612 /**
613 * Is Time/Date function supported
614 *
615 * @param functionName the name of Time/Date function
616 * @return true is supported; false otherwise
617 */
618 Boolean isTimeDateFunctionSupported( String functionName );
619
620 /**
621 * Retrieves the string that can be used to escape wildcard characters. This is the string that can be used to escape '_' or
622 * '%' in the catalog search parameters that are a pattern (and therefore use one of the wildcard characters).
623 * <P>
624 * The '_' character represents any single character; the '%' character represents any sequence of zero or more characters.
625 *
626 * @return the string used to escape wildcard characters
627 */
628 String getSearchStringEscape();
629
630 /**
631 * Sets the string that can be used to escape wildcard characters. This is the string that can be used to escape '_' or '%' in
632 * the catalog search parameters that are a pattern (and therefore use one of the wildcard characters).
633 * <P>
634 * The '_' character represents any single character; the '%' character represents any sequence of zero or more characters.
635 *
636 * @param searchStringEscape the string used to escape wildcard characters
637 */
638 void setSearchStringEscape( String searchStringEscape );
639
640 /**
641 * Retrieves all the "extra" characters that can be used in unquoted identifier names (those beyond a-z, A-Z, 0-9 and _).
642 *
643 * @return the string containing the extra characters
644 */
645 String getExtraNameCharacters();
646
647 /**
648 * Sets all the "extra" characters that can be used in unquoted identifier names (those beyond a-z, A-Z, 0-9 and _).
649 *
650 * @param extraNameCharacters the string containing the extra characters
651 */
652 void setExtraNameCharacters( String extraNameCharacters );
653
654 // --------------------------------------------------------------------
655 // Functions describing which features are supported.
656 // --------------------------------------------------------------------
657
658 /**
659 * Retrieves whether this database supports <code>ALTER TABLE</code> with add column.
660 *
661 * @return <code>true</code> if so; <code>false</code> otherwise
662 */
663 Boolean isSupportsAlterTableWithAddColumn();
664
665 /**
666 * Sets whether this database supports <code>ALTER TABLE</code> with add column.
667 *
668 * @param supportsAlterTableWithAddColumn <code>true</code> if so; <code>false</code> otherwise
669 */
670 void setSupportsAlterTableWithAddColumn( Boolean supportsAlterTableWithAddColumn );
671
672 /**
673 * Retrieves whether this database supports <code>ALTER TABLE</code> with drop column.
674 *
675 * @return <code>true</code> if so; <code>false</code> otherwise
676 */
677 Boolean isSupportsAlterTableWithDropColumn();
678
679 /**
680 * Sets whether this database supports <code>ALTER TABLE</code> with drop column.
681 *
682 * @param supportsAlterTableWithDropColumn <code>true</code> if so; <code>false</code> otherwise
683 */
684 void setSupportsAlterTableWithDropColumn( Boolean supportsAlterTableWithDropColumn );
685
686 /**
687 * Retrieves whether this database supports column aliasing.
688 * <P>
689 * If so, the SQL AS clause can be used to provide names for computed columns or to provide alias names for columns as
690 * required.
691 *
692 * @return <code>true</code> if so; <code>false</code> otherwise
693 */
694 Boolean isSupportsColumnAliasing();
695
696 /**
697 * Sets whether this database supports column aliasing.
698 * <P>
699 * If so, the SQL AS clause can be used to provide names for computed columns or to provide alias names for columns as
700 * required.
701 *
702 * @param supportsColumnAliasing <code>true</code> if so; <code>false</code> otherwise
703 */
704 void setSupportsColumnAliasing( Boolean supportsColumnAliasing );
705
706 /**
707 * Retrieves whether this database supports concatenations between <code>NULL</code> and non-<code>NULL</code> values being
708 * <code>NULL</code>.
709 *
710 * @return <code>true</code> if so; <code>false</code> otherwise
711 */
712 Boolean isNullPlusNonNullIsNull();
713
714 /**
715 * Sets whether this database supports concatenations between <code>NULL</code> and non-<code>NULL</code> values being
716 * <code>NULL</code>.
717 * @param nullPlusNonNullIsNull <code>true</code> if so; <code>false</code> otherwise
718 *
719 */
720 void setNullPlusNonNullIsNull( Boolean nullPlusNonNullIsNull );
721
722 /**
723 * Retrieves whether this database supports the <code>CONVERT</code> function between SQL types.
724 *
725 * @return <code>true</code> if so; <code>false</code> otherwise
726 */
727 Boolean isSupportsConvert();
728
729 /**
730 * Sets whether this database supports the <code>CONVERT</code> function between SQL types.
731 *
732 * @param supportsConvert <code>true</code> if so; <code>false</code> otherwise
733 */
734 void setSupportsConvert( Boolean supportsConvert );
735
736 /**
737 * Retrieves whether this database supports the <code>CONVERT</code> for given SQL types. It uses original
738 * <code>DatabaseMetaData.supportsConvert</code> to check common (NOT ALL POSSIBLE) conversions.
739 *
740 * @return list of common (NOT ALL POSSIBLE) conversions.
741 * @see java.sql.Types
742 */
743 Set<SqlTypeConversionPair> getSupportedConversions();
744
745 /**
746 * Adds SqlTypeConversionPair
747 *
748 * @param sqlTypeConversionPair the SqlTypeConversionPair
749 */
750 void addSqlTypeConversionPair( SqlTypeConversionPair sqlTypeConversionPair );
751
752 /**
753 * deletes SqlTypeConversionPair
754 *
755 * @param sqlTypeConversionPair the SqlTypeConversionPair
756 */
757 void deleteSqlTypeConversionPair( SqlTypeConversionPair sqlTypeConversionPair );
758
759 /**
760 * Searches set of SqlTypeConversionPair by SrcType
761 * @param srcType the source type
762 *
763 * @return set of SqlTypeConversionPair
764 */
765 Set<SqlTypeConversionPair> findSqlTypeConversionPairBySrcType( String srcType );
766
767 /**
768 * Retrieves whether this database supports table correlation names.
769 *
770 * @return <code>true</code> if so; <code>false</code> otherwise
771 */
772 Boolean isSupportsTableCorrelationNames();
773
774 /**
775 * Sets whether this database supports table correlation names.
776 *
777 * @param supportsTableCorrelationNames <code>true</code> if so; <code>false</code> otherwise
778 */
779 void setSupportsTableCorrelationNames( Boolean supportsTableCorrelationNames );
780
781 /**
782 * Retrieves whether, when table correlation names are supported, they are restricted to being different from the names of the
783 * tables.
784 *
785 * @return <code>true</code> if so; <code>false</code> otherwise
786 */
787 Boolean isSupportsDifferentTableCorrelationNames();
788
789 /**
790 * Sets whether, when table correlation names are supported, they are restricted to being different from the names of the
791 * tables.
792 *
793 * @param supportsDifferentTableCorrelationNames <code>true</code> if so; <code>false</code> otherwise
794 */
795 void setSupportsDifferentTableCorrelationNames( Boolean supportsDifferentTableCorrelationNames );
796
797 /**
798 * Retrieves whether this database supports expressions in <code>ORDER BY</code> lists.
799 *
800 * @return <code>true</code> if so; <code>false</code> otherwise
801 */
802 Boolean isSupportsExpressionsInOrderBy();
803
804 /**
805 * Sets whether this database supports expressions in <code>ORDER BY</code> lists.
806 *
807 * @param supportsExpressionsInOrderBy <code>true</code> if so; <code>false</code> otherwise
808 */
809 void setSupportsExpressionsInOrderBy( Boolean supportsExpressionsInOrderBy );
810
811 /**
812 * Retrieves whether this database supports using a column that is not in the <code>SELECT</code> statement in an
813 * <code>ORDER BY</code> clause.
814 *
815 * @return <code>true</code> if so; <code>false</code> otherwise
816 */
817 Boolean isSupportsOrderByUnrelated();
818
819 /**
820 * Sets whether this database supports using a column that is not in the <code>SELECT</code> statement in an
821 * <code>ORDER BY</code> clause.
822 *
823 * @param supportsOrderByUnrelated <code>true</code> if so; <code>false</code> otherwise
824 */
825 void setSupportsOrderByUnrelated( Boolean supportsOrderByUnrelated );
826
827 /**
828 * Retrieves whether this database supports some form of <code>GROUP BY</code> clause.
829 *
830 * @return <code>true</code> if so; <code>false</code> otherwise
831 */
832 Boolean isSupportsGroupBy();
833
834 /**
835 * Sets whether this database supports some form of <code>GROUP BY</code> clause.
836 *
837 * @param supportsGroupBy <code>true</code> if so; <code>false</code> otherwise
838 */
839 void setSupportsGroupBy( Boolean supportsGroupBy );
840
841 /**
842 * Retrieves whether this database supports using a column that is not in the <code>SELECT</code> statement in a
843 * <code>GROUP BY</code> clause.
844 *
845 * @return <code>true</code> if so; <code>false</code> otherwise
846 */
847 Boolean isSupportsGroupByUnrelated();
848
849 /**
850 * Sets whether this database supports using a column that is not in the <code>SELECT</code> statement in a
851 * <code>GROUP BY</code> clause.
852 *
853 * @param supportsGroupByUnrelated <code>true</code> if so; <code>false</code> otherwise
854 */
855 void setSupportsGroupByUnrelated( Boolean supportsGroupByUnrelated );
856
857 /**
858 * Retrieves whether this database supports using columns not included in the <code>SELECT</code> statement in a
859 * <code>GROUP BY</code> clause provided that all of the columns in the <code>SELECT</code> statement are included in the
860 * <code>GROUP BY</code> clause.
861 *
862 * @return <code>true</code> if so; <code>false</code> otherwise
863 */
864 Boolean isSupportsGroupByBeyondSelect();
865
866 /**
867 * Sets whether this database supports using columns not included in the <code>SELECT</code> statement in a
868 * <code>GROUP BY</code> clause provided that all of the columns in the <code>SELECT</code> statement are included in the
869 * <code>GROUP BY</code> clause.
870 *
871 * @param supportsGroupByBeyondSelect <code>true</code> if so; <code>false</code> otherwise
872 */
873 void setSupportsGroupByBeyondSelect( Boolean supportsGroupByBeyondSelect );
874
875 /**
876 * Retrieves whether this database supports specifying a <code>LIKE</code> escape clause.
877 *
878 * @return <code>true</code> if so; <code>false</code> otherwise
879 */
880 Boolean isSupportsLikeEscapeClause();
881
882 /**
883 * Sets whether this database supports specifying a <code>LIKE</code> escape clause.
884 *
885 * @param supportsLikeEscapeClause <code>true</code> if so; <code>false</code> otherwise
886 */
887 void setSupportsLikeEscapeClause( Boolean supportsLikeEscapeClause );
888
889 /**
890 * Retrieves whether this database supports getting multiple <code>ResultSet</code> objects from a single call to the method
891 * <code>execute</code>.
892 *
893 * @return <code>true</code> if so; <code>false</code> otherwise
894 */
895 Boolean isSupportsMultipleResultSets();
896
897 /**
898 * Sets whether this database supports getting multiple <code>ResultSet</code> objects from a single call to the method
899 * <code>execute</code>.
900 *
901 * @param supportsMultipleResultSets <code>true</code> if so; <code>false</code> otherwise
902 */
903 void setSupportsMultipleResultSets( Boolean supportsMultipleResultSets );
904
905 /**
906 * Retrieves whether this database allows having multiple transactions open at once (on different connections).
907 *
908 * @return <code>true</code> if so; <code>false</code> otherwise
909 */
910 Boolean isSupportsMultipleTransactions();
911
912 /**
913 * Sets whether this database allows having multiple transactions open at once (on different connections).
914 *
915 * @param supportsMultipleTransactions <code>true</code> if so; <code>false</code> otherwise
916 */
917 void setSupportsMultipleTransactions( Boolean supportsMultipleTransactions );
918
919 /**
920 * Retrieves whether columns in this database may be defined as non-nullable.
921 *
922 * @return <code>true</code> if so; <code>false</code> otherwise
923 */
924 Boolean isSupportsNonNullableColumns();
925
926 /**
927 * Sets whether columns in this database may be defined as non-nullable.
928 *
929 * @param supportsNonNullableColumns <code>true</code> if so; <code>false</code> otherwise
930 */
931 void setSupportsNonNullableColumns( Boolean supportsNonNullableColumns );
932
933 /**
934 * Retrieves whether this database supports the ODBC Minimum SQL grammar.
935 *
936 * @return <code>true</code> if so; <code>false</code> otherwise
937 */
938 Boolean isSupportsMinimumSQLGrammar();
939
940 /**
941 * Sets whether this database supports the ODBC Minimum SQL grammar.
942 *
943 * @param supportsMinimumSQLGrammar <code>true</code> if so; <code>false</code> otherwise
944 */
945 void setSupportsMinimumSQLGrammar( Boolean supportsMinimumSQLGrammar );
946
947 /**
948 * Retrieves whether this database supports the ODBC Core SQL grammar.
949 *
950 * @return <code>true</code> if so; <code>false</code> otherwise
951 */
952 Boolean isSupportsCoreSQLGrammar();
953
954 /**
955 * Sets whether this database supports the ODBC Core SQL grammar.
956 *
957 * @param supportsCoreSQLGrammar <code>true</code> if so; <code>false</code> otherwise
958 */
959 void setSupportsCoreSQLGrammar( Boolean supportsCoreSQLGrammar );
960
961 /**
962 * Retrieves whether this database supports the ODBC Extended SQL grammar.
963 *
964 * @return <code>true</code> if so; <code>false</code> otherwise
965 */
966 Boolean isSupportsExtendedSQLGrammar();
967
968 /**
969 * Sets whether this database supports the ODBC Extended SQL grammar.
970 *
971 * @param supportsExtendedSQLGrammar <code>true</code> if so; <code>false</code> otherwise
972 */
973 void setSupportsExtendedSQLGrammar( Boolean supportsExtendedSQLGrammar );
974
975 /**
976 * Retrieves whether this database supports the ANSI92 entry level SQL grammar.
977 *
978 * @return <code>true</code> if so; <code>false</code> otherwise
979 */
980 Boolean isSupportsANSI92EntryLevelSQL();
981
982 /**
983 * Sets whether this database supports the ANSI92 entry level SQL grammar.
984 *
985 * @param supportsANSI92EntryLevelSQL <code>true</code> if so; <code>false</code> otherwise
986 */
987 void setSupportsANSI92EntryLevelSQL( Boolean supportsANSI92EntryLevelSQL );
988
989 /**
990 * Retrieves whether this database supports the ANSI92 intermediate SQL grammar supported.
991 *
992 * @return <code>true</code> if so; <code>false</code> otherwise
993 */
994 Boolean isSupportsANSI92IntermediateSQL();
995
996 /**
997 * Sets whether this database supports the ANSI92 intermediate SQL grammar supported.
998 *
999 * @param supportsANSI92IntermediateSQL <code>true</code> if so; <code>false</code> otherwise
1000 */
1001 void setSupportsANSI92IntermediateSQL( Boolean supportsANSI92IntermediateSQL );
1002
1003 /**
1004 * Retrieves whether this database supports the ANSI92 full SQL grammar supported.
1005 *
1006 * @return <code>true</code> if so; <code>false</code> otherwise
1007 */
1008 Boolean isSupportsANSI92FullSQL();
1009
1010 /**
1011 * Sets whether this database supports the ANSI92 full SQL grammar supported.
1012 *
1013 * @param supportsANSI92FullSQL <code>true</code> if so; <code>false</code> otherwise
1014 */
1015 void setSupportsANSI92FullSQL( Boolean supportsANSI92FullSQL );
1016
1017 /**
1018 * Retrieves whether this database supports the SQL Integrity Enhancement Facility.
1019 *
1020 * @return <code>true</code> if so; <code>false</code> otherwise
1021 */
1022 Boolean isSupportsIntegrityEnhancementFacility();
1023
1024 /**
1025 * Sets whether this database supports the SQL Integrity Enhancement Facility.
1026 *
1027 * @param supportsIntegrityEnhancementFacility <code>true</code> if so; <code>false</code> otherwise
1028 */
1029 void setSupportsIntegrityEnhancementFacility( Boolean supportsIntegrityEnhancementFacility );
1030
1031 /**
1032 * Retrieves whether this database supports some form of outer join.
1033 *
1034 * @return <code>true</code> if so; <code>false</code> otherwise
1035 */
1036 Boolean isSupportsOuterJoins();
1037
1038 /**
1039 * Sets whether this database supports some form of outer join.
1040 *
1041 * @param supportsOuterJoins <code>true</code> if so; <code>false</code> otherwise
1042 */
1043 void setSupportsOuterJoins( Boolean supportsOuterJoins );
1044
1045 /**
1046 * Retrieves whether this database supports full nested outer joins.
1047 *
1048 * @return <code>true</code> if so; <code>false</code> otherwise
1049 */
1050 Boolean isSupportsFullOuterJoins();
1051
1052 /**
1053 * Sets whether this database supports full nested outer joins.
1054 *
1055 * @param supportsFullOuterJoins <code>true</code> if so; <code>false</code> otherwise
1056 */
1057 void setSupportsFullOuterJoins( Boolean supportsFullOuterJoins );
1058
1059 /**
1060 * Retrieves whether this database provides limited support for outer joins. (This will be <code>true</code> if the method
1061 * <code>DatabaseMetaData.supportsFullOuterJoins</code> returns <code>true</code>).
1062 *
1063 * @return <code>true</code> if so; <code>false</code> otherwise
1064 */
1065 Boolean isSupportsLimitedOuterJoins();
1066
1067 /**
1068 * Sets whether this database provides limited support for outer joins. (This will be <code>true</code> if the method
1069 * <code>DatabaseMetaData.supportsFullOuterJoins</code> returns <code>true</code>).
1070 *
1071 * @param supportsLimitedOuterJoins <code>true</code> if so; <code>false</code> otherwise
1072 */
1073 void setSupportsLimitedOuterJoins( Boolean supportsLimitedOuterJoins );
1074
1075 /**
1076 * Retrieves the database vendor's preferred term for "schema".
1077 *
1078 * @return the vendor term for "schema"
1079 */
1080 String getSchemaTerm();
1081
1082 /**
1083 * Sets the database vendor's preferred term for "schema".
1084 *
1085 * @param schemaTerm the vendor term for "schema"
1086 */
1087 void setSchemaTerm( String schemaTerm );
1088
1089 /**
1090 * Retrieves the database vendor's preferred term for "procedure".
1091 *
1092 * @return the vendor term for "procedure"
1093 */
1094 String getProcedureTerm();
1095
1096 /**
1097 * Sets the database vendor's preferred term for "procedure".
1098 *
1099 * @param procedureTerm the vendor term for "procedure"
1100 */
1101 void setProcedureTerm( String procedureTerm );
1102
1103 /**
1104 * Retrieves the database vendor's preferred term for "catalog".
1105 *
1106 * @return the vendor term for "catalog"
1107 */
1108 String getCatalogTerm();
1109
1110 /**
1111 * Sets the database vendor's preferred term for "catalog".
1112 *
1113 * @param catalogTerm the vendor term for "catalog"
1114 */
1115 void setCatalogTerm( String catalogTerm );
1116
1117 /**
1118 * Retrieves whether a catalog appears at the start of a fully qualified table name. If not, the catalog appears at the end.
1119 *
1120 * @return <code>true</code> if the catalog name appears at the beginning of a fully qualified table name; <code>false</code>
1121 * otherwise
1122 */
1123 Boolean isCatalogAtStart();
1124
1125 /**
1126 * Sets whether a catalog appears at the start of a fully qualified table name. If not, the catalog appears at the end.
1127 *
1128 * @param catalogAtStart <code>true</code> if the catalog name appears at the beginning of a fully qualified table name;
1129 * <code>false</code> otherwise
1130 */
1131 void setCatalogAtStart( Boolean catalogAtStart );
1132
1133 /**
1134 * Retrieves the <code>String</code> that this database uses as the separator between a catalog and table name.
1135 *
1136 * @return the separator string
1137 */
1138 String getCatalogSeparator();
1139
1140 /**
1141 * Sets the <code>String</code> that this database uses as the separator between a catalog and table name.
1142 *
1143 * @param catalogSeparator the separator string
1144 */
1145 void setCatalogSeparator( String catalogSeparator );
1146
1147 /**
1148 * Retrieves whether a schema name can be used in a data manipulation statement.
1149 *
1150 * @return <code>true</code> if so; <code>false</code> otherwise
1151 */
1152 Boolean isSupportsSchemasInDataManipulation();
1153
1154 /**
1155 * Sets whether a schema name can be used in a data manipulation statement.
1156 *
1157 * @param supportsSchemasInDataManipulation <code>true</code> if so; <code>false</code> otherwise
1158 */
1159 void setSupportsSchemasInDataManipulation( Boolean supportsSchemasInDataManipulation );
1160
1161 /**
1162 * Retrieves whether a schema name can be used in a procedure call statement.
1163 *
1164 * @return <code>true</code> if so; <code>false</code> otherwise
1165 */
1166 Boolean isSupportsSchemasInProcedureCalls();
1167
1168 /**
1169 * Sets whether a schema name can be used in a procedure call statement.
1170 *
1171 * @param supportsSchemasInProcedureCalls <code>true</code> if so; <code>false</code> otherwise
1172 */
1173 void setSupportsSchemasInProcedureCalls( Boolean supportsSchemasInProcedureCalls );
1174
1175 /**
1176 * Retrieves whether a schema name can be used in a table definition statement.
1177 *
1178 * @return <code>true</code> if so; <code>false</code> otherwise
1179 */
1180 Boolean isSupportsSchemasInTableDefinitions();
1181
1182 /**
1183 * Sets whether a schema name can be used in a table definition statement.
1184 *
1185 * @param supportsSchemasInTableDefinitions <code>true</code> if so; <code>false</code> otherwise
1186 */
1187 void setSupportsSchemasInTableDefinitions( Boolean supportsSchemasInTableDefinitions );
1188
1189 /**
1190 * Retrieves whether a schema name can be used in an index definition statement.
1191 *
1192 * @return <code>true</code> if so; <code>false</code> otherwise
1193 */
1194 Boolean isSupportsSchemasInIndexDefinitions();
1195
1196 /**
1197 * Sets whether a schema name can be used in an index definition statement.
1198 *
1199 * @param supportsSchemasInIndexDefinitions <code>true</code> if so; <code>false</code> otherwise
1200 */
1201 void setSupportsSchemasInIndexDefinitions( Boolean supportsSchemasInIndexDefinitions );
1202
1203 /**
1204 * Retrieves whether a schema name can be used in a privilege definition statement.
1205 *
1206 * @return <code>true</code> if so; <code>false</code> otherwise
1207 */
1208 Boolean isSupportsSchemasInPrivilegeDefinitions();
1209
1210 /**
1211 * Sets whether a schema name can be used in a privilege definition statement.
1212 *
1213 * @param supportsSchemasInPrivilegeDefinitions <code>true</code> if so; <code>false</code> otherwise
1214 */
1215 void setSupportsSchemasInPrivilegeDefinitions( Boolean supportsSchemasInPrivilegeDefinitions );
1216
1217 /**
1218 * Retrieves whether a catalog name can be used in a data manipulation statement.
1219 *
1220 * @return <code>true</code> if so; <code>false</code> otherwise
1221 */
1222 Boolean isSupportsCatalogsInDataManipulation();
1223
1224 /**
1225 * Sets whether a catalog name can be used in a data manipulation statement.
1226 *
1227 * @param supportsCatalogsInDataManipulation <code>true</code> if so; <code>false</code> otherwise
1228 */
1229 void setSupportsCatalogsInDataManipulation( Boolean supportsCatalogsInDataManipulation );
1230
1231 /**
1232 * Retrieves whether a catalog name can be used in a procedure call statement.
1233 *
1234 * @return <code>true</code> if so; <code>false</code> otherwise
1235 */
1236 Boolean isSupportsCatalogsInProcedureCalls();
1237
1238 /**
1239 * Sets whether a catalog name can be used in a procedure call statement.
1240 *
1241 * @param supportsCatalogsInProcedureCalls <code>true</code> if so; <code>false</code> otherwise
1242 */
1243 void setSupportsCatalogsInProcedureCalls( Boolean supportsCatalogsInProcedureCalls );
1244
1245 /**
1246 * Retrieves whether a catalog name can be used in a table definition statement.
1247 *
1248 * @return <code>true</code> if so; <code>false</code> otherwise
1249 */
1250 Boolean isSupportsCatalogsInTableDefinitions();
1251
1252 /**
1253 * Sets whether a catalog name can be used in a table definition statement.
1254 *
1255 * @param supportsCatalogsInTableDefinitions <code>true</code> if so; <code>false</code> otherwise
1256 */
1257 void setSupportsCatalogsInTableDefinitions( Boolean supportsCatalogsInTableDefinitions );
1258
1259 /**
1260 * Retrieves whether a catalog name can be used in an index definition statement.
1261 *
1262 * @return <code>true</code> if so; <code>false</code> otherwise
1263 */
1264 Boolean isSupportsCatalogsInIndexDefinitions();
1265
1266 /**
1267 * Sets whether a catalog name can be used in an index definition statement.
1268 *
1269 * @param supportsCatalogsInIndexDefinitions <code>true</code> if so; <code>false</code> otherwise
1270 */
1271 void setSupportsCatalogsInIndexDefinitions( Boolean supportsCatalogsInIndexDefinitions );
1272
1273 /**
1274 * Retrieves whether a catalog name can be used in a privilege definition statement.
1275 *
1276 * @return <code>true</code> if so; <code>false</code> otherwise
1277 */
1278 Boolean isSupportsCatalogsInPrivilegeDefinitions();
1279
1280 /**
1281 * Sets whether a catalog name can be used in a privilege definition statement.
1282 *
1283 * @param supportsCatalogsInPrivilegeDefinitions <code>true</code> if so; <code>false</code> otherwise
1284 */
1285 void setSupportsCatalogsInPrivilegeDefinitions( Boolean supportsCatalogsInPrivilegeDefinitions );
1286
1287 /**
1288 * Retrieves whether this database supports positioned <code>DELETE</code> statements.
1289 *
1290 * @return <code>true</code> if so; <code>false</code> otherwise
1291 */
1292 Boolean isSupportsPositionedDelete();
1293
1294 /**
1295 * Sets whether this database supports positioned <code>DELETE</code> statements.
1296 *
1297 * @param supportsPositionedDelete <code>true</code> if so; <code>false</code> otherwise
1298 */
1299 void setSupportsPositionedDelete( Boolean supportsPositionedDelete );
1300
1301 /**
1302 * Retrieves whether this database supports positioned <code>UPDATE</code> statements.
1303 *
1304 * @return <code>true</code> if so; <code>false</code> otherwise
1305 */
1306 Boolean isSupportsPositionedUpdate();
1307
1308 /**
1309 * Sets whether this database supports positioned <code>UPDATE</code> statements.
1310 *
1311 * @param supportsPositionedUpdate <code>true</code> if so; <code>false</code> otherwise
1312 */
1313 void setSupportsPositionedUpdate( Boolean supportsPositionedUpdate );
1314
1315 /**
1316 * Retrieves whether this database supports <code>SELECT FOR UPDATE</code> statements.
1317 *
1318 * @return <code>true</code> if so; <code>false</code> otherwise
1319 */
1320 Boolean isSupportsSelectForUpdate();
1321
1322 /**
1323 * Sets whether this database supports <code>SELECT FOR UPDATE</code> statements.
1324 *
1325 * @param supportsSelectForUpdate <code>true</code> if so; <code>false</code> otherwise
1326 */
1327 void setSupportsSelectForUpdate( Boolean supportsSelectForUpdate );
1328
1329 /**
1330 * Retrieves whether this database supports stored procedure calls that use the stored procedure escape syntax.
1331 *
1332 * @return <code>true</code> if so; <code>false</code> otherwise
1333 */
1334 Boolean isSupportsStoredProcedures();
1335
1336 /**
1337 * Sets whether this database supports stored procedure calls that use the stored procedure escape syntax.
1338 *
1339 * @param supportsStoredProcedures <code>true</code> if so; <code>false</code> otherwise
1340 */
1341 void setSupportsStoredProcedures( Boolean supportsStoredProcedures );
1342
1343 /**
1344 * Retrieves whether this database supports subqueries in comparison expressions.
1345 *
1346 * @return <code>true</code> if so; <code>false</code> otherwise
1347 */
1348 Boolean isSupportsSubqueriesInComparisons();
1349
1350 /**
1351 * Retrieves whether this database supports subqueries in comparison expressions.
1352 *
1353 * @param supportsSubqueriesInComparisons <code>true</code> if so; <code>false</code> otherwise
1354 */
1355 void setSupportsSubqueriesInComparisons( Boolean supportsSubqueriesInComparisons );
1356
1357 /**
1358 * Retrieves whether this database supports subqueries in <code>EXISTS</code> expressions.
1359 *
1360 * @return <code>true</code> if so; <code>false</code> otherwise
1361 */
1362 Boolean isSupportsSubqueriesInExists();
1363
1364 /**
1365 * Sets whether this database supports subqueries in <code>EXISTS</code> expressions.
1366 *
1367 * @param supportsSubqueriesInExists <code>true</code> if so; <code>false</code> otherwise
1368 */
1369 void setSupportsSubqueriesInExists( Boolean supportsSubqueriesInExists );
1370
1371 /**
1372 * Retrieves whether this database supports subqueries in <code>IN</code> statements.
1373 *
1374 * @return <code>true</code> if so; <code>false</code> otherwise
1375 */
1376 Boolean isSupportsSubqueriesInIns();
1377
1378 /**
1379 * Sets whether this database supports subqueries in <code>IN</code> statements.
1380 *
1381 * @param supportsSubqueriesInIns <code>true</code> if so; <code>false</code> otherwise
1382 */
1383 void setSupportsSubqueriesInIns( Boolean supportsSubqueriesInIns );
1384
1385 /**
1386 * Retrieves whether this database supports subqueries in quantified expressions.
1387 *
1388 * @return <code>true</code> if so; <code>false</code> otherwise
1389 */
1390 Boolean isSupportsSubqueriesInQuantifieds();
1391
1392 /**
1393 * Sets whether this database supports subqueries in quantified expressions.
1394 *
1395 * @param supportsSubqueriesInQuantifieds <code>true</code> if so; <code>false</code> otherwise
1396 */
1397 void setSupportsSubqueriesInQuantifieds( Boolean supportsSubqueriesInQuantifieds );
1398
1399 /**
1400 * Retrieves whether this database supports correlated subqueries.
1401 *
1402 * @return <code>true</code> if so; <code>false</code> otherwise
1403 */
1404 Boolean isSupportsCorrelatedSubqueries();
1405
1406 /**
1407 * Sets whether this database supports correlated subqueries.
1408 *
1409 * @param supportsCorrelatedSubqueries <code>true</code> if so; <code>false</code> otherwise
1410 */
1411 void setSupportsCorrelatedSubqueries( Boolean supportsCorrelatedSubqueries );
1412
1413 /**
1414 * Retrieves whether this database supports SQL <code>UNION</code>.
1415 *
1416 * @return <code>true</code> if so; <code>false</code> otherwise
1417 */
1418 Boolean isSupportsUnion();
1419
1420 /**
1421 * Sets whether this database supports SQL <code>UNION</code>.
1422 *
1423 * @param supportsUnion <code>true</code> if so; <code>false</code> otherwise
1424 */
1425 void setSupportsUnion( Boolean supportsUnion );
1426
1427 /**
1428 * Retrieves whether this database supports SQL <code>UNION ALL</code>.
1429 *
1430 * @return <code>true</code> if so; <code>false</code> otherwise
1431 */
1432 Boolean isSupportsUnionAll();
1433
1434 /**
1435 * Sets whether this database supports SQL <code>UNION ALL</code>.
1436 *
1437 * @param supportsUnionAll <code>true</code> if so; <code>false</code> otherwise
1438 */
1439 void setSupportsUnionAll( Boolean supportsUnionAll );
1440
1441 /**
1442 * Retrieves whether this database supports keeping cursors open across commits.
1443 *
1444 * @return <code>true</code> if cursors always remain open; <code>false</code> if they might not remain open
1445 */
1446 Boolean isSupportsOpenCursorsAcrossCommit();
1447
1448 /**
1449 * Sets whether this database supports keeping cursors open across commits.
1450 *
1451 * @param supportsOpenCursorsAcrossCommit <code>true</code> if cursors always remain open; <code>false</code> if they might
1452 * not remain open
1453 */
1454 void setSupportsOpenCursorsAcrossCommit( Boolean supportsOpenCursorsAcrossCommit );
1455
1456 /**
1457 * Retrieves whether this database supports keeping cursors open across rollbacks.
1458 *
1459 * @return <code>true</code> if cursors always remain open; <code>false</code> if they might not remain open
1460 */
1461 Boolean isSupportsOpenCursorsAcrossRollback();
1462
1463 /**
1464 * Sets whether this database supports keeping cursors open across rollbacks.
1465 *
1466 * @param supportsOpenCursorsAcrossRollback <code>true</code> if cursors always remain open; <code>false</code> if they might
1467 * not remain open
1468 */
1469 void setSupportsOpenCursorsAcrossRollback( Boolean supportsOpenCursorsAcrossRollback );
1470
1471 /**
1472 * Retrieves whether this database supports keeping statements open across commits.
1473 *
1474 * @return <code>true</code> if statements always remain open; <code>false</code> if they might not remain open
1475 */
1476 Boolean isSupportsOpenStatementsAcrossCommit();
1477
1478 /**
1479 * sets whether this database supports keeping statements open across commits.
1480 *
1481 * @param supportsOpenStatementsAcrossCommit <code>true</code> if statements always remain open; <code>false</code> if they
1482 * might not remain open
1483 */
1484 void setSupportsOpenStatementsAcrossCommit( Boolean supportsOpenStatementsAcrossCommit );
1485
1486 /**
1487 * Retrieves whether this database supports keeping statements open across rollbacks.
1488 *
1489 * @return <code>true</code> if statements always remain open; <code>false</code> if they might not remain open
1490 */
1491 Boolean isSupportsOpenStatementsAcrossRollback();
1492
1493 /**
1494 * Sets whether this database supports keeping statements open across rollbacks.
1495 *
1496 * @param supportsOpenStatementsAcrossRollback <code>true</code> if statements always remain open; <code>false</code> if they
1497 * might not remain open
1498 */
1499 void setSupportsOpenStatementsAcrossRollback( Boolean supportsOpenStatementsAcrossRollback );
1500
1501 // ----------------------------------------------------------------------
1502 // The following group of methods exposes various limitations based on the target
1503 // database with the current driver. Unless otherwise specified, a result of zero
1504 // means there is no limit, or the limit is not known.
1505 // ----------------------------------------------------------------------
1506
1507 /**
1508 * Retrieves the maximum number of hex characters this database allows in an inline binary literal.
1509 *
1510 * @return max the maximum length (in hex characters) for a binary literal; a result of zero means that there is no limit or
1511 * the limit is not known
1512 */
1513 Integer getMaxBinaryLiteralLength();
1514
1515 /**
1516 * sets the maximum number of hex characters this database allows in an inline binary literal.
1517 *
1518 * @param maxBinaryLiteralLength max the maximum length (in hex characters) for a binary literal; a result of zero means that
1519 * there is no limit or the limit is not known
1520 */
1521 void setMaxBinaryLiteralLength( Integer maxBinaryLiteralLength );
1522
1523 /**
1524 * Retrieves the maximum number of characters this database allows for a character literal.
1525 *
1526 * @return the maximum number of characters allowed for a character literal; a result of zero means that there is no limit or
1527 * the limit is not known
1528 */
1529 Integer getMaxCharLiteralLength();
1530
1531 /**
1532 * Sets the maximum number of characters this database allows for a character literal.
1533 *
1534 * @param maxCharLiteralLength the maximum number of characters allowed for a character literal; a result of zero means that
1535 * there is no limit or the limit is not known
1536 */
1537 void setMaxCharLiteralLength( Integer maxCharLiteralLength );
1538
1539 /**
1540 * Retrieves the maximum number of characters this database allows for a column name.
1541 *
1542 * @return the maximum number of characters allowed for a column name; a result of zero means that there is no limit or the
1543 * limit is not known
1544 */
1545 Integer getMaxColumnNameLength();
1546
1547 /**
1548 * Sets the maximum number of characters this database allows for a column name.
1549 *
1550 * @param maxColumnNameLength the maximum number of characters allowed for a column name; a result of zero means that there is
1551 * no limit or the limit is not known
1552 */
1553 void setMaxColumnNameLength( Integer maxColumnNameLength );
1554
1555 /**
1556 * Retrieves the maximum number of columns this database allows in a <code>GROUP BY</code> clause.
1557 *
1558 * @return the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known
1559 */
1560 Integer getMaxColumnsInGroupBy();
1561
1562 /**
1563 * Sets the maximum number of columns this database allows in a <code>GROUP BY</code> clause.
1564 *
1565 * @param maxColumnsInGroupBy the maximum number of columns allowed; a result of zero means that there is no limit or the
1566 * limit is not known
1567 */
1568 void setMaxColumnsInGroupBy( Integer maxColumnsInGroupBy );
1569
1570 /**
1571 * Retrieves the maximum number of columns this database allows in an index.
1572 *
1573 * @return the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known
1574 */
1575 Integer getMaxColumnsInIndex();
1576
1577 /**
1578 * Sets the maximum number of columns this database allows in an index.
1579 *
1580 * @param maxColumnsInIndex the maximum number of columns allowed; a result of zero means that there is no limit or the limit
1581 * is not known
1582 */
1583 void setMaxColumnsInIndex( Integer maxColumnsInIndex );
1584
1585 /**
1586 * Retrieves the maximum number of columns this database allows in an <code>ORDER BY</code> clause.
1587 *
1588 * @return the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known
1589 */
1590 Integer getMaxColumnsInOrderBy();
1591
1592 /**
1593 * Sets the maximum number of columns this database allows in an <code>ORDER BY</code> clause.
1594 *
1595 * @param maxColumnsInOrderBy the maximum number of columns allowed; a result of zero means that there is no limit or the
1596 * limit is not known
1597 */
1598 void setMaxColumnsInOrderBy( Integer maxColumnsInOrderBy );
1599
1600 /**
1601 * Retrieves the maximum number of columns this database allows in a <code>SELECT</code> list.
1602 *
1603 * @return the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known
1604 */
1605 Integer getMaxColumnsInSelect();
1606
1607 /**
1608 * Sets the maximum number of columns this database allows in a <code>SELECT</code> list.
1609 *
1610 * @param maxColumnsInSelect the maximum number of columns allowed; a result of zero means that there is no limit or the limit
1611 * is not known
1612 */
1613 void setMaxColumnsInSelect( Integer maxColumnsInSelect );
1614
1615 /**
1616 * Retrieves the maximum number of columns this database allows in a table.
1617 *
1618 * @return the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known
1619 */
1620 Integer getMaxColumnsInTable();
1621
1622 /**
1623 * Sets the maximum number of columns this database allows in a table.
1624 *
1625 * @param maxColumnsInTable the maximum number of columns allowed; a result of zero means that there is no limit or the limit
1626 * is not known
1627 */
1628 void setMaxColumnsInTable( Integer maxColumnsInTable );
1629
1630 /**
1631 * Retrieves the maximum number of concurrent connections to this database that are possible.
1632 *
1633 * @return the maximum number of active connections possible at one time; a result of zero means that there is no limit or the
1634 * limit is not known
1635 */
1636 Integer getMaxConnections();
1637
1638 /**
1639 * Sets the maximum number of concurrent connections to this database that are possible.
1640 *
1641 * @param maxConnections the maximum number of active connections possible at one time; a result of zero means that there is
1642 * no limit or the limit is not known
1643 */
1644 void setMaxConnections( Integer maxConnections );
1645
1646 /**
1647 * Retrieves the maximum number of characters that this database allows in a cursor name.
1648 *
1649 * @return the maximum number of characters allowed in a cursor name; a result of zero means that there is no limit or the
1650 * limit is not known
1651 */
1652 Integer getMaxCursorNameLength();
1653
1654 /**
1655 * Sets the maximum number of characters that this database allows in a cursor name.
1656 *
1657 * @param maxCursorNameLength the maximum number of characters allowed in a cursor name; a result of zero means that there is
1658 * no limit or the limit is not known
1659 */
1660 void setMaxCursorNameLength( Integer maxCursorNameLength );
1661
1662 /**
1663 * Retrieves the maximum number of bytes this database allows for an index, including all of the parts of the index.
1664 *
1665 * @return the maximum number of bytes allowed; this limit includes the composite of all the constituent parts of the index; a
1666 * result of zero means that there is no limit or the limit is not known
1667 */
1668 Integer getMaxIndexLength();
1669
1670 /**
1671 * Sets the maximum number of bytes this database allows for an index, including all of the parts of the index.
1672 *
1673 * @param maxIndexLength the maximum number of bytes allowed; this limit includes the composite of all the constituent parts
1674 * of the index; a result of zero means that there is no limit or the limit is not known
1675 */
1676 void setMaxIndexLength( Integer maxIndexLength );
1677
1678 /**
1679 * Retrieves the maximum number of characters that this database allows in a schema name.
1680 *
1681 * @return the maximum number of characters allowed in a schema name; a result of zero means that there is no limit or the
1682 * limit is not known
1683 */
1684 Integer getMaxSchemaNameLength();
1685
1686 /**
1687 * Sets the maximum number of characters that this database allows in a schema name.
1688 *
1689 * @param maxSchemaNameLength the maximum number of characters allowed in a schema name; a result of zero means that there is
1690 * no limit or the limit is not known
1691 */
1692 void setMaxSchemaNameLength( Integer maxSchemaNameLength );
1693
1694 /**
1695 * Retrieves the maximum number of characters that this database allows in a procedure name.
1696 *
1697 * @return the maximum number of characters allowed in a procedure name; a result of zero means that there is no limit or the
1698 * limit is not known
1699 */
1700 Integer getMaxProcedureNameLength();
1701
1702 /**
1703 * Sets the maximum number of characters that this database allows in a procedure name.
1704 *
1705 * @param maxProcedureNameLength the maximum number of characters allowed in a procedure name; a result of zero means that
1706 * there is no limit or the limit is not known
1707 */
1708 void setMaxProcedureNameLength( Integer maxProcedureNameLength );
1709
1710 /**
1711 * Retrieves the maximum number of characters that this database allows in a catalog name.
1712 *
1713 * @return the maximum number of characters allowed in a catalog name; a result of zero means that there is no limit or the
1714 * limit is not known
1715 */
1716 Integer getMaxCatalogNameLength();
1717
1718 /**
1719 * Sets the maximum number of characters that this database allows in a catalog name.
1720 *
1721 * @param maxCatalogNameLength the maximum number of characters allowed in a catalog name; a result of zero means that there
1722 * is no limit or the limit is not known
1723 */
1724 void setMaxCatalogNameLength( Integer maxCatalogNameLength );
1725
1726 /**
1727 * Retrieves the maximum number of bytes this database allows in a single row.
1728 *
1729 * @return the maximum number of bytes allowed for a row; a result of zero means that there is no limit or the limit is not
1730 * known
1731 */
1732 Integer getMaxRowSize();
1733
1734 /**
1735 * Sets the maximum number of bytes this database allows in a single row.
1736 *
1737 * @param maxRowSize the maximum number of bytes allowed for a row; a result of zero means that there is no limit or the limit
1738 * is not known
1739 */
1740 void setMaxRowSize( Integer maxRowSize );
1741
1742 /**
1743 * Retrieves whether the return value for the method <code>getMaxRowSize</code> includes the SQL data types
1744 * <code>LONGVARCHAR</code> and <code>LONGVARBINARY</code>.
1745 *
1746 * @return <code>true</code> if so; <code>false</code> otherwise
1747 */
1748 Boolean isMaxRowSizeIncludeBlobs();
1749
1750 /**
1751 * Sets whether the return value for the method <code>getMaxRowSize</code> includes the SQL data types
1752 * <code>LONGVARCHAR</code> and <code>LONGVARBINARY</code>.
1753 *
1754 * @param maxRowSizeIncludeBlobs <code>true</code> if so; <code>false</code> otherwise
1755 */
1756 void setMaxRowSizeIncludeBlobs( Boolean maxRowSizeIncludeBlobs );
1757
1758 /**
1759 * Retrieves the maximum number of characters this database allows in an SQL statement.
1760 *
1761 * @return the maximum number of characters allowed for an SQL statement; a result of zero means that there is no limit or the
1762 * limit is not known
1763 */
1764 Integer getMaxStatementLength();
1765
1766 /**
1767 * Sets the maximum number of characters this database allows in an SQL statement.
1768 *
1769 * @param maxStatementLength the maximum number of characters allowed for an SQL statement; a result of zero means that there
1770 * is no limit or the limit is not known
1771 */
1772 void setMaxStatementLength( Integer maxStatementLength );
1773
1774 /**
1775 * Retrieves the maximum number of active statements to this database that can be open at the same time.
1776 *
1777 * @return the maximum number of statements that can be open at one time; a result of zero means that there is no limit or the
1778 * limit is not known
1779 */
1780 Integer getMaxStatements();
1781
1782 /**
1783 * Sets the maximum number of active statements to this database that can be open at the same time.
1784 *
1785 * @param maxStatements the maximum number of statements that can be open at one time; a result of zero means that there is no
1786 * limit or the limit is not known
1787 */
1788 void setMaxStatements( Integer maxStatements );
1789
1790 /**
1791 * Retrieves the maximum number of characters this database allows in a table name.
1792 *
1793 * @return the maximum number of characters allowed for a table name; a result of zero means that there is no limit or the
1794 * limit is not known
1795 */
1796 Integer getMaxTableNameLength();
1797
1798 /**
1799 * Sets the maximum number of characters this database allows in a table name.
1800 *
1801 * @param maxTableNameLength the maximum number of characters allowed for a table name; a result of zero means that there is
1802 * no limit or the limit is not known
1803 */
1804 void setMaxTableNameLength( Integer maxTableNameLength );
1805
1806 /**
1807 * Retrieves the maximum number of tables this database allows in a <code>SELECT</code> statement.
1808 *
1809 * @return the maximum number of tables allowed in a <code>SELECT</code> statement; a result of zero means that there is no
1810 * limit or the limit is not known
1811 */
1812 Integer getMaxTablesInSelect();
1813
1814 /**
1815 * Sets the maximum number of tables this database allows in a <code>SELECT</code> statement.
1816 *
1817 * @param maxTablesInSelect the maximum number of tables allowed in a <code>SELECT</code> statement; a result of zero means
1818 * that there is no limit or the limit is not known
1819 */
1820 void setMaxTablesInSelect( Integer maxTablesInSelect );
1821
1822 /**
1823 * Retrieves the maximum number of characters this database allows in a user name.
1824 *
1825 * @return the maximum number of characters allowed for a user name; a result of zero means that there is no limit or the
1826 * limit is not known
1827 */
1828 Integer getMaxUserNameLength();
1829
1830 /**
1831 * Sets the maximum number of characters this database allows in a user name.
1832 *
1833 * @param maxUserNameLength the maximum number of characters allowed for a user name; a result of zero means that there is no
1834 * limit or the limit is not known
1835 */
1836 void setMaxUserNameLength( Integer maxUserNameLength );
1837
1838 /**
1839 * Retrieves this database's default transaction isolation level. The possible values are defined in
1840 * <code>java.sql.Connection</code>.
1841 *
1842 * @return the default isolation level
1843 * @see java.sql.Connection
1844 */
1845 Integer getDefaultTransactionIsolation();
1846
1847 /**
1848 * Sets this database's default transaction isolation level. The possible values are defined in
1849 * <code>java.sql.Connection</code>.
1850 *
1851 * @param defaultTransactionIsolation the default isolation level
1852 * @see java.sql.Connection
1853 */
1854 void setDefaultTransactionIsolation( Integer defaultTransactionIsolation );
1855
1856 /**
1857 * Retrieves whether this database supports transactions. If not, invoking the method <code>commit</code> is a noop, and the
1858 * isolation level is <code>TRANSACTION_NONE</code>.
1859 *
1860 * @return <code>true</code> if transactions are supported; <code>false</code> otherwise
1861 */
1862 Boolean isSupportsTransactions();
1863
1864 /**
1865 * Sets whether this database supports transactions. If not, invoking the method <code>commit</code> is a noop, and the
1866 * isolation level is <code>TRANSACTION_NONE</code>.
1867 *
1868 * @param supportsTransactions <code>true</code> if transactions are supported; <code>false</code> otherwise
1869 */
1870 void setSupportsTransactions( Boolean supportsTransactions );
1871
1872 /**
1873 * Retrieves list of database supported transaction isolation levels.
1874 *
1875 * @return list of database supported transaction isolation levels.
1876 * @see java.sql.Connection
1877 */
1878 Set<TransactionIsolationLevelType> getSupportedTransactionIsolationLevels();
1879
1880 /**
1881 * Adds TransactionIsolationLevelType
1882 *
1883 * @param transactionIsolationLevelType the Transaction Isolation Level Type
1884 */
1885 void addSupportedTransactionIsolationLevelType( TransactionIsolationLevelType transactionIsolationLevelType );
1886
1887 /**
1888 * Deletes TransactionIsolationLevelType
1889 *
1890 * @param transactionIsolationLevelType the Transaction Isolation Level Type
1891 */
1892 void deleteSupportedTransactionIsolationLevelType( TransactionIsolationLevelType transactionIsolationLevelType );
1893
1894 /**
1895 * Is supported TransactionIsolationLevelType
1896 *
1897 * @param transactionIsolationLevelType the Transaction Isolation Level Type
1898 * @return true if supported
1899 */
1900 Boolean isSupportedTransactionIsolationLevelType( TransactionIsolationLevelType transactionIsolationLevelType );
1901
1902 /**
1903 * Retrieves whether this database supports both data definition and data manipulation statements within a transaction.
1904 *
1905 * @return <code>true</code> if so; <code>false</code> otherwise
1906 */
1907 Boolean isSupportsDataDefinitionAndDataManipulationTransactions();
1908
1909 /**
1910 * Sets whether this database supports both data definition and data manipulation statements within a transaction.
1911 *
1912 * @param supportsDataDefinitionAndDataManipulationTransactions <code>true</code> if so; <code>false</code> otherwise
1913 */
1914 void setSupportsDataDefinitionAndDataManipulationTransactions( Boolean supportsDataDefinitionAndDataManipulationTransactions );
1915
1916 /**
1917 * Retrieves whether this database supports only data manipulation statements within a transaction.
1918 *
1919 * @return <code>true</code> if so; <code>false</code> otherwise
1920 */
1921 Boolean isSupportsDataManipulationTransactionsOnly();
1922
1923 /**
1924 * Sets whether this database supports only data manipulation statements within a transaction.
1925 *
1926 * @param supportsDataManipulationTransactionsOnly <code>true</code> if so; <code>false</code> otherwise
1927 */
1928 void setSupportsDataManipulationTransactionsOnly( Boolean supportsDataManipulationTransactionsOnly );
1929
1930 /**
1931 * Retrieves whether a data definition statement within a transaction forces the transaction to commit.
1932 *
1933 * @return <code>true</code> if so; <code>false</code> otherwise
1934 */
1935 Boolean isDataDefinitionCausesTransactionCommit();
1936
1937 /**
1938 * Sets whether a data definition statement within a transaction forces the transaction to commit.
1939 *
1940 * @param dataDefinitionCausesTransactionCommit <code>true</code> if so; <code>false</code> otherwise
1941 */
1942 void setDataDefinitionCausesTransactionCommit( Boolean dataDefinitionCausesTransactionCommit );
1943
1944 /**
1945 * Retrieves whether this database ignores a data definition statement within a transaction.
1946 *
1947 * @return <code>true</code> if so; <code>false</code> otherwise
1948 */
1949 Boolean isDataDefinitionIgnoredInTransactions();
1950
1951 /**
1952 * Sets whether this database ignores a data definition statement within a transaction.
1953 *
1954 * @param dataDefinitionIgnoredInTransactions <code>true</code> if so; <code>false</code> otherwise
1955 */
1956 void setDataDefinitionIgnoredInTransactions( Boolean dataDefinitionIgnoredInTransactions );
1957
1958 /**
1959 * Retrieves a description of the stored procedures available in the given catalog.
1960 *
1961 * @return a set of stored procedures available
1962 */
1963 Set<StoredProcedure> getStoredProcedures();
1964
1965 /**
1966 * Adds Stored Procedure
1967 *
1968 * @param storedProcedure the Stored Procedure
1969 */
1970 void addStoredProcedure( StoredProcedure storedProcedure );
1971
1972 /**
1973 * Deletes Stored Procedure
1974 *
1975 * @param storedProcedure the Stored Procedure
1976 */
1977 void deleteStoredProcedure( StoredProcedure storedProcedure );
1978
1979 /**
1980 * Finds stored procedute by its name.
1981 *
1982 * @param catalog a catalog name; must match the catalog name as it is stored in the database; "" retrieves those without a
1983 * catalog; <code>null</code> means that the catalog name should not be used to narrow the search
1984 * @param schema a schema name; must match the schema name as it is stored in the database; "" retrieves those without a
1985 * schema; <code>null</code> means that the schema name should not be used to narrow the search
1986 * @param procedureName a procedure name; must match the procedure name as it is stored in the database
1987 * @return stored procedure or null if not found
1988 */
1989 StoredProcedure findStoredProcedureByName( String catalog,
1990 String schema,
1991 String procedureName );
1992
1993 /**
1994 * Retrieves a description of the tables available in the given catalog.
1995 *
1996 * @return a set of tables available
1997 */
1998 Set<Table> getTables();
1999
2000 /**
2001 * Adds Table
2002 *
2003 * @param table the table to add
2004 */
2005 void addTable( Table table );
2006
2007 /**
2008 * Deletes Table
2009 *
2010 * @param table the table to delete
2011 */
2012 void deleteTable( Table table );
2013
2014 /**
2015 * Finds table by its name.
2016 *
2017 * @param catalog a catalog name; must match the catalog name as it is stored in the database; "" retrieves those without a
2018 * catalog; <code>null</code> means that the catalog name should not be used to narrow the search
2019 * @param schema a schema name; must match the schema name as it is stored in the database; "" retrieves those without a
2020 * schema; <code>null</code> means that the schema name should not be used to narrow the search
2021 * @param tableName a table name; must match the table name as it is stored in the database
2022 * @return table or null if not found
2023 */
2024 Table findTableByName( String catalog,
2025 String schema,
2026 String tableName );
2027
2028 /**
2029 * Retrieves the schemas available in this database. The results are ordered by schema name.
2030 *
2031 * @return schemas available in this database.
2032 */
2033 Set<Schema> getSchemas();
2034
2035 /**
2036 * Adds Schema
2037 *
2038 * @param schema the Schema
2039 */
2040 void addSchema( Schema schema );
2041
2042 /**
2043 * Deletes Schema
2044 *
2045 * @param schema the Schema
2046 */
2047 void deleteSchema( Schema schema );
2048
2049 /**
2050 * Finds schema by its name.
2051 *
2052 * @param catalog a catalog name; must match the catalog name as it is stored in the database; "" retrieves those without a
2053 * catalog; <code>null</code> means that the catalog name should not be used to narrow the search
2054 * @param schemaName a schema name; must match the schema name as it is stored in the database;
2055 * @return schema or null if not found
2056 */
2057 Schema findSchemaByName( String catalog,
2058 String schemaName );
2059
2060 /**
2061 * Retrieves the catalogs available in this database
2062 *
2063 * @return catalogs available in this database
2064 */
2065 Set<Catalog> getCatalogs();
2066
2067 /**
2068 * Adds Catalog
2069 *
2070 * @param catalog the catalog to add
2071 */
2072 void addCatalog( Catalog catalog );
2073
2074 /**
2075 * Deletes Catalog
2076 *
2077 * @param catalog the catalog to delete
2078 */
2079 void deleteCatalog( Catalog catalog );
2080
2081 /**
2082 * Finds catalog by its name.
2083 *
2084 * @param catalogName a catalog name; must match the catalog name as it is stored in the database;
2085 * @return catalog or null if not found
2086 */
2087 Catalog findCatalogByName( String catalogName );
2088
2089 /**
2090 * Retrieves the table types available in this database. The results are ordered by table type.
2091 * <P>
2092 * The table type is:
2093 * <OL>
2094 * <LI><B>TABLE_TYPE</B> String => table type. Typical types are "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY",
2095 * "LOCAL TEMPORARY", "ALIAS", "SYNONYM".
2096 * </OL>
2097 *
2098 * @return table types available in this database
2099 */
2100 Set<TableType> getTableTypes();
2101
2102 /**
2103 * Adds TableType
2104 *
2105 * @param tableType the table type to add
2106 */
2107 void addTableType( TableType tableType );
2108
2109 /**
2110 * Deletes TableType
2111 *
2112 * @param tableType the table type to delete
2113 */
2114 void deleteTableType( TableType tableType );
2115
2116 /**
2117 * Finds table type by its name.
2118 *
2119 * @param typeName a table type name; must match the type name as it is stored in the database;
2120 * @return table type or null if not found
2121 */
2122 TableType findTableTypeByTypeName( String typeName );
2123
2124 /**
2125 * Retrieves a description of all the standard SQL types supported by this database
2126 *
2127 * @return all the standard SQL types supported by this database
2128 */
2129 Set<SqlTypeInfo> getSqlTypeInfos();
2130
2131 /**
2132 * Adds SqlTypeInfo
2133 *
2134 * @param sqlTypeInfo the SQL type to add
2135 */
2136 void addSqlTypeInfo( SqlTypeInfo sqlTypeInfo );
2137
2138 /**
2139 * Deletes SqlTypeInfo
2140 *
2141 * @param sqlTypeInfo the SQL type to delete
2142 */
2143 void deleteSqlTypeInfo( SqlTypeInfo sqlTypeInfo );
2144
2145 /**
2146 * Finds SQL type by its name.
2147 *
2148 * @param typeName a table type name; must match the type name as it is stored in the database;
2149 * @return table type or null if not found
2150 */
2151 SqlTypeInfo findSqlTypeInfoByTypeName( String typeName );
2152
2153 // ===============================================================
2154 // --------------------------JDBC 2.0-----------------------------
2155 // ===============================================================
2156
2157 /**
2158 * Retrieves database supported result set types.
2159 *
2160 * @return database supported result set types.
2161 * @see java.sql.Connection
2162 * @since 1.2 (JDBC 2.0)
2163 */
2164 Set<ResultSetType> getSupportedResultSetTypes();
2165
2166 /**
2167 * Adds supported ResultSetType
2168 *
2169 * @param resultSetType the ResultSetType
2170 */
2171 void addSupportedResultSetType( ResultSetType resultSetType );
2172
2173 /**
2174 * Deletes supported ResultSetType
2175 *
2176 * @param resultSetType the ResultSetType
2177 */
2178 void deleteSupportedResultSetType( ResultSetType resultSetType );
2179
2180 /**
2181 * Retrieves database supported concurrencies for the given result set type.
2182 *
2183 * @return database supported concurrencies for the given result set type.
2184 * @see java.sql.Connection
2185 * @since 1.2 (JDBC 2.0)
2186 */
2187 Set<ResultSetConcurrencyType> getSupportedForwardOnlyResultSetConcurrencies();
2188
2189 /**
2190 * Adds ResultSetConcurrencyType
2191 *
2192 * @param resultSetConcurrencyType the ResultSetConcurrencyType
2193 */
2194 void addSupportedForwardOnlyResultSetConcurrency( ResultSetConcurrencyType resultSetConcurrencyType );
2195
2196 /**
2197 * Deletes ResultSetConcurrencyType
2198 *
2199 * @param resultSetConcurrencyType the ResultSetConcurrencyType
2200 */
2201 void deleteSupportedForwardOnlyResultSetConcurrency( ResultSetConcurrencyType resultSetConcurrencyType );
2202
2203 /**
2204 * Retrieves database supported concurrencies for the given result set type.
2205 *
2206 * @return database supported concurrencies for the given result set type.
2207 * @see java.sql.Connection
2208 * @since 1.2 (JDBC 2.0)
2209 */
2210 Set<ResultSetConcurrencyType> getSupportedScrollInsensitiveResultSetConcurrencies();
2211
2212 /**
2213 * Adds ResultSetConcurrencyType
2214 *
2215 * @param resultSetConcurrencyType the ResultSetConcurrencyType
2216 */
2217 void addSupportedScrollInsensitiveResultSetConcurrency( ResultSetConcurrencyType resultSetConcurrencyType );
2218
2219 /**
2220 * Delete ResultSetConcurrencyType
2221 *
2222 * @param resultSetConcurrencyType the ResultSetConcurrencyType
2223 */
2224 void deleteSupportedScrollInsensitiveResultSetConcurrency( ResultSetConcurrencyType resultSetConcurrencyType );
2225
2226 /**
2227 * Retrieves database supported concurrencies for the given result set type.
2228 *
2229 * @return database supported concurrencies for the given result set type.
2230 * @see java.sql.Connection
2231 * @since 1.2 (JDBC 2.0)
2232 */
2233 Set<ResultSetConcurrencyType> getSupportedScrollSensitiveResultSetConcurrencies();
2234
2235 /**
2236 * Adds resultSetConcurrencyType
2237 *
2238 * @param resultSetConcurrencyType the ResultSetConcurrencyType
2239 */
2240 void addSupportedScrollSensitiveResultSetConcurrency( ResultSetConcurrencyType resultSetConcurrencyType );
2241
2242 /**
2243 * delete resultSetConcurrencyType
2244 *
2245 * @param resultSetConcurrencyType the ResultSetConcurrencyType
2246 */
2247 void deleteSupportedScrollSensitiveResultSetConcurrency( ResultSetConcurrencyType resultSetConcurrencyType );
2248
2249 /**
2250 * Retrieves whether for the given type of <code>ResultSet</code> object, the result set's own updates are visible.
2251 *
2252 * @return <code>true</code> if updates are visible for the given result set type; <code>false</code> otherwise
2253 * @since 1.2 (JDBC 2.0)
2254 */
2255 Boolean isForwardOnlyResultSetOwnUpdatesAreVisible();
2256
2257 /**
2258 * Sets whether for the given type of <code>ResultSet</code> object, the result set's own updates are visible.
2259 *
2260 * @param forwardOnlyResultSetOwnUpdatesAreVisible <code>true</code> if updates are visible for the given result set type;
2261 * <code>false</code> otherwise
2262 * @since 1.2 (JDBC 2.0)
2263 */
2264 void setForwardOnlyResultSetOwnUpdatesAreVisible( Boolean forwardOnlyResultSetOwnUpdatesAreVisible );
2265
2266 /**
2267 * Retrieves whether for the given type of <code>ResultSet</code> object, the result set's own updates are visible.
2268 *
2269 * @return <code>true</code> if updates are visible for the given result set type; <code>false</code> otherwise
2270 * @since 1.2 (JDBC 2.0)
2271 */
2272 Boolean isScrollInsensitiveResultSetOwnUpdatesAreVisible();
2273
2274 /**
2275 * Sets whether for the given type of <code>ResultSet</code> object, the result set's own updates are visible.
2276 *
2277 * @param scrollInsensitiveResultSetOwnUpdatesAreVisible <code>true</code> if updates are visible for the given result set
2278 * type; <code>false</code> otherwise
2279 * @since 1.2 (JDBC 2.0)
2280 */
2281 void setScrollInsensitiveResultSetOwnUpdatesAreVisible( Boolean scrollInsensitiveResultSetOwnUpdatesAreVisible );
2282
2283 /**
2284 * Retrieves whether for the given type of <code>ResultSet</code> object, the result set's own updates are visible.
2285 *
2286 * @return <code>true</code> if updates are visible for the given result set type; <code>false</code> otherwise
2287 * @since 1.2 (JDBC 2.0)
2288 */
2289 Boolean isScrollSensitiveResultSetOwnUpdatesAreVisible();
2290
2291 /**
2292 * Sets whether for the given type of <code>ResultSet</code> object, the result set's own updates are visible.
2293 *
2294 * @param scrollSensitiveResultSetOwnUpdatesAreVisible <code>true</code> if updates are visible for the given result set type;
2295 * <code>false</code> otherwise
2296 * @since 1.2 (JDBC 2.0)
2297 */
2298 void setScrollSensitiveResultSetOwnUpdatesAreVisible( Boolean scrollSensitiveResultSetOwnUpdatesAreVisible );
2299
2300 /**
2301 * Retrieves whether a result set's own deletes are visible.
2302 *
2303 * @return <code>true</code> if deletes are visible for the given result set type; <code>false</code> otherwise
2304 * @since 1.2 (JDBC 2.0)
2305 */
2306 Boolean isForwardOnlyResultSetOwnDeletesAreVisible();
2307
2308 /**
2309 * Sets whether a result set's own deletes are visible.
2310 *
2311 * @param forwardOnlyResultSetOwnDeletesAreVisible <code>true</code> if deletes are visible for the given result set type;
2312 * <code>false</code> otherwise
2313 * @since 1.2 (JDBC 2.0)
2314 */
2315 void setForwardOnlyResultSetOwnDeletesAreVisible( Boolean forwardOnlyResultSetOwnDeletesAreVisible );
2316
2317 /**
2318 * Retrieves whether a result set's own deletes are visible.
2319 *
2320 * @return <code>true</code> if deletes are visible for the given result set type; <code>false</code> otherwise
2321 * @since 1.2 (JDBC 2.0)
2322 */
2323 Boolean isScrollInsensitiveResultSetOwnDeletesAreVisible();
2324
2325 /**
2326 * Sets whether a result set's own deletes are visible.
2327 *
2328 * @param scrollInsensitiveResultSetOwnDeletesAreVisible <code>true</code> if deletes are visible for the given result set
2329 * type; <code>false</code> otherwise
2330 * @since 1.2 (JDBC 2.0)
2331 */
2332 void setScrollInsensitiveResultSetOwnDeletesAreVisible( Boolean scrollInsensitiveResultSetOwnDeletesAreVisible );
2333
2334 /**
2335 * Retrieves whether a result set's own deletes are visible.
2336 *
2337 * @return <code>true</code> if deletes are visible for the given result set type; <code>false</code> otherwise
2338 * @since 1.2 (JDBC 2.0)
2339 */
2340 Boolean isScrollSensitiveResultSetOwnDeletesAreVisible();
2341
2342 /**
2343 * Sets whether a result set's own deletes are visible.
2344 *
2345 * @param scrollSensitiveResultSetOwnDeletesAreVisible <code>true</code> if deletes are visible for the given result set type;
2346 * <code>false</code> otherwise
2347 * @since 1.2 (JDBC 2.0)
2348 */
2349 void setScrollSensitiveResultSetOwnDeletesAreVisible( Boolean scrollSensitiveResultSetOwnDeletesAreVisible );
2350
2351 /**
2352 * Retrieves whether a result set's own inserts are visible.
2353 *
2354 * @return <code>true</code> if inserts are visible for the given result set type; <code>false</code> otherwise
2355 * @since 1.2 (JDBC 2.0)
2356 */
2357 Boolean isForwardOnlyResultSetOwnInsertsAreVisible();
2358
2359 /**
2360 * Sets whether a result set's own inserts are visible.
2361 *
2362 * @param forwardOnlyResultSetOwnInsertsAreVisible <code>true</code> if inserts are visible for the given result set type;
2363 * <code>false</code> otherwise
2364 * @since 1.2 (JDBC 2.0)
2365 */
2366 void setForwardOnlyResultSetOwnInsertsAreVisible( Boolean forwardOnlyResultSetOwnInsertsAreVisible );
2367
2368 /**
2369 * Retrieves whether a result set's own inserts are visible.
2370 *
2371 * @return <code>true</code> if inserts are visible for the given result set type; <code>false</code> otherwise
2372 * @since 1.2 (JDBC 2.0)
2373 */
2374 Boolean isScrollInsensitiveResultSetOwnInsertsAreVisible();
2375
2376 /**
2377 * Sets whether a result set's own inserts are visible.
2378 *
2379 * @param scrollInsensitiveResultSetOwnInsertsAreVisible <code>true</code> if inserts are visible for the given result set
2380 * type; <code>false</code> otherwise
2381 * @since 1.2 (JDBC 2.0)
2382 */
2383 void setScrollInsensitiveResultSetOwnInsertsAreVisible( Boolean scrollInsensitiveResultSetOwnInsertsAreVisible );
2384
2385 /**
2386 * Retrieves whether a result set's own inserts are visible.
2387 *
2388 * @return <code>true</code> if inserts are visible for the given result set type; <code>false</code> otherwise
2389 * @since 1.2 (JDBC 2.0)
2390 */
2391 Boolean isScrollSensitiveResultSetOwnInsertsAreVisible();
2392
2393 /**
2394 * Sets whether a result set's own inserts are visible.
2395 *
2396 * @param scrollSensitiveResultSetOwnInsertsAreVisible <code>true</code> if inserts are visible for the given result set type;
2397 * <code>false</code> otherwise
2398 * @since 1.2 (JDBC 2.0)
2399 */
2400 void setScrollSensitiveResultSetOwnInsertsAreVisible( Boolean scrollSensitiveResultSetOwnInsertsAreVisible );
2401
2402 /**
2403 * Retrieves whether updates made by others are visible.
2404 *
2405 * @return <code>true</code> if updates made by others are visible for the given result set type; <code>false</code> otherwise
2406 * @since 1.2 (JDBC 2.0)
2407 */
2408 Boolean isForwardOnlyResultSetOthersUpdatesAreVisible();
2409
2410 /**
2411 * Sets whether updates made by others are visible.
2412 *
2413 * @param forwardOnlyResultSetOthersUpdatesAreVisible <code>true</code> if updates made by others are visible for the given
2414 * result set type; <code>false</code> otherwise
2415 * @since 1.2 (JDBC 2.0)
2416 */
2417 void setForwardOnlyResultSetOthersUpdatesAreVisible( Boolean forwardOnlyResultSetOthersUpdatesAreVisible );
2418
2419 /**
2420 * Retrieves whether updates made by others are visible.
2421 *
2422 * @return <code>true</code> if updates made by others are visible for the given result set type; <code>false</code> otherwise
2423 * @since 1.2 (JDBC 2.0)
2424 */
2425 Boolean isScrollInsensitiveResultSetOthersUpdatesAreVisible();
2426
2427 /**
2428 * Sets whether updates made by others are visible.
2429 *
2430 * @param scrollInsensitiveResultSetOthersUpdatesAreVisible <code>true</code> if updates made by others are visible for the
2431 * given result set type; <code>false</code> otherwise
2432 * @since 1.2 (JDBC 2.0)
2433 */
2434 void setScrollInsensitiveResultSetOthersUpdatesAreVisible( Boolean scrollInsensitiveResultSetOthersUpdatesAreVisible );
2435
2436 /**
2437 * Retrieves whether updates made by others are visible.
2438 *
2439 * @return <code>true</code> if updates made by others are visible for the given result set type; <code>false</code> otherwise
2440 * @since 1.2 (JDBC 2.0)
2441 */
2442 Boolean isScrollSensitiveResultSetOthersUpdatesAreVisible();
2443
2444 /**
2445 * Sets whether updates made by others are visible.
2446 *
2447 * @param scrollSensitiveResultSetOthersUpdatesAreVisible <code>true</code> if updates made by others are visible for the
2448 * given result set type; <code>false</code> otherwise
2449 * @since 1.2 (JDBC 2.0)
2450 */
2451 void setScrollSensitiveResultSetOthersUpdatesAreVisible( Boolean scrollSensitiveResultSetOthersUpdatesAreVisible );
2452
2453 /**
2454 * Retrieves whether deletes made by others are visible.
2455 *
2456 * @return <code>true</code> if deletes made by others are visible for the given result set type; <code>false</code> otherwise
2457 * @since 1.2 (JDBC 2.0)
2458 */
2459 Boolean isForwardOnlyResultSetOthersDeletesAreVisible();
2460
2461 /**
2462 * Sets whether deletes made by others are visible.
2463 *
2464 * @param forwardOnlyResultSetOthersDeletesAreVisible <code>true</code> if deletes made by others are visible for the given
2465 * result set type; <code>false</code> otherwise
2466 * @since 1.2 (JDBC 2.0)
2467 */
2468 void setForwardOnlyResultSetOthersDeletesAreVisible( Boolean forwardOnlyResultSetOthersDeletesAreVisible );
2469
2470 /**
2471 * Retrieves whether deletes made by others are visible.
2472 *
2473 * @return <code>true</code> if deletes made by others are visible for the given result set type; <code>false</code> otherwise
2474 * @since 1.2 (JDBC 2.0)
2475 */
2476 Boolean isScrollInsensitiveResultSetOthersDeletesAreVisible();
2477
2478 /**
2479 * Sets whether deletes made by others are visible.
2480 *
2481 * @param scrollInsensitiveResultSetOthersDeletesAreVisible <code>true</code> if deletes made by others are visible for the
2482 * given result set type; <code>false</code> otherwise
2483 * @since 1.2 (JDBC 2.0)
2484 */
2485 void setScrollInsensitiveResultSetOthersDeletesAreVisible( Boolean scrollInsensitiveResultSetOthersDeletesAreVisible );
2486
2487 /**
2488 * Retrieves whether deletes made by others are visible.
2489 *
2490 * @return <code>true</code> if deletes made by others are visible for the given result set type; <code>false</code> otherwise
2491 * @since 1.2 (JDBC 2.0)
2492 */
2493 Boolean isScrollSensitiveResultSetOthersDeletesAreVisible();
2494
2495 /**
2496 * Sets whether deletes made by others are visible.
2497 *
2498 * @param scrollSensitiveResultSetOthersDeletesAreVisible <code>true</code> if deletes made by others are visible for the
2499 * given result set type; <code>false</code> otherwise
2500 * @since 1.2 (JDBC 2.0)
2501 */
2502 void setScrollSensitiveResultSetOthersDeletesAreVisible( Boolean scrollSensitiveResultSetOthersDeletesAreVisible );
2503
2504 /**
2505 * Retrieves whether inserts made by others are visible.
2506 *
2507 * @return <code>true</code> if inserts made by others are visible for the given result set type; <code>false</code> otherwise
2508 * @since 1.2 (JDBC 2.0)
2509 */
2510 Boolean isForwardOnlyResultSetOthersInsertsAreVisible();
2511
2512 /**
2513 * Sets whether inserts made by others are visible.
2514 *
2515 * @param forwardOnlyResultSetOthersInsertsAreVisible <code>true</code> if inserts made by others are visible for the given
2516 * result set type; <code>false</code> otherwise
2517 * @since 1.2 (JDBC 2.0)
2518 */
2519 void setForwardOnlyResultSetOthersInsertsAreVisible( Boolean forwardOnlyResultSetOthersInsertsAreVisible );
2520
2521 /**
2522 * Retrieves whether inserts made by others are visible.
2523 *
2524 * @return <code>true</code> if inserts made by others are visible for the given result set type; <code>false</code> otherwise
2525 * @since 1.2 (JDBC 2.0)
2526 */
2527 Boolean isScrollInsensitiveResultSetOthersInsertsAreVisible();
2528
2529 /**
2530 * Sets whether inserts made by others are visible.
2531 *
2532 * @param scrollInsensitiveResultSetOthersInsertsAreVisible <code>true</code> if inserts made by others are visible for the
2533 * given result set type; <code>false</code> otherwise
2534 * @since 1.2 (JDBC 2.0)
2535 */
2536 void setScrollInsensitiveResultSetOthersInsertsAreVisible( Boolean scrollInsensitiveResultSetOthersInsertsAreVisible );
2537
2538 /**
2539 * Retrieves whether inserts made by others are visible.
2540 *
2541 * @return <code>true</code> if inserts made by others are visible for the given result set type; <code>false</code> otherwise
2542 * @since 1.2 (JDBC 2.0)
2543 */
2544 Boolean isScrollSensitiveResultSetOthersInsertsAreVisible();
2545
2546 /**
2547 * Sets whether inserts made by others are visible.
2548 *
2549 * @param scrollSensitiveResultSetOthersInsertsAreVisible <code>true</code> if inserts made by others are visible for the
2550 * given result set type; <code>false</code> otherwise
2551 * @since 1.2 (JDBC 2.0)
2552 */
2553 void setScrollSensitiveResultSetOthersInsertsAreVisible( Boolean scrollSensitiveResultSetOthersInsertsAreVisible );
2554
2555 /**
2556 * Retrieves whether or not a visible row update can be detected by calling the method <code>ResultSet.rowUpdated</code>.
2557 *
2558 * @return <code>true</code> if changes are detected by the result set type; <code>false</code> otherwise
2559 * @since 1.2 (JDBC 2.0)
2560 */
2561 Boolean isForwardOnlyResultSetUpdatesAreDetected();
2562
2563 /**
2564 * Sets whether or not a visible row update can be detected by calling the method <code>ResultSet.rowUpdated</code>.
2565 *
2566 * @param forwardOnlyResultSetUpdatesAreDetected <code>true</code> if changes are detected by the result set type;
2567 * <code>false</code> otherwise
2568 * @since 1.2 (JDBC 2.0)
2569 */
2570 void setForwardOnlyResultSetUpdatesAreDetected( Boolean forwardOnlyResultSetUpdatesAreDetected );
2571
2572 /**
2573 * Retrieves whether or not a visible row update can be detected by calling the method <code>ResultSet.rowUpdated</code>.
2574 *
2575 * @return <code>true</code> if changes are detected by the result set type; <code>false</code> otherwise
2576 * @since 1.2 (JDBC 2.0)
2577 */
2578 Boolean isScrollInsensitiveResultSetUpdatesAreDetected();
2579
2580 /**
2581 * Sets whether or not a visible row update can be detected by calling the method <code>ResultSet.rowUpdated</code>.
2582 *
2583 * @param scrollInsensitiveResultSetUpdatesAreDetected <code>true</code> if changes are detected by the result set type;
2584 * <code>false</code> otherwise
2585 * @since 1.2 (JDBC 2.0)
2586 */
2587 void setScrollInsensitiveResultSetUpdatesAreDetected( Boolean scrollInsensitiveResultSetUpdatesAreDetected );
2588
2589 /**
2590 * Retrieves whether or not a visible row update can be detected by calling the method <code>ResultSet.rowUpdated</code>.
2591 *
2592 * @return <code>true</code> if changes are detected by the result set type; <code>false</code> otherwise
2593 * @since 1.2 (JDBC 2.0)
2594 */
2595 Boolean isScrollSensitiveResultSetUpdatesAreDetected();
2596
2597 /**
2598 * Sets whether or not a visible row update can be detected by calling the method <code>ResultSet.rowUpdated</code>.
2599 *
2600 * @param scrollSensitiveResultSetUpdatesAreDetected <code>true</code> if changes are detected by the result set type;
2601 * <code>false</code> otherwise
2602 * @since 1.2 (JDBC 2.0)
2603 */
2604 void setScrollSensitiveResultSetUpdatesAreDetected( Boolean scrollSensitiveResultSetUpdatesAreDetected );
2605
2606 /**
2607 * Retrieves whether or not a visible row delete can be detected by calling the method <code>ResultSet.rowDeleted</code>. If
2608 * the method <code>deletesAreDetected</code> returns <code>false</code>, it means that deleted rows are removed from the
2609 * result set.
2610 *
2611 * @return <code>true</code> if deletes are detected by the given result set type; <code>false</code> otherwise
2612 * @since 1.2 (JDBC 2.0)
2613 */
2614 Boolean isForwardOnlyResultSetDeletesAreDetected();
2615
2616 /**
2617 * Sets whether or not a visible row delete can be detected by calling the method <code>ResultSet.rowDeleted</code>. If the
2618 * method <code>deletesAreDetected</code> returns <code>false</code>, it means that deleted rows are removed from the result
2619 * set.
2620 *
2621 * @param forwardOnlyResultSetDeletesAreDetected <code>true</code> if deletes are detected by the given result set type;
2622 * <code>false</code> otherwise
2623 * @since 1.2 (JDBC 2.0)
2624 */
2625 void setForwardOnlyResultSetDeletesAreDetected( Boolean forwardOnlyResultSetDeletesAreDetected );
2626
2627 /**
2628 * Retrieves whether or not a visible row delete can be detected by calling the method <code>ResultSet.rowDeleted</code>. If
2629 * the method <code>deletesAreDetected</code> returns <code>false</code>, it means that deleted rows are removed from the
2630 * result set.
2631 *
2632 * @return <code>true</code> if deletes are detected by the given result set type; <code>false</code> otherwise
2633 * @since 1.2 (JDBC 2.0)
2634 */
2635 Boolean isScrollInsensitiveResultSetDeletesAreDetected();
2636
2637 /**
2638 * Sets whether or not a visible row delete can be detected by calling the method <code>ResultSet.rowDeleted</code>. If the
2639 * method <code>deletesAreDetected</code> returns <code>false</code>, it means that deleted rows are removed from the result
2640 * set.
2641 *
2642 * @param scrollInsensitiveResultSetDeletesAreDetected <code>true</code> if deletes are detected by the given result set type;
2643 * <code>false</code> otherwise
2644 * @since 1.2 (JDBC 2.0)
2645 */
2646 void setScrollInsensitiveResultSetDeletesAreDetected( Boolean scrollInsensitiveResultSetDeletesAreDetected );
2647
2648 /**
2649 * Retrieves whether or not a visible row delete can be detected by calling the method <code>ResultSet.rowDeleted</code>. If
2650 * the method <code>deletesAreDetected</code> returns <code>false</code>, it means that deleted rows are removed from the
2651 * result set.
2652 *
2653 * @return <code>true</code> if deletes are detected by the given result set type; <code>false</code> otherwise
2654 * @since 1.2 (JDBC 2.0)
2655 */
2656 Boolean isScrollSensitiveResultSetDeletesAreDetected();
2657
2658 /**
2659 * Sets whether or not a visible row delete can be detected by calling the method <code>ResultSet.rowDeleted</code>. If the
2660 * method <code>deletesAreDetected</code> returns <code>false</code>, it means that deleted rows are removed from the result
2661 * set.
2662 *
2663 * @param scrollSensitiveResultSetDeletesAreDetected <code>true</code> if deletes are detected by the given result set type;
2664 * <code>false</code> otherwise
2665 * @since 1.2 (JDBC 2.0)
2666 */
2667 void setScrollSensitiveResultSetDeletesAreDetected( Boolean scrollSensitiveResultSetDeletesAreDetected );
2668
2669 /**
2670 * Retrieves whether or not a visible row insert can be detected by calling the method <code>ResultSet.rowInserted</code>.
2671 *
2672 * @return <code>true</code> if changes are detected by the specified result set type; <code>false</code> otherwise
2673 * @since 1.2 (JDBC 2.0)
2674 */
2675 Boolean isForwardOnlyResultInsertsAreDetected();
2676
2677 /**
2678 * Sets whether or not a visible row insert can be detected by calling the method <code>ResultSet.rowInserted</code>.
2679 *
2680 * @param forwardOnlyResultInsertsAreDetected <code>true</code> if changes are detected by the specified result set type;
2681 * <code>false</code> otherwise
2682 * @since 1.2 (JDBC 2.0)
2683 */
2684 void setForwardOnlyResultInsertsAreDetected( Boolean forwardOnlyResultInsertsAreDetected );
2685
2686 /**
2687 * Retrieves whether or not a visible row insert can be detected by calling the method <code>ResultSet.rowInserted</code>.
2688 *
2689 * @return <code>true</code> if changes are detected by the specified result set type; <code>false</code> otherwise
2690 * @since 1.2 (JDBC 2.0)
2691 */
2692 Boolean isScrollInsensitiveResultInsertsAreDetected();
2693
2694 /**
2695 * Sets whether or not a visible row insert can be detected by calling the method <code>ResultSet.rowInserted</code>.
2696 *
2697 * @param scrollInsensitiveResultInsertsAreDetected <code>true</code> if changes are detected by the specified result set
2698 * type; <code>false</code> otherwise
2699 * @since 1.2 (JDBC 2.0)
2700 */
2701 void setScrollInsensitiveResultInsertsAreDetected( Boolean scrollInsensitiveResultInsertsAreDetected );
2702
2703 /**
2704 * Retrieves whether or not a visible row insert can be detected by calling the method <code>ResultSet.rowInserted</code>.
2705 *
2706 * @return <code>true</code> if changes are detected by the specified result set type; <code>false</code> otherwise
2707 * @since 1.2 (JDBC 2.0)
2708 */
2709 Boolean isScrollSensitiveResultInsertsAreDetected();
2710
2711 /**
2712 * Sets whether or not a visible row insert can be detected by calling the method <code>ResultSet.rowInserted</code>.
2713 *
2714 * @param scrollSensitiveResultInsertsAreDetected <code>true</code> if changes are detected by the specified result set type;
2715 * <code>false</code> otherwise
2716 * @since 1.2 (JDBC 2.0)
2717 */
2718 void setScrollSensitiveResultInsertsAreDetected( Boolean scrollSensitiveResultInsertsAreDetected );
2719
2720 /**
2721 * Retrieves whether this database supports batch updates.
2722 *
2723 * @return <code>true</code> if this database supports batch upcates; <code>false</code> otherwise
2724 * @since 1.2 (JDBC 2.0)
2725 */
2726 Boolean isSupportsBatchUpdates();
2727
2728 /**
2729 * Sets whether this database supports batch updates.
2730 *
2731 * @param supportsBatchUpdates <code>true</code> if this database supports batch upcates; <code>false</code> otherwise
2732 * @since 1.2 (JDBC 2.0)
2733 */
2734 void setSupportsBatchUpdates( Boolean supportsBatchUpdates );
2735
2736 /**
2737 * Retrieves a description of the UDT available in the given catalog.
2738 *
2739 * @return a set of UDT available
2740 */
2741 Set<UserDefinedType> getUserDefinedTypes();
2742
2743 /**
2744 * Adds UDT
2745 *
2746 * @param udt the UDT to add
2747 */
2748 void addUserDefinedType( UserDefinedType udt );
2749
2750 /**
2751 * Deletes UDT
2752 *
2753 * @param udt the UDT to delete
2754 */
2755 void deleteUserDefinedType( UserDefinedType udt );
2756
2757 /**
2758 * Finds UDT by its name.
2759 *
2760 * @param catalog a catalog name; must match the catalog name as it is stored in the database; "" retrieves those without a
2761 * catalog; <code>null</code> means that the catalog name should not be used to narrow the search
2762 * @param schema a schema name; must match the schema name as it is stored in the database; "" retrieves those without a
2763 * schema; <code>null</code> means that the schema name should not be used to narrow the search
2764 * @param tableName a table name; must match the table name as it is stored in the database
2765 * @return table or null if not found
2766 */
2767 UserDefinedType findUserDefinedTypeByName( String catalog,
2768 String schema,
2769 String tableName );
2770
2771 // ===============================================================
2772 // ------------------- JDBC 3.0 ---------------------------------
2773 // ===============================================================
2774
2775 /**
2776 * Retrieves whether this database supports savepoints.
2777 *
2778 * @return <code>true</code> if savepoints are supported; <code>false</code> otherwise
2779 * @since 1.4 (JDBC 3.0)
2780 */
2781 Boolean isSupportsSavepoints();
2782
2783 /**
2784 * Sets whether this database supports savepoints.
2785 *
2786 * @param supportsSavepoints <code>true</code> if savepoints are supported; <code>false</code> otherwise
2787 * @since 1.4 (JDBC 3.0)
2788 */
2789 void setSupportsSavepoints( Boolean supportsSavepoints );
2790
2791 /**
2792 * Retrieves whether this database supports named parameters to callable statements.
2793 *
2794 * @return <code>true</code> if named parameters are supported; <code>false</code> otherwise
2795 * @since 1.4 (JDBC 3.0)
2796 */
2797 Boolean isSupportsNamedParameters();
2798
2799 /**
2800 * Sets whether this database supports named parameters to callable statements.
2801 *
2802 * @param supportsNamedParameters <code>true</code> if named parameters are supported; <code>false</code> otherwise
2803 * @since 1.4 (JDBC 3.0)
2804 */
2805 void setSupportsNamedParameters( Boolean supportsNamedParameters );
2806
2807 /**
2808 * Retrieves whether it is possible to have multiple <code>ResultSet</code> objects returned from a
2809 * <code>CallableStatement</code> object simultaneously.
2810 *
2811 * @return <code>true</code> if a <code>CallableStatement</code> object can return multiple <code>ResultSet</code> objects
2812 * simultaneously; <code>false</code> otherwise
2813 * @since 1.4 (JDBC 3.0)
2814 */
2815 Boolean isSupportsMultipleOpenResults();
2816
2817 /**
2818 * Sets whether it is possible to have multiple <code>ResultSet</code> objects returned from a <code>CallableStatement</code>
2819 * object simultaneously.
2820 *
2821 * @param supportsMultipleOpenResults <code>true</code> if a <code>CallableStatement</code> object can return multiple
2822 * <code>ResultSet</code> objects simultaneously; <code>false</code> otherwise
2823 * @since 1.4 (JDBC 3.0)
2824 */
2825 void setSupportsMultipleOpenResults( Boolean supportsMultipleOpenResults );
2826
2827 /**
2828 * Retrieves whether auto-generated keys can be retrieved after a statement has been executed.
2829 *
2830 * @return <code>true</code> if auto-generated keys can be retrieved after a statement has executed; <code>false</code>
2831 * otherwise
2832 * @since 1.4 (JDBC 3.0)
2833 */
2834 Boolean isSupportsGetGeneratedKeys();
2835
2836 /**
2837 * Sets whether auto-generated keys can be retrieved after a statement has been executed.
2838 *
2839 * @param supportsGetGeneratedKeys <code>true</code> if auto-generated keys can be retrieved after a statement has executed;
2840 * <code>false</code> otherwise
2841 * @since 1.4 (JDBC 3.0)
2842 */
2843 void setSupportsGetGeneratedKeys( Boolean supportsGetGeneratedKeys );
2844
2845 /**
2846 * Retrieves whether this database supports the given result set holdability.
2847 *
2848 * @return <code>true</code> if so; <code>false</code> otherwise
2849 * @see java.sql.Connection
2850 * @since 1.4 (JDBC 3.0)
2851 */
2852 Boolean isSupportsResultSetHoldCurrorsOverCommitHoldability();
2853
2854 /**
2855 * Sets whether this database supports the given result set holdability.
2856 *
2857 * @param supportsResultSetHoldCurrorsOverCommitHoldability <code>true</code> if so; <code>false</code> otherwise
2858 * @see java.sql.Connection
2859 * @since 1.4 (JDBC 3.0)
2860 */
2861 void setSupportsResultSetHoldCurrorsOverCommitHoldability( Boolean supportsResultSetHoldCurrorsOverCommitHoldability );
2862
2863 /**
2864 * Retrieves whether this database supports the given result set holdability.
2865 *
2866 * @return <code>true</code> if so; <code>false</code> otherwise
2867 * @see java.sql.Connection
2868 * @since 1.4 (JDBC 3.0)
2869 */
2870 Boolean isSupportsResultSetCloseCurrorsAtCommitHoldability();
2871
2872 /**
2873 * Sets whether this database supports the given result set holdability.
2874 *
2875 * @param supportsResultSetCloseCurrorsAtCommitHoldability <code>true</code> if so; <code>false</code> otherwise
2876 * @see java.sql.Connection
2877 * @since 1.4 (JDBC 3.0)
2878 */
2879 void setSupportsResultSetCloseCurrorsAtCommitHoldability( Boolean supportsResultSetCloseCurrorsAtCommitHoldability );
2880
2881 /**
2882 * Retrieves the default holdability of this <code>ResultSet</code> object.
2883 *
2884 * @return the default holdability; either <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
2885 * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
2886 * @since 1.4
2887 */
2888 ResultSetHoldabilityType getResultSetHoldabilityType();
2889
2890 /**
2891 * Sets the default holdability of this <code>ResultSet</code> object.
2892 *
2893 * @param resultSetHoldabilityType the ResultSetHoldabilityType
2894 * the default holdability; either <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
2895 * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
2896 * @since 1.4
2897 */
2898 void setResultSetHoldabilityType( ResultSetHoldabilityType resultSetHoldabilityType );
2899
2900 /**
2901 * Retrieves the major version number of the underlying database.
2902 *
2903 * @return the underlying database's major version
2904 * @since 1.4 (JDBC 3.0)
2905 */
2906 Integer getDatabaseMajorVersion();
2907
2908 /**
2909 * Sets the major version number of the underlying database.
2910 *
2911 * @param databaseMajorVersion the underlying database's major version
2912 * @since 1.4 (JDBC 3.0)
2913 */
2914 void setDatabaseMajorVersion( Integer databaseMajorVersion );
2915
2916 /**
2917 * Retrieves the minor version number of the underlying database.
2918 *
2919 * @return underlying database's minor version
2920 * @since 1.4 (JDBC 3.0)
2921 */
2922 Integer getDatabaseMinorVersion();
2923
2924 /**
2925 * Sets the minor version number of the underlying database.
2926 *
2927 * @param databaseMinorVersion underlying database's minor version
2928 * @since 1.4 (JDBC 3.0)
2929 */
2930 void setDatabaseMinorVersion( Integer databaseMinorVersion );
2931
2932 /**
2933 * Retrieves the major JDBC version number for this driver.
2934 *
2935 * @return JDBC version major number
2936 * @since 1.4 (JDBC 3.0)
2937 */
2938 Integer getJDBCMajorVersion();
2939
2940 /**
2941 * Sets the major JDBC version number for this driver.
2942 *
2943 * @param jdbcMajorVersion JDBC version major number
2944 * @since 1.4 (JDBC 3.0)
2945 */
2946 void setJDBCMajorVersion( Integer jdbcMajorVersion );
2947
2948 /**
2949 * Retrieves the minor JDBC version number for this driver.
2950 *
2951 * @return JDBC version minor number
2952 * @since 1.4 (JDBC 3.0)
2953 */
2954 Integer getJDBCMinorVersion();
2955
2956 /**
2957 * Sets the minor JDBC version number for this driver.
2958 *
2959 * @param jdbcMinorVersion JDBC version minor number
2960 * @since 1.4 (JDBC 3.0)
2961 */
2962 void setJDBCMinorVersion( Integer jdbcMinorVersion );
2963
2964 /**
2965 * Indicates whether the SQLSTATE returned by <code>SQLException.getSQLState</code> is X/Open (now known as Open Group) SQL
2966 * CLI or SQL99.
2967 *
2968 * @return the type of SQLSTATE; one of: sqlStateXOpen or sqlStateSQL99
2969 * @since 1.4 (JDBC 3.0)
2970 */
2971 SQLStateType getSQLStateType();
2972
2973 /**
2974 * Indicates whether the SQLSTATE returned by <code>SQLException.getSQLState</code> is X/Open (now known as Open Group) SQL
2975 * CLI or SQL99.
2976 *
2977 * @param sqlStateType the type of SQLSTATE; one of: sqlStateXOpen or sqlStateSQL99
2978 * @since 1.4 (JDBC 3.0)
2979 */
2980 void setSQLStateType( SQLStateType sqlStateType );
2981
2982 /**
2983 * Indicates whether updates made to a LOB are made on a copy or directly to the LOB.
2984 *
2985 * @return <code>true</code> if updates are made to a copy of the LOB; <code>false</code> if updates are made directly to the
2986 * LOB
2987 * @since 1.4 (JDBC 3.0)
2988 */
2989 Boolean isLocatorsUpdateCopy();
2990
2991 /**
2992 * Indicates whether updates made to a LOB are made on a copy or directly to the LOB.
2993 *
2994 * @param locatorsUpdateCopy <code>true</code> if updates are made to a copy of the LOB; <code>false</code> if updates are
2995 * made directly to the LOB
2996 * @since 1.4 (JDBC 3.0)
2997 */
2998 void setLocatorsUpdateCopy( Boolean locatorsUpdateCopy );
2999
3000 /**
3001 * Retrieves whether this database supports statement pooling.
3002 *
3003 * @return <code>true</code> if so; <code>false</code> otherwise
3004 * @since 1.4 (JDBC 3.0)
3005 */
3006 Boolean isSupportsStatementPooling();
3007
3008 /**
3009 * Sets whether this database supports statement pooling.
3010 *
3011 * @param supportsStatementPooling <code>true</code> if so; <code>false</code> otherwise
3012 * @since 1.4 (JDBC 3.0)
3013 */
3014 void setSupportsStatementPooling( Boolean supportsStatementPooling );
3015
3016 }