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 }