Java API By Example, From Geeks To Geeks.

1 2 /** 3  * RmiJdbc client/server JDBC Driver 4  * (C) GIE Dyade (Groupe BULL / INRIA Research Center) 1997 5  * 6  * @version 1.0 7  * @author Pierre-Yves Gibello (pierreyves.gibello@experlog.com) 8  */ 9 10 package org.objectweb.rmijdbc; 11 12 import java.sql.*; 13 import java.rmi.RemoteException ; 14 15 /** 16  * This class provides information about the database as a whole. 17  * 18  * <P>Many of the methods here return lists of information in ResultSets. 19  * You can use the normal ResultSet methods such as getString and getInt 20  * to retrieve the data from these ResultSets. If a given form of 21  * metadata is not available, these methods should throw a SQLException. 22  * 23  * <P>Some of these methods take arguments that are String patterns. These 24  * arguments all have names such as fooPattern. Within a pattern String, "%" 25  * means match any substring of 0 or more characters, and "_" means match 26  * any one character. Only metadata entries matching the search pattern 27  * are returned. If a search pattern argument is set to a null ref, it means 28  * that argument's criteria should be dropped from the search. 29  * 30  * <P>A SQLException will be thrown if a driver does not support a meta 31  * data method. In the case of methods that return a ResultSet, 32  * either a ResultSet (which may be empty) is returned or a 33  * SQLException is thrown. 34  */ 35 interface RJDatabaseMetaDataInterface extends java.rmi.Remote { 36 37   //---------------------------------------------------------------------- 38 // First, a variety of minor information about the target database. 39 40     /** 41      * Can all the procedures returned by getProcedures be called by the 42      * current user? 43      * 44      * @return true if so 45      */ 46   boolean allProceduresAreCallable() throws RemoteException , SQLException; 47 48     /** 49      * Can all the tables returned by getTable be SELECTed by the 50      * current user? 51      * 52      * @return true if so 53      */ 54   boolean allTablesAreSelectable() throws RemoteException , SQLException; 55 56     /** 57      * What's the url for this database? 58      * 59      * @return the url or null if it can't be generated 60      */ 61   String getURL() throws RemoteException , SQLException; 62 63     /** 64      * What's our user name as known to the database? 65      * 66      * @return our database user name 67      */ 68   String getUserName() throws RemoteException , SQLException; 69 70     /** 71      * Is the database in read-only mode? 72      * 73      * @return true if so 74      */ 75   boolean isReadOnly() throws RemoteException , SQLException; 76 77     /** 78      * Are NULL values sorted high? 79      * 80      * @return true if so 81      */ 82   boolean nullsAreSortedHigh() throws RemoteException , SQLException; 83 84     /** 85      * Are NULL values sorted low? 86      * 87      * @return true if so 88      */ 89   boolean nullsAreSortedLow() throws RemoteException , SQLException; 90 91     /** 92      * Are NULL values sorted at the start regardless of sort order? 93      * 94      * @return true if so 95      */ 96   boolean nullsAreSortedAtStart() throws RemoteException , SQLException; 97 98     /** 99      * Are NULL values sorted at the end regardless of sort order? 100      * 101      * @return true if so 102      */ 103   boolean nullsAreSortedAtEnd() throws RemoteException , SQLException; 104 105     /** 106      * What's the name of this database product? 107      * 108      * @return database product name 109      */ 110   String getDatabaseProductName() throws RemoteException , SQLException; 111 112     /** 113      * What's the version of this database product? 114      * 115      * @return database version 116      */ 117   String getDatabaseProductVersion() throws RemoteException , SQLException; 118 119     /** 120      * What's the name of this JDBC driver? 121      * 122      * @return JDBC driver name 123      */ 124   String getDriverName() throws RemoteException , SQLException; 125 126     /** 127      * What's the version of this JDBC driver? 128      * 129      * @return JDBC driver version 130      */ 131   String getDriverVersion() throws RemoteException , SQLException; 132 133     /** 134      * What's this JDBC driver's major version number? 135      * 136      * @return JDBC driver major version 137      */ 138   int getDriverMajorVersion() throws RemoteException , SQLException; 139 140     /** 141      * What's this JDBC driver's minor version number? 142      * 143      * @return JDBC driver minor version number 144      */ 145   int getDriverMinorVersion() throws RemoteException , SQLException; 146 147     /** 148      * Does the database store tables in a local file? 149      * 150      * @return true if so 151      */ 152   boolean usesLocalFiles() throws RemoteException , SQLException; 153 154     /** 155      * Does the database use a file for each table? 156      * 157      * @return true if the database uses a local file for each table 158      */ 159   boolean usesLocalFilePerTable() throws RemoteException , SQLException; 160 161     /** 162      * Does the database treat mixed case unquoted SQL identifiers as 163      * case sensitive and as a result store them in mixed case? 164      * 165      * A JDBC-Compliant driver will always return false. 166      * 167      * @return true if so 168      */ 169   boolean supportsMixedCaseIdentifiers() throws RemoteException , SQLException; 170 171     /** 172      * Does the database treat mixed case unquoted SQL identifiers as 173      * case insensitive and store them in upper case? 174      * 175      * @return true if so 176      */ 177   boolean storesUpperCaseIdentifiers() throws RemoteException , SQLException; 178 179     /** 180      * Does the database treat mixed case unquoted SQL identifiers as 181      * case insensitive and store them in lower case? 182      * 183      * @return true if so 184      */ 185   boolean storesLowerCaseIdentifiers() throws RemoteException , SQLException; 186 187     /** 188      * Does the database treat mixed case unquoted SQL identifiers as 189      * case insensitive and store them in mixed case? 190      * 191      * @return true if so 192      */ 193   boolean storesMixedCaseIdentifiers() throws RemoteException , SQLException; 194 195     /** 196      * Does the database treat mixed case quoted SQL identifiers as 197      * case sensitive and as a result store them in mixed case? 198      * 199      * A JDBC-Compliant driver will always return false. 200      * 201      * @return true if so 202      */ 203   boolean supportsMixedCaseQuotedIdentifiers() 204   throws RemoteException , SQLException; 205 206     /** 207      * Does the database treat mixed case quoted SQL identifiers as 208      * case insensitive and store them in upper case? 209      * 210      * @return true if so 211      */ 212   boolean storesUpperCaseQuotedIdentifiers() 213   throws RemoteException , SQLException; 214 215     /** 216      * Does the database treat mixed case quoted SQL identifiers as 217      * case insensitive and store them in lower case? 218      * 219      * @return true if so 220      */ 221   boolean storesLowerCaseQuotedIdentifiers() 222   throws RemoteException , SQLException; 223 224     /** 225      * Does the database treat mixed case quoted SQL identifiers as 226      * case insensitive and store them in mixed case? 227      * 228      * @return true if so 229      */ 230   boolean storesMixedCaseQuotedIdentifiers() 231   throws RemoteException , SQLException; 232 233     /** 234      * What's the string used to quote SQL identifiers? 235      * This returns a space " " if identifier quoting isn't supported. 236      * 237      * A JDBC-Compliant driver always uses a double quote character. 238      * 239      * @return the quoting string 240      */ 241   String getIdentifierQuoteString() throws RemoteException , SQLException; 242 243     /** 244      * Get a comma separated list of all a database's SQL keywords 245      * that are NOT also SQL92 keywords. 246      * 247      * @return the list 248      */ 249   String getSQLKeywords() throws RemoteException , SQLException; 250 251     /** 252      * Get a comma separated list of math functions. 253      * 254      * @return the list 255      */ 256   String getNumericFunctions() throws RemoteException , SQLException; 257 258     /** 259      * Get a comma separated list of string functions. 260      * 261      * @return the list 262      */ 263   String getStringFunctions() throws RemoteException , SQLException; 264 265     /** 266      * Get a comma separated list of system functions. 267      * 268      * @return the list 269      */ 270   String getSystemFunctions() throws RemoteException , SQLException; 271 272     /** 273      * Get a comma separated list of time and date functions. 274      * 275      * @return the list 276      */ 277   String getTimeDateFunctions() throws RemoteException , SQLException; 278 279     /** 280      * This is the string that can be used to escape '_' or '%' in 281      * the string pattern style catalog search parameters. 282      * 283      * <P>The '_' character represents any single character. 284      * <P>The '%' character represents any sequence of zero or 285      * more characters. 286      * @return the string used to escape wildcard characters 287      */ 288   String getSearchStringEscape() throws RemoteException , SQLException; 289 290     /** 291      * Get all the "extra" characters that can be used in unquoted 292      * identifier names (those beyond a-z, A-Z, 0-9 and _). 293      * 294      * @return the string containing the extra characters 295      */ 296   String getExtraNameCharacters() throws RemoteException , SQLException; 297 298     //-------------------------------------------------------------------- 299 // Functions describing which features are supported. 300 301     /** 302      * Is "ALTER TABLE" with add column supported? 303      * 304      * @return true if so 305      */ 306   boolean supportsAlterTableWithAddColumn() 307   throws RemoteException , SQLException; 308 309     /** 310      * Is "ALTER TABLE" with drop column supported? 311      * 312      * @return true if so 313      */ 314   boolean supportsAlterTableWithDropColumn() 315   throws RemoteException , SQLException; 316 317     /** 318      * Is column aliasing supported? 319      * 320      * <P>If so, the SQL AS clause can be used to provide names for 321      * computed columns or to provide alias names for columns as 322      * required. 323      * 324      * A JDBC-Compliant driver always returns true. 325      * 326      * @return true if so 327      */ 328   boolean supportsColumnAliasing() throws RemoteException , SQLException; 329 330     /** 331      * Are concatenations between NULL and non-NULL values NULL? 332      * 333      * A JDBC-Compliant driver always returns true. 334      * 335      * @return true if so 336      */ 337   boolean nullPlusNonNullIsNull() throws RemoteException , SQLException; 338 339     /** 340      * Is the CONVERT function between SQL types supported? 341      * 342      * @return true if so 343      */ 344   boolean supportsConvert() throws RemoteException , SQLException; 345 346     /** 347      * Is CONVERT between the given SQL types supported? 348      * 349      * @param fromType the type to convert from 350      * @param toType the type to convert to 351      * @return true if so 352      * @see Types 353      */ 354   boolean supportsConvert(int fromType, int toType) 355   throws RemoteException , SQLException; 356 357     /** 358      * Are table correlation names supported? 359      * 360      * A JDBC-Compliant driver always returns true. 361      * 362      * @return true if so 363      */ 364   boolean supportsTableCorrelationNames() throws RemoteException , SQLException; 365 366     /** 367      * If table correlation names are supported, are they restricted 368      * to be different from the names of the tables? 369      * 370      * @return true if so 371      */ 372   boolean supportsDifferentTableCorrelationNames() 373   throws RemoteException , SQLException; 374 375     /** 376      * Are expressions in "ORDER BY" lists supported? 377      * 378      * @return true if so 379      */ 380   boolean supportsExpressionsInOrderBy() throws RemoteException , SQLException; 381 382     /** 383      * Can an "ORDER BY" clause use columns not in the SELECT? 384      * 385      * @return true if so 386      */ 387   boolean supportsOrderByUnrelated() throws RemoteException , SQLException; 388 389     /** 390      * Is some form of "GROUP BY" clause supported? 391      * 392      * @return true if so 393      */ 394   boolean supportsGroupBy() throws RemoteException , SQLException; 395 396     /** 397      * Can a "GROUP BY" clause use columns not in the SELECT? 398      * 399      * @return true if so 400      */ 401   boolean supportsGroupByUnrelated() throws RemoteException , SQLException; 402 403     /** 404      * Can a "GROUP BY" clause add columns not in the SELECT 405      * provided it specifies all the columns in the SELECT? 406      * 407      * @return true if so 408      */ 409   boolean supportsGroupByBeyondSelect() throws RemoteException , SQLException; 410 411     /** 412      * Is the escape character in "LIKE" clauses supported? 413      * 414      * A JDBC-Compliant driver always returns true. 415      * 416      * @return true if so 417      */ 418   boolean supportsLikeEscapeClause() throws RemoteException , SQLException; 419 420     /** 421      * Are multiple ResultSets from a single execute supported? 422      * 423      * @return true if so 424      */ 425   boolean supportsMultipleResultSets() throws RemoteException , SQLException; 426 427     /** 428      * Can we have multiple transactions open at once (on different 429      * connections)? 430      * 431      * @return true if so 432      */ 433   boolean supportsMultipleTransactions() throws RemoteException , SQLException; 434 435     /** 436      * Can columns be defined as non-nullable? 437      * 438      * A JDBC-Compliant driver always returns true. 439      * 440      * @return true if so 441      */ 442   boolean supportsNonNullableColumns() throws RemoteException , SQLException; 443 444     /** 445      * Is the ODBC Minimum SQL grammar supported? 446      * 447      * All JDBC-Compliant drivers must return true. 448      * 449      * @return true if so 450      */ 451   boolean supportsMinimumSQLGrammar() throws RemoteException , SQLException; 452 453     /** 454      * Is the ODBC Core SQL grammar supported? 455      * 456      * @return true if so 457      */ 458   boolean supportsCoreSQLGrammar() throws RemoteException , SQLException; 459 460     /** 461      * Is the ODBC Extended SQL grammar supported? 462      * 463      * @return true if so 464      */ 465   boolean supportsExtendedSQLGrammar() throws RemoteException , SQLException; 466 467     /** 468      * Is the ANSI92 entry level SQL grammar supported? 469      * 470      * All JDBC-Compliant drivers must return true. 471      * 472      * @return true if so 473      */ 474   boolean supportsANSI92EntryLevelSQL() throws RemoteException , SQLException; 475 476     /** 477      * Is the ANSI92 intermediate SQL grammar supported? 478      * 479      * @return true if so 480      */ 481   boolean supportsANSI92IntermediateSQL() throws RemoteException , SQLException; 482 483     /** 484      * Is the ANSI92 full SQL grammar supported? 485      * 486      * @return true if so 487      */ 488   boolean supportsANSI92FullSQL() throws RemoteException , SQLException; 489 490     /** 491      * Is the SQL Integrity Enhancement Facility supported? 492      * 493      * @return true if so 494      */ 495   boolean supportsIntegrityEnhancementFacility() 496   throws RemoteException , SQLException; 497 498     /** 499      * Is some form of outer join supported? 500      * 501      * @return true if so 502      */ 503   boolean supportsOuterJoins() throws RemoteException , SQLException; 504 505     /** 506      * Are full nested outer joins supported? 507      * 508      * @return true if so 509      */ 510   boolean supportsFullOuterJoins() throws RemoteException , SQLException; 511 512     /** 513      * Is there limited support for outer joins? (This will be true 514      * if supportFullOuterJoins is true.) 515      * 516      * @return true if so 517      */ 518   boolean supportsLimitedOuterJoins() throws RemoteException , SQLException; 519 520     /** 521      * What's the database vendor's preferred term for "schema"? 522      * 523      * @return the vendor term 524      */ 525   String getSchemaTerm() throws RemoteException , SQLException; 526 527     /** 528      * What's the database vendor's preferred term for "procedure"? 529      * 530      * @return the vendor term 531      */ 532   String getProcedureTerm() throws RemoteException , SQLException; 533 534     /** 535      * What's the database vendor's preferred term for "catalog"? 536      * 537      * @return the vendor term 538      */ 539   String getCatalogTerm() throws RemoteException , SQLException; 540 541     /** 542      * Does a catalog appear at the start of a qualified table name? 543      * (Otherwise it appears at the end) 544      * 545      * @return true if it appears at the start 546      */ 547   boolean isCatalogAtStart() throws RemoteException , SQLException; 548 549     /** 550      * What's the separator between catalog and table name? 551      * 552      * @return the separator string 553      */ 554   String getCatalogSeparator() throws RemoteException , SQLException; 555 556     /** 557      * Can a schema name be used in a data manipulation statement? 558      * 559      * @return true if so 560      */ 561   boolean supportsSchemasInDataManipulation() 562   throws RemoteException , SQLException; 563 564     /** 565      * Can a schema name be used in a procedure call statement? 566      * 567      * @return true if so 568      */ 569   boolean supportsSchemasInProcedureCalls() 570   throws RemoteException , SQLException; 571 572     /** 573      * Can a schema name be used in a table definition statement? 574      * 575      * @return true if so 576      */ 577   boolean supportsSchemasInTableDefinitions() 578   throws RemoteException , SQLException; 579 580     /** 581      * Can a schema name be used in an index definition statement? 582      * 583      * @return true if so 584      */ 585   boolean supportsSchemasInIndexDefinitions() 586   throws RemoteException , SQLException; 587 588     /** 589      * Can a schema name be used in a privilege definition statement? 590      * 591      * @return true if so 592      */ 593   boolean supportsSchemasInPrivilegeDefinitions() 594   throws RemoteException , SQLException; 595 596     /** 597      * Can a catalog name be used in a data manipulation statement? 598      * 599      * @return true if so 600      */ 601   boolean supportsCatalogsInDataManipulation() 602   throws RemoteException , SQLException; 603 604     /** 605      * Can a catalog name be used in a procedure call statement? 606      * 607      * @return true if so 608      */ 609   boolean supportsCatalogsInProcedureCalls() 610   throws RemoteException , SQLException; 611 612     /** 613      * Can a catalog name be used in a table definition statement? 614      * 615      * @return true if so 616      */ 617   boolean supportsCatalogsInTableDefinitions() 618   throws RemoteException , SQLException; 619 620     /** 621      * Can a catalog name be used in an index definition statement? 622      * 623      * @return true if so 624      */ 625   boolean supportsCatalogsInIndexDefinitions() 626   throws RemoteException , SQLException; 627 628     /** 629      * Can a catalog name be used in a privilege definition statement? 630      * 631      * @return true if so 632      */ 633   boolean supportsCatalogsInPrivilegeDefinitions() 634   throws RemoteException , SQLException; 635 636 637     /** 638      * Is positioned DELETE supported? 639      * 640      * @return true if so 641      */ 642   boolean supportsPositionedDelete() throws RemoteException , SQLException; 643 644     /** 645      * Is positioned UPDATE supported? 646      * 647      * @return true if so 648      */ 649   boolean supportsPositionedUpdate() throws RemoteException , SQLException; 650 651     /** 652      * Is SELECT for UPDATE supported? 653      * 654      * @return true if so 655      */ 656   boolean supportsSelectForUpdate() throws RemoteException , SQLException; 657 658     /** 659      * Are stored procedure calls using the stored procedure escape 660      * syntax supported? 661      * 662      * @return true if so 663      */ 664   boolean supportsStoredProcedures() throws RemoteException , SQLException; 665 666     /** 667      * Are subqueries in comparison expressions supported? 668      * 669      * A JDBC-Compliant driver always returns true. 670      * 671      * @return true if so 672      */ 673   boolean supportsSubqueriesInComparisons() 674   throws RemoteException , SQLException; 675 676     /** 677      * Are subqueries in 'exists' expressions supported? 678      * 679      * A JDBC-Compliant driver always returns true. 680      * 681      * @return true if so 682      */ 683   boolean supportsSubqueriesInExists() throws RemoteException , SQLException; 684 685     /** 686      * Are subqueries in 'in' statements supported? 687      * 688      * A JDBC-Compliant driver always returns true. 689      * 690      * @return true if so 691      */ 692   boolean supportsSubqueriesInIns() throws RemoteException , SQLException; 693 694     /** 695      * Are subqueries in quantified expressions supported? 696      * 697      * A JDBC-Compliant driver always returns true. 698      * 699      * @return true if so 700      */ 701   boolean supportsSubqueriesInQuantifieds() 702   throws RemoteException , SQLException; 703 704     /** 705      * Are correlated subqueries supported? 706      * 707      * A JDBC-Compliant driver always returns true. 708      * 709      * @return true if so 710      */ 711   boolean supportsCorrelatedSubqueries() throws RemoteException , SQLException; 712 713     /** 714      * Is SQL UNION supported? 715      * 716      * @return true if so 717      */ 718   boolean supportsUnion() throws RemoteException , SQLException; 719 720     /** 721      * Is SQL UNION ALL supported? 722      * 723      * @return true if so 724      */ 725   boolean supportsUnionAll() throws RemoteException , SQLException; 726 727     /** 728      * Can cursors remain open across commits? 729      * 730      * @return true if cursors always remain open; false if they might not remain open 731      */ 732   boolean supportsOpenCursorsAcrossCommit() 733   throws RemoteException , SQLException; 734 735     /** 736      * Can cursors remain open across rollbacks? 737      * 738      * @return true if cursors always remain open; false if they might not remain open 739      */ 740   boolean supportsOpenCursorsAcrossRollback() 741   throws RemoteException , SQLException; 742 743     /** 744      * Can statements remain open across commits? 745      * 746      * @return true if statements always remain open; false if they might not remain open 747      */ 748   boolean supportsOpenStatementsAcrossCommit() 749   throws RemoteException , SQLException; 750 751     /** 752      * Can statements remain open across rollbacks? 753      * 754      * @return true if statements always remain open; false if they might not remain open 755      */ 756   boolean supportsOpenStatementsAcrossRollback() 757   throws RemoteException , SQLException; 758 759    760 761     //---------------------------------------------------------------------- 762 // The following group of methods exposes various limitations 763 // based on the target database with the current driver. 764 // Unless otherwise specified, a result of zero means there is no 765 // limit, or the limit is not known. 766 767     /** 768      * How many hex characters can you have in an inline binary literal? 769      * 770      * @return max literal length 771      */ 772   int getMaxBinaryLiteralLength() throws RemoteException , SQLException; 773 774     /** 775      * What's the max length for a character literal? 776      * 777      * @return max literal length 778      */ 779   int getMaxCharLiteralLength() throws RemoteException , SQLException; 780 781     /** 782      * What's the limit on column name length? 783      * 784      * @return max literal length 785      */ 786   int getMaxColumnNameLength() throws RemoteException , SQLException; 787 788     /** 789      * What's the maximum number of columns in a "GROUP BY" clause? 790      * 791      * @return max number of columns 792      */ 793   int getMaxColumnsInGroupBy() throws RemoteException , SQLException; 794 795     /** 796      * What's the maximum number of columns allowed in an index? 797      * 798      * @return max columns 799      */ 800   int getMaxColumnsInIndex() throws RemoteException , SQLException; 801 802     /** 803      * What's the maximum number of columns in an "ORDER BY" clause? 804      * 805      * @return max columns 806      */ 807   int getMaxColumnsInOrderBy() throws RemoteException , SQLException; 808 809     /** 810      * What's the maximum number of columns in a "SELECT" list? 811      * 812      * @return max columns 813      */ 814   int getMaxColumnsInSelect() throws RemoteException , SQLException; 815 816     /** 817      * What's the maximum number of columns in a table? 818      * 819      * @return max columns 820      */ 821   int getMaxColumnsInTable() throws RemoteException , SQLException; 822 823     /** 824      * How many active connections can we have at a time to this database? 825      * 826      * @return max connections 827      */ 828   int getMaxConnections() throws RemoteException , SQLException; 829 830     /** 831      * What's the maximum cursor name length? 832      * 833      * @return max cursor name length in bytes 834      */ 835   int getMaxCursorNameLength() throws RemoteException , SQLException; 836 837     /** 838      * What's the maximum length of an index (in bytes)? 839      * 840      * @return max index length in bytes 841      */ 842   int getMaxIndexLength() throws RemoteException , SQLException; 843 844     /** 845      * What's the maximum length allowed for a schema name? 846      * 847      * @return max name length in bytes 848      */ 849   int getMaxSchemaNameLength() throws RemoteException , SQLException; 850 851     /** 852      * What's the maximum length of a procedure name? 853      * 854      * @return max name length in bytes 855      */ 856   int getMaxProcedureNameLength() throws RemoteException , SQLException; 857 858     /** 859      * What's the maximum length of a catalog name? 860      * 861      * @return max name length in bytes 862      */ 863   int getMaxCatalogNameLength() throws RemoteException , SQLException; 864 865     /** 866      * What's the maximum length of a single row? 867      * 868      * @return max row size in bytes 869      */ 870   int getMaxRowSize() throws RemoteException , SQLException; 871 872     /** 873      * Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY 874      * blobs? 875      * 876      * @return true if so 877      */ 878   boolean doesMaxRowSizeIncludeBlobs() throws RemoteException , SQLException; 879 880     /** 881      * What's the maximum length of a SQL statement? 882      * 883      * @return max length in bytes 884      */ 885   int getMaxStatementLength() throws RemoteException , SQLException; 886 887     /** 888      * How many active statements can we have open at one time to this 889      * database? 890      * 891      * @return the maximum 892      */ 893   int getMaxStatements() throws RemoteException , SQLException; 894 895     /** 896      * What's the maximum length of a table name? 897      * 898      * @return max name length in bytes 899      */ 900   int getMaxTableNameLength() throws RemoteException , SQLException; 901 902     /** 903      * What's the maximum number of tables in a SELECT? 904      * 905      * @return the maximum 906      */ 907   int getMaxTablesInSelect() throws RemoteException , SQLException; 908 909     /** 910      * What's the maximum length of a user name? 911      * 912      * @return max name length in bytes 913      */ 914   int getMaxUserNameLength() throws RemoteException , SQLException; 915 916     //---------------------------------------------------------------------- 917 918     /** 919      * What's the database's default transaction isolation level? The 920      * values are defined in java.sql.Connection. 921      * 922      * @return the default isolation level 923      * @see Connection 924      */ 925   int getDefaultTransactionIsolation() throws RemoteException , SQLException; 926 927     /** 928      * Are transactions supported? If not, commit is a noop and the 929      * isolation level is TRANSACTION_NONE. 930      * 931      * @return true if transactions are supported 932      */ 933   boolean supportsTransactions() throws RemoteException , SQLException; 934 935     /** 936      * Does the database support the given transaction isolation level? 937      * 938      * @param level the values are defined in java.sql.Connection 939      * @return true if so 940      * @see Connection 941      */ 942   boolean supportsTransactionIsolationLevel(int level) 943   throws RemoteException , SQLException; 944 945     /** 946      * Are both data definition and data manipulation statements 947      * within a transaction supported? 948      * 949      * @return true if so 950      */ 951   boolean supportsDataDefinitionAndDataManipulationTransactions() 952   throws RemoteException , SQLException; 953 954     /** 955      * Are only data manipulation statements within a transaction 956      * supported? 957      * 958      * @return true if so 959      */ 960   boolean supportsDataManipulationTransactionsOnly() 961   throws RemoteException , SQLException; 962 963     /** 964      * Does a data definition statement within a transaction force the 965      * transaction to commit? 966      * 967      * @return true if so 968      */ 969   boolean dataDefinitionCausesTransactionCommit() 970   throws RemoteException , SQLException; 971 972     /** 973      * Is a data definition statement within a transaction ignored? 974      * 975      * @return true if so 976      */ 977   boolean dataDefinitionIgnoredInTransactions() 978   throws RemoteException , SQLException; 979 980 981     /** 982      * Get a description of stored procedures available in a 983      * catalog. 984      * 985      * <P>Only procedure descriptions matching the schema and 986      * procedure name criteria are returned. They are ordered by 987      * PROCEDURE_SCHEM, and PROCEDURE_NAME. 988      * 989      * <P>Each procedure description has the the following columns: 990      * <OL> 991      * <LI><B>PROCEDURE_CAT</B> String => procedure catalog (may be null) 992      * <LI><B>PROCEDURE_SCHEM</B> String => procedure schema (may be null) 993      * <LI><B>PROCEDURE_NAME</B> String => procedure name 994      * <LI> reserved for future use 995      * <LI> reserved for future use 996      * <LI> reserved for future use 997      * <LI><B>REMARKS</B> String => explanatory comment on the procedure 998      * <LI><B>PROCEDURE_TYPE</B> short => kind of procedure: 999      * <UL> 1000     * <LI> procedureResultUnknown - May return a result 1001     * <LI> procedureNoResult - Does not return a result 1002     * <LI> procedureReturnsResult - Returns a result 1003     * </UL> 1004     * </OL> 1005     * 1006     * @param catalog a catalog name; "" retrieves those without a 1007     * catalog; null means drop catalog name from the selection criteria 1008     * @param schemaPattern a schema name pattern; "" retrieves those 1009     * without a schema 1010     * @param procedureNamePattern a procedure name pattern 1011     * @return RJResultSetInterface - each row is a procedure description 1012     * @see #getSearchStringEscape 1013     */ 1014  RJResultSetInterface getProcedures(String catalog, String schemaPattern, 1015   String procedureNamePattern) throws RemoteException , SQLException; 1016 1017    /** 1018     * Get a description of a catalog's stored procedure parameters 1019     * and result columns. 1020     * 1021     * <P>Only descriptions matching the schema, procedure and 1022     * parameter name criteria are returned. They are ordered by 1023     * PROCEDURE_SCHEM and PROCEDURE_NAME. Within this, the return value, 1024     * if any, is first. Next are the parameter descriptions in call 1025     * order. The column descriptions follow in column number order. 1026     * 1027     * <P>Each row in the RJResultSetInterface is a parameter description or 1028     * column description with the following fields: 1029     * <OL> 1030     * <LI><B>PROCEDURE_CAT</B> String => procedure catalog (may be null) 1031     * <LI><B>PROCEDURE_SCHEM</B> String => procedure schema (may be null) 1032     * <LI><B>PROCEDURE_NAME</B> String => procedure name 1033     * <LI><B>COLUMN_NAME</B> String => column/parameter name 1034     * <LI><B>COLUMN_TYPE</B> Short => kind of column/parameter: 1035     * <UL> 1036     * <LI> procedureColumnUnknown - nobody knows 1037     * <LI> procedureColumnIn - IN parameter 1038     * <LI> procedureColumnInOut - INOUT parameter 1039     * <LI> procedureColumnOut - OUT parameter 1040     * <LI> procedureColumnReturn - procedure return value 1041     * <LI> procedureColumnResult - result column in RJResultSetInterface 1042     * </UL> 1043     * <LI><B>DATA_TYPE</B> short => SQL type from java.sql.Types 1044     * <LI><B>TYPE_NAME</B> String => SQL type name 1045     * <LI><B>PRECISION</B> int => precision 1046     * <LI><B>LENGTH</B> int => length in bytes of data 1047     * <LI><B>SCALE</B> short => scale 1048     * <LI><B>RADIX</B> short => radix 1049     * <LI><B>NULLABLE</B> short => can it contain NULL? 1050     * <UL> 1051     * <LI> procedureNoNulls - does not allow NULL values 1052     * <LI> procedureNullable - allows NULL values 1053     * <LI> procedureNullableUnknown - nullability unknown 1054     * </UL> 1055     * <LI><B>REMARKS</B> String => comment describing parameter/column 1056     * </OL> 1057     * 1058     * <P><B>Note:</B> Some databases may not return the column 1059     * descriptions for a procedure. Additional columns beyond 1060     * REMARKS can be defined by the database. 1061     * 1062     * @param catalog a catalog name; "" retrieves those without a 1063     * catalog; null means drop catalog name from the selection criteria 1064     * @param schemaPattern a schema name pattern; "" retrieves those 1065     * without a schema 1066     * @param procedureNamePattern a procedure name pattern 1067     * @param columnNamePattern a column name pattern 1068     * @return RJResultSetInterface - each row is a stored procedure parameter or 1069     * column description 1070     * @see #getSearchStringEscape 1071     */ 1072  RJResultSetInterface getProcedureColumns(String catalog, 1073   String schemaPattern, 1074   String procedureNamePattern, 1075   String columnNamePattern) throws RemoteException , SQLException; 1076 1077    /** 1078     * Get a description of tables available in a catalog. 1079     * 1080     * <P>Only table descriptions matching the catalog, schema, table 1081     * name and type criteria are returned. They are ordered by 1082     * TABLE_TYPE, TABLE_SCHEM and TABLE_NAME. 1083     * 1084     * <P>Each table description has the following columns: 1085     * <OL> 1086     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 1087     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 1088     * <LI><B>TABLE_NAME</B> String => table name 1089     * <LI><B>TABLE_TYPE</B> String => table type. Typical types are "TABLE", 1090     * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", 1091     * "LOCAL TEMPORARY", "ALIAS", "SYNONYM". 1092     * <LI><B>REMARKS</B> String => explanatory comment on the table 1093     * </OL> 1094     * 1095     * <P><B>Note:</B> Some databases may not return information for 1096     * all tables. 1097     * 1098     * @param catalog a catalog name; "" retrieves those without a 1099     * catalog; null means drop catalog name from the selection criteria 1100     * @param schemaPattern a schema name pattern; "" retrieves those 1101     * without a schema 1102     * @param tableNamePattern a table name pattern 1103     * @param types a list of table types to include; null returns all types 1104     * @return RJResultSetInterface - each row is a table description 1105     * @see #getSearchStringEscape 1106     */ 1107  RJResultSetInterface getTables(String catalog, String schemaPattern, 1108  String tableNamePattern, String types[]) 1109  throws RemoteException , SQLException; 1110 1111    /** 1112     * Get the schema names available in this database. The results 1113     * are ordered by schema name. 1114     * 1115     * <P>The schema column is: 1116     * <OL> 1117     * <LI><B>TABLE_SCHEM</B> String => schema name 1118     * </OL> 1119     * 1120     * @return RJResultSetInterface - each row has a single String column that is a 1121     * schema name 1122     */ 1123  RJResultSetInterface getSchemas() throws RemoteException , SQLException; 1124 1125    /** 1126     * Get the catalog names available in this database. The results 1127     * are ordered by catalog name. 1128     * 1129     * <P>The catalog column is: 1130     * <OL> 1131     * <LI><B>TABLE_CAT</B> String => catalog name 1132     * </OL> 1133     * 1134     * @return RJResultSetInterface - each row has a single String column that is a 1135     * catalog name 1136     */ 1137  RJResultSetInterface getCatalogs() throws RemoteException , SQLException; 1138 1139    /** 1140     * Get the table types available in this database. The results 1141     * are ordered by table type. 1142     * 1143     * <P>The table type is: 1144     * <OL> 1145     * <LI><B>TABLE_TYPE</B> String => table type. Typical types are "TABLE", 1146     * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", 1147     * "LOCAL TEMPORARY", "ALIAS", "SYNONYM". 1148     * </OL> 1149     * 1150     * @return RJResultSetInterface - each row has a single String column that is a 1151     * table type 1152     */ 1153  RJResultSetInterface getTableTypes() throws RemoteException , SQLException; 1154 1155    /** 1156     * Get a description of table columns available in a catalog. 1157     * 1158     * <P>Only column descriptions matching the catalog, schema, table 1159     * and column name criteria are returned. They are ordered by 1160     * TABLE_SCHEM, TABLE_NAME and ORDINAL_POSITION. 1161     * 1162     * <P>Each column description has the following columns: 1163     * <OL> 1164     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 1165     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 1166     * <LI><B>TABLE_NAME</B> String => table name 1167     * <LI><B>COLUMN_NAME</B> String => column name 1168     * <LI><B>DATA_TYPE</B> short => SQL type from java.sql.Types 1169     * <LI><B>TYPE_NAME</B> String => Data source dependent type name 1170     * <LI><B>COLUMN_SIZE</B> int => column size. For char or date 1171     * types this is the maximum number of characters, for numeric or 1172     * decimal types this is precision. 1173     * <LI><B>BUFFER_LENGTH</B> is not used. 1174     * <LI><B>DECIMAL_DIGITS</B> int => the number of fractional digits 1175     * <LI><B>NUM_PREC_RADIX</B> int => Radix (typically either 10 or 2) 1176     * <LI><B>NULLABLE</B> int => is NULL allowed? 1177     * <UL> 1178     * <LI> columnNoNulls - might not allow NULL values 1179     * <LI> columnNullable - definitely allows NULL values 1180     * <LI> columnNullableUnknown - nullability unknown 1181     * </UL> 1182     * <LI><B>REMARKS</B> String => comment describing column (may be null) 1183     * <LI><B>COLUMN_DEF</B> String => default value (may be null) 1184     * <LI><B>SQL_DATA_TYPE</B> int => unused 1185     * <LI><B>SQL_DATETIME_SUB</B> int => unused 1186     * <LI><B>CHAR_OCTET_LENGTH</B> int => for char types the 1187     * maximum number of bytes in the column 1188     * <LI><B>ORDINAL_POSITION</B> int => index of column in table 1189     * (starting at 1) 1190     * <LI><B>IS_NULLABLE</B> String => "NO" means column definitely 1191     * does not allow NULL values; "YES" means the column might 1192     * allow NULL values. An empty string means nobody knows. 1193     * </OL> 1194     * 1195     * @param catalog a catalog name; "" retrieves those without a 1196     * catalog; null means drop catalog name from the selection criteria 1197     * @param schemaPattern a schema name pattern; "" retrieves those 1198     * without a schema 1199     * @param tableNamePattern a table name pattern 1200     * @param columnNamePattern a column name pattern 1201     * @return RJResultSetInterface - each row is a column description 1202     * @see #getSearchStringEscape 1203     */ 1204  RJResultSetInterface getColumns(String catalog, String schemaPattern, 1205   String tableNamePattern, String columnNamePattern) throws RemoteException , SQLException; 1206 1207    /** 1208     * Get a description of the access rights for a table's columns. 1209     * 1210     * <P>Only privileges matching the column name criteria are 1211     * returned. They are ordered by COLUMN_NAME and PRIVILEGE. 1212     * 1213     * <P>Each privilige description has the following columns: 1214     * <OL> 1215     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 1216     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 1217     * <LI><B>TABLE_NAME</B> String => table name 1218     * <LI><B>COLUMN_NAME</B> String => column name 1219     * <LI><B>GRANTOR</B> => grantor of access (may be null) 1220     * <LI><B>GRANTEE</B> String => grantee of access 1221     * <LI><B>PRIVILEGE</B> String => name of access (SELECT, 1222     * INSERT, UPDATE, REFRENCES, ...) 1223     * <LI><B>IS_GRANTABLE</B> String => "YES" if grantee is permitted 1224     * to grant to others; "NO" if not; null if unknown 1225     * </OL> 1226     * 1227     * @param catalog a catalog name; "" retrieves those without a 1228     * catalog; null means drop catalog name from the selection criteria 1229     * @param schema a schema name; "" retrieves those without a schema 1230     * @param table a table name 1231     * @param columnNamePattern a column name pattern 1232     * @return RJResultSetInterface - each row is a column privilege description 1233     * @see #getSearchStringEscape 1234     */ 1235  RJResultSetInterface getColumnPrivileges(String catalog, String schema, 1236   String table, String columnNamePattern) throws RemoteException , SQLException; 1237 1238    /** 1239     * Get a description of the access rights for each table available 1240     * in a catalog. Note that a table privilege applies to one or 1241     * more columns in the table. It would be wrong to assume that 1242     * this priviledge applies to all columns (this may be true for 1243     * some systems but is not true for all.) 1244     * 1245     * <P>Only privileges matching the schema and table name 1246     * criteria are returned. They are ordered by TABLE_SCHEM, 1247     * TABLE_NAME, and PRIVILEGE. 1248     * 1249     * <P>Each privilige description has the following columns: 1250     * <OL> 1251     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 1252     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 1253     * <LI><B>TABLE_NAME</B> String => table name 1254     * <LI><B>GRANTOR</B> => grantor of access (may be null) 1255     * <LI><B>GRANTEE</B> String => grantee of access 1256     * <LI><B>PRIVILEGE</B> String => name of access (SELECT, 1257     * INSERT, UPDATE, REFRENCES, ...) 1258     * <LI><B>IS_GRANTABLE</B> String => "YES" if grantee is permitted 1259     * to grant to others; "NO" if not; null if unknown 1260     * </OL> 1261     * 1262     * @param catalog a catalog name; "" retrieves those without a 1263     * catalog; null means drop catalog name from the selection criteria 1264     * @param schemaPattern a schema name pattern; "" retrieves those 1265     * without a schema 1266     * @param tableNamePattern a table name pattern 1267     * @return RJResultSetInterface - each row is a table privilege description 1268     * @see #getSearchStringEscape 1269     */ 1270  RJResultSetInterface getTablePrivileges(String catalog, String schemaPattern, 1271   String tableNamePattern) throws RemoteException , SQLException; 1272 1273    /** 1274     * Get a description of a table's optimal set of columns that 1275     * uniquely identifies a row. They are ordered by SCOPE. 1276     * 1277     * <P>Each column description has the following columns: 1278     * <OL> 1279     * <LI><B>SCOPE</B> short => actual scope of result 1280     * <UL> 1281     * <LI> bestRowTemporary - very temporary, while using row 1282     * <LI> bestRowTransaction - valid for remainder of current transaction 1283     * <LI> bestRowSession - valid for remainder of current session 1284     * </UL> 1285     * <LI><B>COLUMN_NAME</B> String => column name 1286     * <LI><B>DATA_TYPE</B> short => SQL data type from java.sql.Types 1287     * <LI><B>TYPE_NAME</B> String => Data source dependent type name 1288     * <LI><B>COLUMN_SIZE</B> int => precision 1289     * <LI><B>BUFFER_LENGTH</B> int => not used 1290     * <LI><B>DECIMAL_DIGITS</B> short => scale 1291     * <LI><B>PSEUDO_COLUMN</B> short => is this a pseudo column 1292     * like an Oracle ROWID 1293     * <UL> 1294     * <LI> bestRowUnknown - may or may not be pseudo column 1295     * <LI> bestRowNotPseudo - is NOT a pseudo column 1296     * <LI> bestRowPseudo - is a pseudo column 1297     * </UL> 1298     * </OL> 1299     * 1300     * @param catalog a catalog name; "" retrieves those without a 1301     * catalog; null means drop catalog name from the selection criteria 1302     * @param schema a schema name; "" retrieves those without a schema 1303     * @param table a table name 1304     * @param scope the scope of interest; use same values as SCOPE 1305     * @param nullable include columns that are nullable? 1306     * @return RJResultSetInterface - each row is a column description 1307     */ 1308  RJResultSetInterface getBestRowIdentifier(String catalog, String schema, 1309   String table, int scope, boolean nullable) throws RemoteException , SQLException; 1310   1311    /** 1312     * Get a description of a table's columns that are automatically 1313     * updated when any value in a row is updated. They are 1314     * unordered. 1315     * 1316     * <P>Each column description has the following columns: 1317     * <OL> 1318     * <LI><B>SCOPE</B> short => is not used 1319     * <LI><B>COLUMN_NAME</B> String => column name 1320     * <LI><B>DATA_TYPE</B> short => SQL data type from java.sql.Types 1321     * <LI><B>TYPE_NAME</B> String => Data source dependent type name 1322     * <LI><B>COLUMN_SIZE</B> int => precision 1323     * <LI><B>BUFFER_LENGTH</B> int => length of column value in bytes 1324     * <LI><B>DECIMAL_DIGITS</B> short => scale 1325     * <LI><B>PSEUDO_COLUMN</B> short => is this a pseudo column 1326     * like an Oracle ROWID 1327     * <UL> 1328     * <LI> versionColumnUnknown - may or may not be pseudo column 1329     * <LI> versionColumnNotPseudo - is NOT a pseudo column 1330     * <LI> versionColumnPseudo - is a pseudo column 1331     * </UL> 1332     * </OL> 1333     * 1334     * @param catalog a catalog name; "" retrieves those without a 1335     * catalog; null means drop catalog name from the selection criteria 1336     * @param schema a schema name; "" retrieves those without a schema 1337     * @param table a table name 1338     * @return RJResultSetInterface - each row is a column description 1339     */ 1340  RJResultSetInterface getVersionColumns(String catalog, String schema, 1341    String table) throws RemoteException , SQLException; 1342   1343    /** 1344     * Get a description of a table's primary key columns. They 1345     * are ordered by COLUMN_NAME. 1346     * 1347     * <P>Each primary key column description has the following columns: 1348     * <OL> 1349     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 1350     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 1351     * <LI><B>TABLE_NAME</B> String => table name 1352     * <LI><B>COLUMN_NAME</B> String => column name 1353     * <LI><B>KEY_SEQ</B> short => sequence number within primary key 1354     * <LI><B>PK_NAME</B> String => primary key name (may be null) 1355     * </OL> 1356     * 1357     * @param catalog a catalog name; "" retrieves those without a 1358     * catalog; null means drop catalog name from the selection criteria 1359     * @param schema a schema name pattern; "" retrieves those 1360     * without a schema 1361     * @param table a table name 1362     * @return RJResultSetInterface - each row is a primary key column description 1363     */ 1364  RJResultSetInterface getPrimaryKeys(String catalog, String schema, 1365   String table) throws RemoteException , SQLException; 1366 1367    /** 1368     * Get a description of the primary key columns that are 1369     * referenced by a table's foreign key columns (the primary keys 1370     * imported by a table). They are ordered by PKTABLE_CAT, 1371     * PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ. 1372     * 1373     * <P>Each primary key column description has the following columns: 1374     * <OL> 1375     * <LI><B>PKTABLE_CAT</B> String => primary key table catalog 1376     * being imported (may be null) 1377     * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema 1378     * being imported (may be null) 1379     * <LI><B>PKTABLE_NAME</B> String => primary key table name 1380     * being imported 1381     * <LI><B>PKCOLUMN_NAME</B> String => primary key column name 1382     * being imported 1383     * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be null) 1384     * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be null) 1385     * <LI><B>FKTABLE_NAME</B> String => foreign key table name 1386     * <LI><B>FKCOLUMN_NAME</B> String => foreign key column name 1387     * <LI><B>KEY_SEQ</B> short => sequence number within foreign key 1388     * <LI><B>UPDATE_RULE</B> short => What happens to 1389     * foreign key when primary is updated: 1390     * <UL> 1391     * <LI> importedNoAction - do not allow update of primary 1392     * key if it has been imported 1393     * <LI> importedKeyCascade - change imported key to agree 1394     * with primary key update 1395     * <LI> importedKeySetNull - change imported key to NULL if 1396     * its primary key has been updated 1397     * <LI> importedKeySetDefault - change imported key to default values 1398     * if its primary key has been updated 1399     * <LI> importedKeyRestrict - same as importedKeyNoAction 1400     * (for ODBC 2.x compatibility) 1401     * </UL> 1402     * <LI><B>DELETE_RULE</B> short => What happens to 1403     * the foreign key when primary is deleted. 1404     * <UL> 1405     * <LI> importedKeyNoAction - do not allow delete of primary 1406     * key if it has been imported 1407     * <LI> importedKeyCascade - delete rows that import a deleted key 1408     * <LI> importedKeySetNull - change imported key to NULL if 1409     * its primary key has been deleted 1410     * <LI> importedKeyRestrict - same as importedKeyNoAction 1411     * (for ODBC 2.x compatibility) 1412     * <LI> importedKeySetDefault - change imported key to default if 1413     * its primary key has been deleted 1414     * </UL> 1415     * <LI><B>FK_NAME</B> String => foreign key name (may be null) 1416     * <LI><B>PK_NAME</B> String => primary key name (may be null) 1417     * <LI><B>DEFERRABILITY</B> short => can the evaluation of foreign key 1418     * constraints be deferred until commit 1419     * <UL> 1420     * <LI> importedKeyInitiallyDeferred - see SQL92 for definition 1421     * <LI> importedKeyInitiallyImmediate - see SQL92 for definition 1422     * <LI> importedKeyNotDeferrable - see SQL92 for definition 1423     * </UL> 1424     * </OL> 1425     * 1426     * @param catalog a catalog name; "" retrieves those without a 1427     * catalog; null means drop catalog name from the selection criteria 1428     * @param schema a schema name pattern; "" retrieves those 1429     * without a schema 1430     * @param table a table name 1431     * @return RJResultSetInterface - each row is a primary key column description 1432     * @see #getExportedKeys 1433     */ 1434  RJResultSetInterface getImportedKeys(String catalog, String schema, 1435   String table) throws RemoteException , SQLException; 1436 1437    /** 1438     * Get a description of the foreign key columns that reference a 1439     * table's primary key columns (the foreign keys exported by a 1440     * table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM, 1441     * FKTABLE_NAME, and KEY_SEQ. 1442     * 1443     * <P>Each foreign key column description has the following columns: 1444     * <OL> 1445     * <LI><B>PKTABLE_CAT</B> String => primary key table catalog (may be null) 1446     * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema (may be null) 1447     * <LI><B>PKTABLE_NAME</B> String => primary key table name 1448     * <LI><B>PKCOLUMN_NAME</B> String => primary key column name 1449     * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be null) 1450     * being exported (may be null) 1451     * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be null) 1452     * being exported (may be null) 1453     * <LI><B>FKTABLE_NAME</B> String => foreign key table name 1454     * being exported 1455     * <LI><B>FKCOLUMN_NAME</B> String => foreign key column name 1456     * being exported 1457     * <LI><B>KEY_SEQ</B> short => sequence number within foreign key 1458     * <LI><B>UPDATE_RULE</B> short => What happens to 1459     * foreign key when primary is updated: 1460     * <UL> 1461     * <LI> importedNoAction - do not allow update of primary 1462     * key if it has been imported 1463     * <LI> importedKeyCascade - change imported key to agree 1464     * with primary key update 1465     * <LI> importedKeySetNull - change imported key to NULL if 1466     * its primary key has been updated 1467     * <LI> importedKeySetDefault - change imported key to default values 1468     * if its primary key has been updated 1469     * <LI> importedKeyRestrict - same as importedKeyNoAction 1470     * (for ODBC 2.x compatibility) 1471     * </UL> 1472     * <LI><B>DELETE_RULE</B> short => What happens to 1473     * the foreign key when primary is deleted. 1474     * <UL> 1475     * <LI> importedKeyNoAction - do not allow delete of primary 1476     * key if it has been imported 1477     * <LI> importedKeyCascade - delete rows that import a deleted key 1478     * <LI> importedKeySetNull - change imported key to NULL if 1479     * its primary key has been deleted 1480     * <LI> importedKeyRestrict - same as importedKeyNoAction 1481     * (for ODBC 2.x compatibility) 1482     * <LI> importedKeySetDefault - change imported key to default if 1483     * its primary key has been deleted 1484     * </UL> 1485     * <LI><B>FK_NAME</B> String => foreign key name (may be null) 1486     * <LI><B>PK_NAME</B> String => primary key name (may be null) 1487     * <LI><B>DEFERRABILITY</B> short => can the evaluation of foreign key 1488     * constraints be deferred until commit 1489     * <UL> 1490     * <LI> importedKeyInitiallyDeferred - see SQL92 for definition 1491     * <LI> importedKeyInitiallyImmediate - see SQL92 for definition 1492     * <LI> importedKeyNotDeferrable - see SQL92 for definition 1493     * </UL> 1494     * </OL> 1495     * 1496     * @param catalog a catalog name; "" retrieves those without a 1497     * catalog; null means drop catalog name from the selection criteria 1498     * @param schema a schema name pattern; "" retrieves those 1499     * without a schema 1500     * @param table a table name 1501     * @return RJResultSetInterface - each row is a foreign key column description 1502     * @see #getImportedKeys 1503     */ 1504  RJResultSetInterface getExportedKeys(String catalog, String schema, 1505   String table) throws RemoteException , SQLException; 1506 1507    /** 1508     * Get a description of the foreign key columns in the foreign key 1509     * table that reference the primary key columns of the primary key 1510     * table (describe how one table imports another's key.) This 1511     * should normally return a single foreign key/primary key pair 1512     * (most tables only import a foreign key from a table once.) They 1513     * are ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and 1514     * KEY_SEQ. 1515     * 1516     * <P>Each foreign key column description has the following columns: 1517     * <OL> 1518     * <LI><B>PKTABLE_CAT</B> String => primary key table catalog (may be null) 1519     * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema (may be null) 1520     * <LI><B>PKTABLE_NAME</B> String => primary key table name 1521     * <LI><B>PKCOLUMN_NAME</B> String => primary key column name 1522     * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be null) 1523     * being exported (may be null) 1524     * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be null) 1525     * being exported (may be null) 1526     * <LI><B>FKTABLE_NAME</B> String => foreign key table name 1527     * being exported 1528     * <LI><B>FKCOLUMN_NAME</B> String => foreign key column name 1529     * being exported 1530     * <LI><B>KEY_SEQ</B> short => sequence number within foreign key 1531     * <LI><B>UPDATE_RULE</B> short => What happens to 1532     * foreign key when primary is updated: 1533     * <UL> 1534     * <LI> importedNoAction - do not allow update of primary 1535     * key if it has been imported 1536     * <LI> importedKeyCascade - change imported key to agree 1537     * with primary key update 1538     * <LI> importedKeySetNull - change imported key to NULL if 1539     * its primary key has been updated 1540     * <LI> importedKeySetDefault - change imported key to default values 1541     * if its primary key has been updated 1542     * <LI> importedKeyRestrict - same as importedKeyNoAction 1543     * (for ODBC 2.x compatibility) 1544     * </UL> 1545     * <LI><B>DELETE_RULE</B> short => What happens to 1546     * the foreign key when primary is deleted. 1547     * <UL> 1548     * <LI> importedKeyNoAction - do not allow delete of primary 1549     * key if it has been imported 1550     * <LI> importedKeyCascade - delete rows that import a deleted key 1551     * <LI> importedKeySetNull - change imported key to NULL if 1552     * its primary key has been deleted 1553     * <LI> importedKeyRestrict - same as importedKeyNoAction 1554     * (for ODBC 2.x compatibility) 1555     * <LI> importedKeySetDefault - change imported key to default if 1556     * its primary key has been deleted 1557     * </UL> 1558     * <LI><B>FK_NAME</B> String => foreign key name (may be null) 1559     * <LI><B>PK_NAME</B> String => primary key name (may be null) 1560     * <LI><B>DEFERRABILITY</B> short => can the evaluation of foreign key 1561     * constraints be deferred until commit 1562     * <UL> 1563     * <LI> importedKeyInitiallyDeferred - see SQL92 for definition 1564     * <LI> importedKeyInitiallyImmediate - see SQL92 for definition 1565     * <LI> importedKeyNotDeferrable - see SQL92 for definition 1566     * </UL> 1567     * </OL> 1568     * 1569     * @param primaryCatalog a catalog name; "" retrieves those without a 1570     * catalog; null means drop catalog name from the selection criteria 1571     * @param primarySchema a schema name pattern; "" retrieves those 1572     * without a schema 1573     * @param primaryTable the table name that exports the key 1574     * @param foreignCatalog a catalog name; "" retrieves those without a 1575     * catalog; null means drop catalog name from the selection criteria 1576     * @param foreignSchema a schema name pattern; "" retrieves those 1577     * without a schema 1578     * @param foreignTable the table name that imports the key 1579     * @return RJResultSetInterface - each row is a foreign key column description 1580     * @see #getImportedKeys 1581     */ 1582  RJResultSetInterface getCrossReference( 1583   String primaryCatalog, String primarySchema, String primaryTable, 1584   String foreignCatalog, String foreignSchema, String foreignTable) 1585   throws RemoteException , SQLException; 1586 1587    /** 1588     * Get a description of all the standard SQL types supported by 1589     * this database. They are ordered by DATA_TYPE and then by how 1590     * closely the data type maps to the corresponding JDBC SQL type. 1591     * 1592     * <P>Each type description has the following columns: 1593     * <OL> 1594     * <LI><B>TYPE_NAME</B> String => Type name 1595     * <LI><B>DATA_TYPE</B> short => SQL data type from java.sql.Types 1596     * <LI><B>PRECISION</B> int => maximum precision 1597     * <LI><B>LITERAL_PREFIX</B> String => prefix used to quote a literal 1598     * (may be null) 1599     * <LI><B>LITERAL_SUFFIX</B> String => suffix used to quote a literal 1600            (may be null) 1601     * <LI><B>CREATE_PARAMS</B> String => parameters used in creating 1602     * the type (may be null) 1603     * <LI><B>NULLABLE</B> short => can you use NULL for this type? 1604     * <UL> 1605     * <LI> typeNoNulls - does not allow NULL values 1606     * <LI> typeNullable - allows NULL values 1607     * <LI> typeNullableUnknown - nullability unknown 1608     * </UL> 1609     * <LI><B>CASE_SENSITIVE</B> boolean=> is it case sensitive? 1610     * <LI><B>SEARCHABLE</B> short => can you use "WHERE" based on this type: 1611     * <UL> 1612     * <LI> typePredNone - No support 1613     * <LI> typePredChar - Only supported with WHERE .. LIKE 1614     * <LI> typePredBasic - Supported except for WHERE .. LIKE 1615     * <LI> typeSearchable - Supported for all WHERE .. 1616     * </UL> 1617     * <LI><B>UNSIGNED_ATTRIBUTE</B> boolean => is it unsigned? 1618     * <LI><B>FIXED_PREC_SCALE</B> boolean => can it be a money value? 1619     * <LI><B>AUTO_INCREMENT</B> boolean => can it be used for an 1620     * auto-increment value? 1621     * <LI><B>LOCAL_TYPE_NAME</B> String => localized version of type name 1622     * (may be null) 1623     * <LI><B>MINIMUM_SCALE</B> short => minimum scale supported 1624     * <LI><B>MAXIMUM_SCALE</B> short => maximum scale supported 1625     * <LI><B>SQL_DATA_TYPE</B> int => unused 1626     * <LI><B>SQL_DATETIME_SUB</B> int => unused 1627     * <LI><B>NUM_PREC_RADIX</B> int => usually 2 or 10 1628     * </OL> 1629     * 1630     * @return RJResultSetInterface - each row is a SQL type description 1631     */ 1632  RJResultSetInterface getTypeInfo() throws RemoteException , SQLException; 1633   1634    /** 1635     * Get a description of a table's indices and statistics. They are 1636     * ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION. 1637     * 1638     * <P>Each index column description has the following columns: 1639     * <OL> 1640     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 1641     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 1642     * <LI><B>TABLE_NAME</B> String => table name 1643     * <LI><B>NON_UNIQUE</B> boolean => Can index values be non-unique? 1644     * false when TYPE is tableIndexStatistic 1645     * <LI><B>INDEX_QUALIFIER</B> String => index catalog (may be null); 1646     * null when TYPE is tableIndexStatistic 1647     * <LI><B>INDEX_NAME</B> String => index name; null when TYPE is 1648     * tableIndexStatistic 1649     * <LI><B>TYPE</B> short => index type: 1650     * <UL> 1651     * <LI> tableIndexStatistic - this identifies table statistics that are 1652     * returned in conjuction with a table's index descriptions 1653     * <LI> tableIndexClustered - this is a clustered index 1654     * <LI> tableIndexHashed - this is a hashed index 1655     * <LI> tableIndexOther - this is some other style of index 1656     * </UL> 1657     * <LI><B>ORDINAL_POSITION</B> short => column sequence number 1658     * within index; zero when TYPE is tableIndexStatistic 1659     * <LI><B>COLUMN_NAME</B> String => column name; null when TYPE is 1660     * tableIndexStatistic 1661     * <LI><B>ASC_OR_DESC</B> String => column sort sequence, "A" => ascending, 1662     * "D" => descending, may be null if sort sequence is not supported; 1663     * null when TYPE is tableIndexStatistic 1664     * <LI><B>CARDINALITY</B> int => When TYPE is tableIndexStatistic, then 1665     * this is the number of rows in the table; otherwise, it is the 1666     * number of unique values in the index. 1667     * <LI><B>PAGES</B> int => When TYPE is tableIndexStatisic then 1668     * this is the number of pages used for the table, otherwise it 1669     * is the number of pages used for the current index. 1670     * <LI><B>FILTER_CONDITION</B> String => Filter condition, if any. 1671     * (may be null) 1672     * </OL> 1673     * 1674     * @param catalog a catalog name; "" retrieves those without a 1675     * catalog; null means drop catalog name from the selection criteria 1676     * @param schema a schema name pattern; "" retrieves those without a schema 1677     * @param table a table name 1678     * @param unique when true, return only indices for unique values; 1679     * when false, return indices regardless of whether unique or not 1680     * @param approximate when true, result is allowed to reflect approximate 1681     * or out of data values; when false, results are requested to be 1682     * accurate 1683     * @return RJResultSetInterface - each row is an index column description 1684     */ 1685  RJResultSetInterface getIndexInfo(String catalog, String schema, String table, 1686   boolean unique, boolean approximate) throws RemoteException , SQLException; 1687 1688    //--------------------------JDBC 2.0----------------------------- 1689 1690    /** 1691     * JDBC 2.0 1692     * 1693     * Does the database support the given result set type? 1694     * 1695     * @param type defined in <code>java.sql.ResultSet</code> 1696     * @return <code>true</code> if so; <code>false</code> otherwise 1697     * @exception SQLException if a database access error occurs 1698     * @see Connection 1699     */ 1700    boolean supportsResultSetType(int type) throws RemoteException , SQLException; 1701 1702    /** 1703     * JDBC 2.0 1704     * 1705     * Does the database support the concurrency type in combination 1706     * with the given result set type? 1707     * 1708     * @param type defined in <code>java.sql.ResultSet</code> 1709     * @param concurrency type defined in <code>java.sql.ResultSet</code> 1710     * @return <code>true</code> if so; <code>false</code> otherwise 1711     * @exception SQLException if a database access error occurs 1712     * @see Connection 1713     */ 1714    boolean supportsResultSetConcurrency(int type, int concurrency) 1715      throws RemoteException , SQLException; 1716 1717    /** 1718     * JDBC 2.0 1719     * 1720     * Indicates whether a result set's own updates are visible. 1721     * 1722     * @param result set type, i.e. ResultSet.TYPE_XXX 1723     * @return <code>true</code> if updates are visible for the result set type; 1724     * <code>false</code> otherwise 1725     * @exception SQLException if a database access error occurs 1726     */ 1727    boolean ownUpdatesAreVisible(int type) throws RemoteException , SQLException; 1728 1729    /** 1730     * JDBC 2.0 1731     * 1732     * Indicates whether a result set's own deletes are visible. 1733     * 1734     * @param result set type, i.e. ResultSet.TYPE_XXX 1735     * @return <code>true</code> if deletes are visible for the result set type; 1736     * <code>false</code> otherwise 1737     * @exception SQLException if a database access error occurs 1738     */ 1739    boolean ownDeletesAreVisible(int type) throws RemoteException , SQLException; 1740    /** 1741     * JDBC 2.0 1742     * 1743     * Indicates whether a result set's own inserts are visible. 1744     * 1745     * @param result set type, i.e. ResultSet.TYPE_XXX 1746     * @return <code>true</code> if inserts are visible for the result set type; 1747     * <code>false</code> otherwise 1748     * @exception SQLException if a database access error occurs 1749     */ 1750    boolean ownInsertsAreVisible(int type) throws RemoteException , SQLException; 1751 1752    /** 1753     * JDBC 2.0 1754     * 1755     * Indicates whether updates made by others are visible. 1756     * 1757     * @param result set type, i.e. ResultSet.TYPE_XXX 1758     * @return <code>true</code> if updates made by others 1759     * are visible for the result set type; 1760     * <code>false</code> otherwise 1761     * @exception SQLException if a database access error occurs 1762     */ 1763    boolean othersUpdatesAreVisible(int type) throws RemoteException , SQLException; 1764 1765    /** 1766     * JDBC 2.0 1767     * 1768     * Indicates whether deletes made by others are visible. 1769     * 1770     * @param result set type, i.e. ResultSet.TYPE_XXX 1771     * @return <code>true</code> if deletes made by others 1772     * are visible for the result set type; 1773     * <code>false</code> otherwise 1774     * @exception SQLException if a database access error occurs 1775     */ 1776    boolean othersDeletesAreVisible(int type) throws RemoteException , SQLException; 1777    /** 1778     * JDBC 2.0 1779     * 1780     * Indicates whether inserts made by others are visible. 1781     * 1782     * @param result set type, i.e. ResultSet.TYPE_XXX 1783     * @return true if updates are visible for the result set type 1784     * @return <code>true</code> if inserts made by others 1785     * are visible for the result set type; 1786     * <code>false</code> otherwise 1787     * @exception SQLException if a database access error occurs 1788     */ 1789    boolean othersInsertsAreVisible(int type) throws RemoteException , SQLException; 1790 1791    /** 1792     * JDBC 2.0 1793     * 1794     * Indicates whether or not a visible row update can be detected by 1795     * calling the method <code>ResultSet.rowUpdated</code>. 1796     * 1797     * @param result set type, i.e. ResultSet.TYPE_XXX 1798     * @return <code>true</code> if changes are detected by the result set type; 1799     * <code>false</code> otherwise 1800     * @exception SQLException if a database access error occurs 1801     */ 1802    boolean updatesAreDetected(int type) throws RemoteException , SQLException; 1803 1804    /** 1805     * JDBC 2.0 1806     * 1807     * Indicates whether or not a visible row delete can be detected by 1808     * calling ResultSet.rowDeleted(). If deletesAreDetected() 1809     * returns false, then deleted rows are removed from the result set. 1810     * 1811     * @param result set type, i.e. ResultSet.TYPE_XXX 1812     * @return true if changes are detected by the resultset type 1813     * @exception SQLException if a database access error occurs 1814     */ 1815    boolean deletesAreDetected(int type) throws RemoteException , SQLException; 1816 1817    /** 1818     * JDBC 2.0 1819     * 1820     * Indicates whether or not a visible row insert can be detected 1821     * by calling ResultSet.rowInserted(). 1822     * 1823     * @param result set type, i.e. ResultSet.TYPE_XXX 1824     * @return true if changes are detected by the resultset type 1825     * @exception SQLException if a database access error occurs 1826     */ 1827    boolean insertsAreDetected(int type) throws RemoteException , SQLException; 1828 1829    /** 1830     * JDBC 2.0 1831     * 1832     * Indicates whether the driver supports batch updates. 1833     * @return true if the driver supports batch updates; false otherwise 1834     */ 1835    boolean supportsBatchUpdates() throws RemoteException , SQLException; 1836 1837    /** 1838     * JDBC 2.0 1839     * 1840     * Gets a description of the user-defined types defined in a particular 1841     * schema. Schema-specific UDTs may have type JAVA_OBJECT, STRUCT, 1842     * or DISTINCT. 1843     * 1844     * <P>Only types matching the catalog, schema, type name and type 1845     * criteria are returned. They are ordered by DATA_TYPE, TYPE_SCHEM 1846     * and TYPE_NAME. The type name parameter may be a fully-qualified 1847     * name. In this case, the catalog and schemaPattern parameters are 1848     * ignored. 1849     * 1850     * <P>Each type description has the following columns: 1851     * <OL> 1852     * <LI><B>TYPE_CAT</B> String => the type's catalog (may be null) 1853     * <LI><B>TYPE_SCHEM</B> String => type's schema (may be null) 1854     * <LI><B>TYPE_NAME</B> String => type name 1855     * <LI><B>CLASS_NAME</B> String => Java class name 1856     * <LI><B>DATA_TYPE</B> String => type value defined in java.sql.Types. 1857     * One of JAVA_OBJECT, STRUCT, or DISTINCT 1858     * <LI><B>REMARKS</B> String => explanatory comment on the type 1859     * </OL> 1860     * 1861     * <P><B>Note:</B> If the driver does not support UDTs, an empty 1862     * result set is returned. 1863     * 1864     * @param catalog a catalog name; "" retrieves those without a 1865     * catalog; null means drop catalog name from the selection criteria 1866     * @param schemaPattern a schema name pattern; "" retrieves those 1867     * without a schema 1868     * @param typeNamePattern a type name pattern; may be a fully-qualified 1869     * name 1870     * @param types a list of user-named types to include (JAVA_OBJECT, 1871     * STRUCT, or DISTINCT); null returns all types 1872     * @return ResultSet - each row is a type description 1873     * @exception SQLException if a database access error occurs 1874     */ 1875  RJResultSetInterface getUDTs(String catalog, String schemaPattern, 1876   String typeNamePattern, int[] types) 1877   throws RemoteException , SQLException; 1878 1879    /** 1880     * JDBC 2.0 1881     * Retrieves the connection that produced this metadata object. 1882     * 1883     * @return the connection that produced this metadata object 1884     */ 1885    Connection getConnection() throws RemoteException , SQLException; 1886 1887 1888    // ------------------- JDBC 3.0 ------------------------- 1889 1890    /** 1891     * Retrieves whether this database supports savepoints. 1892     * 1893     * @return <code>true</code> if savepoints are supported; 1894     * <code>false</code> otherwise 1895     * @exception SQLException if a database access error occurs 1896     * @since 1.4 1897     */ 1898    boolean supportsSavepoints() throws RemoteException , SQLException; 1899 1900    /** 1901     * Retrieves whether this database supports named parameters to callable 1902     * statements. 1903     * 1904     * @return <code>true</code> if named parameters are supported; 1905     * <code>false</code> otherwise 1906     * @exception SQLException if a database access error occurs 1907     * @since 1.4 1908     */ 1909    boolean supportsNamedParameters() throws RemoteException , SQLException; 1910 1911    /** 1912     * Retrieves whether it is possible to have multiple <code>ResultSet</code> objects 1913     * returned from a <code>CallableStatement</code> object 1914     * simultaneously. 1915     * 1916     * @return <code>true</code> if a <code>CallableStatement</code> object 1917     * can return multiple <code>ResultSet</code> objects 1918     * simultaneously; <code>false</code> otherwise 1919     * @exception SQLException if a datanase access error occurs 1920     * @since 1.4 1921     */ 1922    boolean supportsMultipleOpenResults() throws RemoteException , SQLException; 1923 1924    /** 1925     * Retrieves whether auto-generated keys can be retrieved after 1926     * a statement has been executed. 1927     * 1928     * @return <code>true</code> if auto-generated keys can be retrieved 1929     * after a statement has executed; <code>false</code> otherwise 1930     * @exception SQLException if a database access error occurs 1931     * @since 1.4 1932     */ 1933    boolean supportsGetGeneratedKeys() throws RemoteException , SQLException; 1934 1935    /** 1936     * Retrieves a description of the user-defined type (UDT) hierarchies defined in a 1937     * particular schema in this database. Only the immediate super type/ 1938     * sub type relationship is modeled. 1939     * <P> 1940     * Only supertype information for UDTs matching the catalog, 1941     * schema, and type name is returned. The type name parameter 1942     * may be a fully-qualified name. When the UDT name supplied is a 1943     * fully-qualified name, the catalog and schemaPattern parameters are 1944     * ignored. 1945     * <P> 1946     * If a UDT does not have a direct super type, it is not listed here. 1947     * A row of the <code>ResultSet</code> object returned by this method 1948     * describes the designated UDT and a direct supertype. A row has the following 1949     * columns: 1950     * <OL> 1951     * <LI><B>TYPE_CAT</B> String => the UDT's catalog (may be <code>null</code>) 1952     * <LI><B>TYPE_SCHEM</B> String => UDT's schema (may be <code>null</code>) 1953     * <LI><B>TYPE_NAME</B> String => type name of the UDT 1954     * <LI><B>SUPERTYPE_CAT</B> String => the direct super type's catalog 1955     * (may be <code>null</code>) 1956     * <LI><B>SUPERTYPE_SCHEM</B> String => the direct super type's schema 1957     * (may be <code>null</code>) 1958     * <LI><B>SUPERTYPE_NAME</B> String => the direct super type's name 1959     * </OL> 1960     * 1961     * <P><B>Note:</B> If the driver does not support type hierarchies, an 1962     * empty result set is returned. 1963     * 1964     * @param catalog a catalog name; "" retrieves those without a catalog; 1965     * <code>null</code> means drop catalog name from the selection criteria 1966     * @param schemaPattern a schema name pattern; "" retrieves those 1967     * without a schema 1968     * @param typeNamePattern a UDT name pattern; may be a fully-qualified 1969     * name 1970     * @return a <code>ResultSet</code> object in which a row gives information 1971     * about the designated UDT 1972     * @throws SQLException if a database access error occurs 1973     * @since 1.4 1974     */ 1975  RJResultSetInterface getSuperTypes(String catalog, String schemaPattern, 1976   String typeNamePattern) throws RemoteException , SQLException; 1977     1978    /** 1979     * Retrieves a description of the table hierarchies defined in a particular 1980     * schema in this database. 1981     * 1982     * <P>Only supertable information for tables matching the catalog, schema 1983     * and table name are returned. The table name parameter may be a fully- 1984     * qualified name, in which case, the catalog and schemaPattern parameters 1985     * are ignored. If a table does not have a super table, it is not listed here. 1986     * Supertables have to be defined in the same catalog and schema as the 1987     * sub tables. Therefore, the type description does not need to include 1988     * this information for the supertable. 1989     * 1990     * <P>Each type description has the following columns: 1991     * <OL> 1992     * <LI><B>TABLE_CAT</B> String => the type's catalog (may be <code>null</code>) 1993     * <LI><B>TABLE_SCHEM</B> String => type's schema (may be <code>null</code>) 1994     * <LI><B>TABLE_NAME</B> String => type name 1995     * <LI><B>SUPERTABLE_NAME</B> String => the direct super type's name 1996     * </OL> 1997     * 1998     * <P><B>Note:</B> If the driver does not support type hierarchies, an 1999     * empty result set is returned. 2000     * 2001     * @param catalog a catalog name; "" retrieves those without a catalog; 2002     * <code>null</code> means drop catalog name from the selection criteria 2003     * @param schemaPattern a schema name pattern; "" retrieves those 2004     * without a schema 2005     * @param tableNamePattern a table name pattern; may be a fully-qualified 2006     * name 2007     * @return a <code>ResultSet</code> object in which each row is a type description 2008     * @throws SQLException if a database access error occurs 2009     * @since 1.4 2010     */ 2011  RJResultSetInterface getSuperTables(String catalog, String schemaPattern, 2012   String tableNamePattern) throws RemoteException , SQLException; 2013 2014    /** 2015     * Indicates that <code>NULL</code> values might not be allowed. 2016     * <P> 2017     * A possible value for the column 2018     * <code>NULLABLE</code> in the <code>ResultSet</code> object 2019     * returned by the method <code>getAttributes</code>. 2020     */ 2021    short attributeNoNulls = 0; 2022 2023    /** 2024     * Indicates that <code>NULL</code> values are definitely allowed. 2025     * <P> 2026     * A possible value for the column <code>NULLABLE</code> 2027     * in the <code>ResultSet</code> object 2028     * returned by the method <code>getAttributes</code>. 2029     */ 2030    short attributeNullable = 1; 2031 2032    /** 2033     * Indicates that whether <code>NULL</code> values are allowed is not 2034     * known. 2035     * <P> 2036     * A possible value for the column <code>NULLABLE</code> 2037     * in the <code>ResultSet</code> object 2038     * returned by the method <code>getAttributes</code>. 2039     */ 2040    short attributeNullableUnknown = 2; 2041 2042    /** 2043     * Retrieves a description of the given attribute of the given type 2044     * for a user-defined type (UDT) that is available in the given schema 2045     * and catalog. 2046     * <P> 2047     * Descriptions are returned only for attributes of UDTs matching the 2048     * catalog, schema, type, and attribute name criteria. They are ordered by 2049     * TYPE_SCHEM, TYPE_NAME and ORDINAL_POSITION. This description 2050     * does not contain inherited attributes. 2051     * <P> 2052     * The <code>ResultSet</code> object that is returned has the following 2053     * columns: 2054     * <OL> 2055     * <LI><B>TYPE_CAT</B> String => type catalog (may be <code>null</code>) 2056     * <LI><B>TYPE_SCHEM</B> String => type schema (may be <code>null</code>) 2057     * <LI><B>TYPE_NAME</B> String => type name 2058     * <LI><B>ATTR_NAME</B> String => attribute name 2059     * <LI><B>DATA_TYPE</B> short => attribute type SQL type from java.sql.Types 2060     * <LI><B>ATTR_TYPE_NAME</B> String => Data source dependent type name. 2061     * For a UDT, the type name is fully qualified. For a REF, the type name is 2062     * fully qualified and represents the target type of the reference type. 2063     * <LI><B>ATTR_SIZE</B> int => column size. For char or date 2064     * types this is the maximum number of characters; for numeric or 2065     * decimal types this is precision. 2066     * <LI><B>DECIMAL_DIGITS</B> int => the number of fractional digits 2067     * <LI><B>NUM_PREC_RADIX</B> int => Radix (typically either 10 or 2) 2068     * <LI><B>NULLABLE</B> int => whether NULL is allowed 2069     * <UL> 2070     * <LI> attributeNoNulls - might not allow NULL values 2071     * <LI> attributeNullable - definitely allows NULL values 2072     * <LI> attributeNullableUnknown - nullability unknown 2073     * </UL> 2074     * <LI><B>REMARKS</B> String => comment describing column (may be <code>null</code>) 2075     * <LI><B>ATTR_DEF</B> String => default value (may be <code>null</code>) 2076     * <LI><B>SQL_DATA_TYPE</B> int => unused 2077     * <LI><B>SQL_DATETIME_SUB</B> int => unused 2078     * <LI><B>CHAR_OCTET_LENGTH</B> int => for char types the 2079     * maximum number of bytes in the column 2080     * <LI><B>ORDINAL_POSITION</B> int => index of column in table 2081     * (starting at 1) 2082     * <LI><B>IS_NULLABLE</B> String => "NO" means column definitely 2083     * does not allow NULL values; "YES" means the column might 2084     * allow NULL values. An empty string means unknown. 2085     * <LI><B>SCOPE_CATALOG</B> String => catalog of table that is the 2086     * scope of a reference attribute (<code>null</code> if DATA_TYPE isn't REF) 2087     * <LI><B>SCOPE_SCHEMA</B> String => schema of table that is the 2088     * scope of a reference attribute (<code>null</code> if DATA_TYPE isn't REF) 2089     * <LI><B>SCOPE_TABLE</B> String => table name that is the scope of a 2090     * reference attribute (<code>null</code> if the DATA_TYPE isn't REF) 2091     * <LI><B>SOURCE_DATA_TYPE</B> short => source type of a distinct type or user-generated 2092     * Ref type,SQL type from java.sql.Types (<code>null</code> if DATA_TYPE 2093     * isn't DISTINCT or user-generated REF) 2094     * </OL> 2095     * @param catalog a catalog name; must match the catalog name as it 2096     * is stored in the database; "" retrieves those without a catalog; 2097     * <code>null</code> means that the catalog name should not be used to narrow 2098     * the search 2099     * @param schemaPattern a schema name pattern; must match the schema name 2100     * as it is stored in the database; "" retrieves those without a schema; 2101     * <code>null</code> means that the schema name should not be used to narrow 2102     * the search 2103     * @param typeNamePattern a type name pattern; must match the 2104     * type name as it is stored in the database 2105     * @param attributeNamePattern an attribute name pattern; must match the attribute 2106     * name as it is declared in the database 2107     * @return a <code>ResultSet</code> object in which each row is an 2108     * attribute description 2109     * @exception SQLException if a database access error occurs 2110     * @since 1.4 2111     */ 2112  RJResultSetInterface getAttributes(String catalog, String schemaPattern, 2113   String typeNamePattern, String attributeNamePattern) 2114   throws RemoteException , SQLException; 2115 2116    /** 2117     * Retrieves whether this database supports the given result set holdability. 2118     * 2119     * @param holdability one of the following constants: 2120     * <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or 2121     * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT<code> 2122     * @return <code>true</code> if so; <code>false</code> otherwise 2123     * @exception SQLException if a database access error occurs 2124     * @see Connection 2125     * @since 1.4 2126     */ 2127  boolean supportsResultSetHoldability(int holdability) throws RemoteException , SQLException; 2128 2129    /** 2130     * Retrieves the default holdability of this <code>ResultSet</code> 2131     * object. 2132     * 2133     * @return the default holdability; either 2134     * <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or 2135     * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code> 2136     * @exception SQLException if a database access error occurs 2137     * @since 1.4 2138     */ 2139  int getResultSetHoldability() throws RemoteException , SQLException; 2140 2141    /** 2142     * Retrieves the major version number of the underlying database. 2143     * 2144     * @return the underlying database's major version 2145     * @exception SQLException if a database access error occurs 2146     * @since 1.4 2147     */ 2148    int getDatabaseMajorVersion() throws RemoteException , SQLException; 2149 2150    /** 2151     * Retrieves the minor version number of the underlying database. 2152     * 2153     * @return underlying database's minor version 2154     * @exception SQLException if a database access error occurs 2155     * @since 1.4 2156     */ 2157    int getDatabaseMinorVersion() throws RemoteException , SQLException; 2158 2159    /** 2160     * Retrieves the major JDBC version number for this 2161     * driver. 2162     * 2163     * @return JDBC version major number 2164     * @exception SQLException if a database access error occurs 2165     * @since 1.4 2166     */ 2167    int getJDBCMajorVersion() throws RemoteException , SQLException; 2168 2169    /** 2170     * Retrieves the minor JDBC version number for this 2171     * driver. 2172     * 2173     * @return JDBC version minor number 2174     * @exception SQLException if a database access error occurs 2175     * @since 1.4 2176     */ 2177    int getJDBCMinorVersion() throws RemoteException , SQLException; 2178 2179    /** 2180     * Indicates that the value is an 2181     * X/Open (now know as Open Group) SQL CLI SQLSTATE value. 2182     * <P> 2183     * A possible return value for the method 2184     * <code>SQLException.getSQLState</code>. 2185     * @since 1.4 2186     */ 2187    int sqlStateXOpen = 1; 2188 2189    /** 2190     * Indicates that the value is an SQL99 SQLSTATE value. 2191     * <P> 2192     * A possible return value for the method 2193     * <code>SQLException.getSQLState</code>. 2194     * @since 1.4 2195     */ 2196    int sqlStateSQL99 = 2; 2197 2198    /** 2199     * Indicates whether the SQLSTATEs returned by <code>SQLException.getSQLState</code> 2200     * is X/Open (now known as Open Group) SQL CLI or SQL99. 2201     * @return the type of SQLSTATEs, one of: 2202     * sqlStateXOpen or 2203     * sqlStateSQL99 2204     * @throws SQLException if a database access error occurs 2205     * @since 1.4 2206     */ 2207    int getSQLStateType() throws RemoteException , SQLException; 2208 2209    /** 2210     * Indicates whether updates made to a LOB are made on a copy or directly 2211     * to the LOB. 2212     * @return <code>true</code> if updates are made to a copy of the LOB; 2213     * <code>false</code> if updates are made directly to the LOB 2214     * @throws SQLException if a database access error occurs 2215     * @since 1.4 2216     */ 2217    boolean locatorsUpdateCopy() throws RemoteException , SQLException; 2218 2219    /** 2220     * Retrieves weather this database supports statement pooling. 2221     * 2222     * @return <code>true</code> is so; 2223           <code>false</code> otherwise 2224     * @throws SQLExcpetion if a database access error occurs 2225     * @since 1.4 2226     */ 2227    boolean supportsStatementPooling() throws RemoteException , SQLException; 2228 2229}; 2230 2231

A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame Popular Tags