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 public class RJDatabaseMetaData 36 implements java.sql.DatabaseMetaData , java.io.Serializable { 37 38   RJDatabaseMetaDataInterface rmiMetadata_; 39   Connection connection_; 40 41   public RJDatabaseMetaData(RJDatabaseMetaDataInterface d, Connection c) { 42     rmiMetadata_ = d; 43     connection_ = c; 44   } 45 46   //---------------------------------------------------------------------- 47 // First, a variety of minor information about the target database. 48 49   /** 50    * Can all the procedures returned by getProcedures be called by the 51    * current user? 52    * 53    * @return true if so 54    */ 55   public boolean allProceduresAreCallable() throws SQLException { 56     try { 57       return rmiMetadata_.allProceduresAreCallable(); 58     } catch(RemoteException e) { 59       throw new java.sql.SQLException (e.getMessage()); 60     } 61   } 62 63     /** 64      * Can all the tables returned by getTable be SELECTed by the 65      * current user? 66      * 67      * @return true if so 68      */ 69   public boolean allTablesAreSelectable() throws SQLException { 70     try { 71       return rmiMetadata_.allTablesAreSelectable(); 72     } catch(RemoteException e) { 73       throw new java.sql.SQLException (e.getMessage()); 74     } 75   } 76 77     /** 78      * What's the url for this database? 79      * 80      * @return the url or null if it can't be generated 81      */ 82   public String getURL() throws SQLException { 83     try { 84       return rmiMetadata_.getURL(); 85     } catch(RemoteException e) { 86       throw new java.sql.SQLException (e.getMessage()); 87     } 88   } 89 90     /** 91      * What's our user name as known to the database? 92      * 93      * @return our database user name 94      */ 95   public String getUserName() throws SQLException { 96     try { 97       return rmiMetadata_.getUserName(); 98     } catch(RemoteException e) { 99       throw new java.sql.SQLException (e.getMessage()); 100     } 101   } 102 103     /** 104      * Is the database in read-only mode? 105      * 106      * @return true if so 107      */ 108   public boolean isReadOnly() throws SQLException { 109     try { 110       return rmiMetadata_.isReadOnly(); 111     } catch(RemoteException e) { 112       throw new java.sql.SQLException (e.getMessage()); 113     } 114   } 115 116     /** 117      * Are NULL values sorted high? 118      * 119      * @return true if so 120      */ 121   public boolean nullsAreSortedHigh() throws SQLException { 122     try { 123       return rmiMetadata_.nullsAreSortedHigh(); 124     } catch(RemoteException e) { 125       throw new java.sql.SQLException (e.getMessage()); 126     } 127   } 128 129     /** 130      * Are NULL values sorted low? 131      * 132      * @return true if so 133      */ 134   public boolean nullsAreSortedLow() throws SQLException { 135     try { 136       return rmiMetadata_.nullsAreSortedLow(); 137     } catch(RemoteException e) { 138       throw new java.sql.SQLException (e.getMessage()); 139     } 140   } 141 142     /** 143      * Are NULL values sorted at the start regardless of sort order? 144      * 145      * @return true if so 146      */ 147   public boolean nullsAreSortedAtStart() throws SQLException { 148     try { 149       return rmiMetadata_.nullsAreSortedAtStart(); 150     } catch(RemoteException e) { 151       throw new java.sql.SQLException (e.getMessage()); 152     } 153   } 154 155     /** 156      * Are NULL values sorted at the end regardless of sort order? 157      * 158      * @return true if so 159      */ 160   public boolean nullsAreSortedAtEnd() throws SQLException { 161     try { 162       return rmiMetadata_.nullsAreSortedAtEnd(); 163     } catch(RemoteException e) { 164       throw new java.sql.SQLException (e.getMessage()); 165     } 166   } 167 168     /** 169      * What's the name of this database product? 170      * 171      * @return database product name 172      */ 173   public String getDatabaseProductName() throws SQLException { 174     try { 175       return rmiMetadata_.getDatabaseProductName(); 176     } catch(RemoteException e) { 177       throw new java.sql.SQLException (e.getMessage()); 178     } 179   } 180 181     /** 182      * What's the version of this database product? 183      * 184      * @return database version 185      */ 186   public String getDatabaseProductVersion() throws SQLException { 187     try { 188       return rmiMetadata_.getDatabaseProductVersion(); 189     } catch(RemoteException e) { 190       throw new java.sql.SQLException (e.getMessage()); 191     } 192   } 193 194     /** 195      * What's the name of this JDBC driver? 196      * 197      * @return JDBC driver name 198      */ 199   public String getDriverName() throws SQLException { 200     try { 201       return rmiMetadata_.getDriverName(); 202     } catch(RemoteException e) { 203       throw new java.sql.SQLException (e.getMessage()); 204     } 205   } 206 207     /** 208      * What's the version of this JDBC driver? 209      * 210      * @return JDBC driver version 211      */ 212   public String getDriverVersion() throws SQLException { 213     try { 214       return rmiMetadata_.getDriverVersion(); 215     } catch(RemoteException e) { 216       throw new java.sql.SQLException (e.getMessage()); 217     } 218   } 219 220     /** 221      * What's this JDBC driver's major version number? 222      * 223      * @return JDBC driver major version 224      */ 225   public int getDriverMajorVersion() { 226     try { 227       return rmiMetadata_.getDriverMajorVersion(); 228     } catch(Exception e) { 229       return 0; 230     } 231   } 232 233     /** 234      * What's this JDBC driver's minor version number? 235      * 236      * @return JDBC driver minor version number 237      */ 238   public int getDriverMinorVersion() { 239     try { 240       return rmiMetadata_.getDriverMinorVersion(); 241     } catch(Exception e) { 242       return 0; 243     } 244   } 245 246     /** 247      * Does the database store tables in a local file? 248      * 249      * @return true if so 250      */ 251   public boolean usesLocalFiles() throws SQLException { 252     try { 253       return rmiMetadata_.usesLocalFiles(); 254     } catch(RemoteException e) { 255       throw new java.sql.SQLException (e.getMessage()); 256     } 257   } 258 259     /** 260      * Does the database use a file for each table? 261      * 262      * @return true if the database uses a local file for each table 263      */ 264   public boolean usesLocalFilePerTable() throws SQLException { 265     try { 266       return rmiMetadata_.usesLocalFilePerTable(); 267     } catch(RemoteException e) { 268       throw new java.sql.SQLException (e.getMessage()); 269     } 270   } 271 272     /** 273      * Does the database treat mixed case unquoted SQL identifiers as 274      * case sensitive and as a result store them in mixed case? 275      * 276      * A JDBC-Compliant driver will always return false. 277      * 278      * @return true if so 279      */ 280   public boolean supportsMixedCaseIdentifiers() throws SQLException { 281     try { 282       return rmiMetadata_.supportsMixedCaseIdentifiers(); 283     } catch(RemoteException e) { 284       throw new java.sql.SQLException (e.getMessage()); 285     } 286   } 287 288     /** 289      * Does the database treat mixed case unquoted SQL identifiers as 290      * case insensitive and store them in upper case? 291      * 292      * @return true if so 293      */ 294   public boolean storesUpperCaseIdentifiers() throws SQLException { 295     try { 296       return rmiMetadata_.storesUpperCaseIdentifiers(); 297     } catch(RemoteException e) { 298       throw new java.sql.SQLException (e.getMessage()); 299     } 300   } 301 302     /** 303      * Does the database treat mixed case unquoted SQL identifiers as 304      * case insensitive and store them in lower case? 305      * 306      * @return true if so 307      */ 308   public boolean storesLowerCaseIdentifiers() throws SQLException { 309     try { 310       return rmiMetadata_.storesLowerCaseIdentifiers(); 311     } catch(RemoteException e) { 312       throw new java.sql.SQLException (e.getMessage()); 313     } 314   } 315 316     /** 317      * Does the database treat mixed case unquoted SQL identifiers as 318      * case insensitive and store them in mixed case? 319      * 320      * @return true if so 321      */ 322   public boolean storesMixedCaseIdentifiers() throws SQLException { 323     try { 324       return rmiMetadata_.storesMixedCaseIdentifiers(); 325     } catch(RemoteException e) { 326       throw new java.sql.SQLException (e.getMessage()); 327     } 328   } 329 330     /** 331      * Does the database treat mixed case quoted SQL identifiers as 332      * case sensitive and as a result store them in mixed case? 333      * 334      * A JDBC-Compliant driver will always return false. 335      * 336      * @return true if so 337      */ 338   public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException { 339     try { 340       return rmiMetadata_.supportsMixedCaseQuotedIdentifiers(); 341     } catch(RemoteException e) { 342       throw new java.sql.SQLException (e.getMessage()); 343     } 344   } 345 346     /** 347      * Does the database treat mixed case quoted SQL identifiers as 348      * case insensitive and store them in upper case? 349      * 350      * @return true if so 351      */ 352   public boolean storesUpperCaseQuotedIdentifiers() throws SQLException { 353     try { 354       return rmiMetadata_.storesUpperCaseQuotedIdentifiers(); 355     } catch(RemoteException e) { 356       throw new java.sql.SQLException (e.getMessage()); 357     } 358   } 359 360     /** 361      * Does the database treat mixed case quoted SQL identifiers as 362      * case insensitive and store them in lower case? 363      * 364      * @return true if so 365      */ 366   public boolean storesLowerCaseQuotedIdentifiers() throws SQLException { 367     try { 368       return rmiMetadata_.storesLowerCaseQuotedIdentifiers(); 369     } catch(RemoteException e) { 370       throw new java.sql.SQLException (e.getMessage()); 371     } 372   } 373 374     /** 375      * Does the database treat mixed case quoted SQL identifiers as 376      * case insensitive and store them in mixed case? 377      * 378      * @return true if so 379      */ 380   public boolean storesMixedCaseQuotedIdentifiers() throws SQLException { 381     try { 382       return rmiMetadata_.storesMixedCaseQuotedIdentifiers(); 383     } catch(RemoteException e) { 384       throw new java.sql.SQLException (e.getMessage()); 385     } 386   } 387 388     /** 389      * What's the string used to quote SQL identifiers? 390      * This returns a space " " if identifier quoting isn't supported. 391      * 392      * A JDBC-Compliant driver always uses a double quote character. 393      * 394      * @return the quoting string 395      */ 396   public String getIdentifierQuoteString() throws SQLException { 397     try { 398       return rmiMetadata_.getIdentifierQuoteString(); 399     } catch(RemoteException e) { 400       throw new java.sql.SQLException (e.getMessage()); 401     } 402   } 403 404     /** 405      * Get a comma separated list of all a database's SQL keywords 406      * that are NOT also SQL92 keywords. 407      * 408      * @return the list 409      */ 410   public String getSQLKeywords() throws SQLException { 411     try { 412       return rmiMetadata_.getSQLKeywords(); 413     } catch(RemoteException e) { 414       throw new java.sql.SQLException (e.getMessage()); 415     } 416   } 417 418     /** 419      * Get a comma separated list of math functions. 420      * 421      * @return the list 422      */ 423   public String getNumericFunctions() throws SQLException { 424     try { 425       return rmiMetadata_.getNumericFunctions(); 426     } catch(RemoteException e) { 427       throw new java.sql.SQLException (e.getMessage()); 428     } 429   } 430 431     /** 432      * Get a comma separated list of string functions. 433      * 434      * @return the list 435      */ 436   public String getStringFunctions() throws SQLException { 437     try { 438       return rmiMetadata_.getStringFunctions(); 439     } catch(RemoteException e) { 440       throw new java.sql.SQLException (e.getMessage()); 441     } 442   } 443 444     /** 445      * Get a comma separated list of system functions. 446      * 447      * @return the list 448      */ 449   public String getSystemFunctions() throws SQLException { 450     try { 451       return rmiMetadata_.getSystemFunctions(); 452     } catch(RemoteException e) { 453       throw new java.sql.SQLException (e.getMessage()); 454     } 455   } 456 457     /** 458      * Get a comma separated list of time and date functions. 459      * 460      * @return the list 461      */ 462   public String getTimeDateFunctions() throws SQLException { 463     try { 464       return rmiMetadata_.getTimeDateFunctions(); 465     } catch(RemoteException e) { 466       throw new java.sql.SQLException (e.getMessage()); 467     } 468   } 469 470     /** 471      * This is the string that can be used to escape '_' or '%' in 472      * the string pattern style catalog search parameters. 473      * 474      * <P>The '_' character represents any single character. 475      * <P>The '%' character represents any sequence of zero or 476      * more characters. 477      * @return the string used to escape wildcard characters 478      */ 479   public String getSearchStringEscape() throws SQLException { 480     try { 481       return rmiMetadata_.getSearchStringEscape(); 482     } catch(RemoteException e) { 483       throw new java.sql.SQLException (e.getMessage()); 484     } 485   } 486 487     /** 488      * Get all the "extra" characters that can be used in unquoted 489      * identifier names (those beyond a-z, A-Z, 0-9 and _). 490      * 491      * @return the string containing the extra characters 492      */ 493   public String getExtraNameCharacters() throws SQLException { 494     try { 495       return rmiMetadata_.getExtraNameCharacters(); 496     } catch(RemoteException e) { 497       throw new java.sql.SQLException (e.getMessage()); 498     } 499   } 500 501     //-------------------------------------------------------------------- 502 // Functions describing which features are supported. 503 504     /** 505      * Is "ALTER TABLE" with add column supported? 506      * 507      * @return true if so 508      */ 509   public boolean supportsAlterTableWithAddColumn() throws SQLException { 510     try { 511       return rmiMetadata_.supportsAlterTableWithAddColumn(); 512     } catch(RemoteException e) { 513       throw new java.sql.SQLException (e.getMessage()); 514     } 515   } 516 517     /** 518      * Is "ALTER TABLE" with drop column supported? 519      * 520      * @return true if so 521      */ 522   public boolean supportsAlterTableWithDropColumn() throws SQLException { 523     try { 524       return rmiMetadata_.supportsAlterTableWithDropColumn(); 525     } catch(RemoteException e) { 526       throw new java.sql.SQLException (e.getMessage()); 527     } 528   } 529 530     /** 531      * Is column aliasing supported? 532      * 533      * <P>If so, the SQL AS clause can be used to provide names for 534      * computed columns or to provide alias names for columns as 535      * required. 536      * 537      * A JDBC-Compliant driver always returns true. 538      * 539      * @return true if so 540      */ 541   public boolean supportsColumnAliasing() throws SQLException { 542     try { 543       return rmiMetadata_.supportsColumnAliasing(); 544     } catch(RemoteException e) { 545       throw new java.sql.SQLException (e.getMessage()); 546     } 547   } 548 549     /** 550      * Are concatenations between NULL and non-NULL values NULL? 551      * 552      * A JDBC-Compliant driver always returns true. 553      * 554      * @return true if so 555      */ 556   public boolean nullPlusNonNullIsNull() throws SQLException { 557     try { 558       return rmiMetadata_.nullPlusNonNullIsNull(); 559     } catch(RemoteException e) { 560       throw new java.sql.SQLException (e.getMessage()); 561     } 562   } 563 564     /** 565      * Is the CONVERT function between SQL types supported? 566      * 567      * @return true if so 568      */ 569   public boolean supportsConvert() throws SQLException { 570     try { 571       return rmiMetadata_.supportsConvert(); 572     } catch(RemoteException e) { 573       throw new java.sql.SQLException (e.getMessage()); 574     } 575   } 576 577     /** 578      * Is CONVERT between the given SQL types supported? 579      * 580      * @param fromType the type to convert from 581      * @param toType the type to convert to 582      * @return true if so 583      * @see Types 584      */ 585   public boolean supportsConvert(int fromType, int toType) throws SQLException { 586     try { 587       return rmiMetadata_.supportsConvert(); 588     } catch(RemoteException e) { 589       throw new java.sql.SQLException (e.getMessage()); 590     } 591   } 592 593     /** 594      * Are table correlation names supported? 595      * 596      * A JDBC-Compliant driver always returns true. 597      * 598      * @return true if so 599      */ 600   public boolean supportsTableCorrelationNames() throws SQLException { 601     try { 602       return rmiMetadata_.supportsTableCorrelationNames(); 603     } catch(RemoteException e) { 604       throw new java.sql.SQLException (e.getMessage()); 605     } 606   } 607 608     /** 609      * If table correlation names are supported, are they restricted 610      * to be different from the names of the tables? 611      * 612      * @return true if so 613      */ 614   public boolean supportsDifferentTableCorrelationNames() throws SQLException { 615     try { 616       return rmiMetadata_.supportsDifferentTableCorrelationNames(); 617     } catch(RemoteException e) { 618       throw new java.sql.SQLException (e.getMessage()); 619     } 620   } 621 622     /** 623      * Are expressions in "ORDER BY" lists supported? 624      * 625      * @return true if so 626      */ 627   public boolean supportsExpressionsInOrderBy() throws SQLException { 628     try { 629       return rmiMetadata_.supportsExpressionsInOrderBy(); 630     } catch(RemoteException e) { 631       throw new java.sql.SQLException (e.getMessage()); 632     } 633   } 634 635     /** 636      * Can an "ORDER BY" clause use columns not in the SELECT? 637      * 638      * @return true if so 639      */ 640   public boolean supportsOrderByUnrelated() throws SQLException { 641     try { 642       return rmiMetadata_.supportsOrderByUnrelated(); 643     } catch(RemoteException e) { 644       throw new java.sql.SQLException (e.getMessage()); 645     } 646   } 647 648     /** 649      * Is some form of "GROUP BY" clause supported? 650      * 651      * @return true if so 652      */ 653   public boolean supportsGroupBy() throws SQLException { 654     try { 655       return rmiMetadata_.supportsGroupBy(); 656     } catch(RemoteException e) { 657       throw new java.sql.SQLException (e.getMessage()); 658     } 659   } 660 661     /** 662      * Can a "GROUP BY" clause use columns not in the SELECT? 663      * 664      * @return true if so 665      */ 666   public boolean supportsGroupByUnrelated() throws SQLException { 667     try { 668       return rmiMetadata_.supportsGroupByUnrelated(); 669     } catch(RemoteException e) { 670       throw new java.sql.SQLException (e.getMessage()); 671     } 672   } 673 674     /** 675      * Can a "GROUP BY" clause add columns not in the SELECT 676      * provided it specifies all the columns in the SELECT? 677      * 678      * @return true if so 679      */ 680   public boolean supportsGroupByBeyondSelect() throws SQLException { 681     try { 682       return rmiMetadata_.supportsGroupByBeyondSelect(); 683     } catch(RemoteException e) { 684       throw new java.sql.SQLException (e.getMessage()); 685     } 686   } 687 688     /** 689      * Is the escape character in "LIKE" clauses supported? 690      * 691      * A JDBC-Compliant driver always returns true. 692      * 693      * @return true if so 694      */ 695   public boolean supportsLikeEscapeClause() throws SQLException { 696     try { 697       return rmiMetadata_.supportsLikeEscapeClause(); 698     } catch(RemoteException e) { 699       throw new java.sql.SQLException (e.getMessage()); 700     } 701   } 702 703     /** 704      * Are multiple ResultSets from a single execute supported? 705      * 706      * @return true if so 707      */ 708   public boolean supportsMultipleResultSets() throws SQLException { 709     try { 710       return rmiMetadata_.supportsMultipleResultSets(); 711     } catch(RemoteException e) { 712       throw new java.sql.SQLException (e.getMessage()); 713     } 714   } 715 716     /** 717      * Can we have multiple transactions open at once (on different 718      * connections)? 719      * 720      * @return true if so 721      */ 722   public boolean supportsMultipleTransactions() throws SQLException { 723     try { 724       return rmiMetadata_.supportsMultipleTransactions(); 725     } catch(RemoteException e) { 726       throw new java.sql.SQLException (e.getMessage()); 727     } 728   } 729 730     /** 731      * Can columns be defined as non-nullable? 732      * 733      * A JDBC-Compliant driver always returns true. 734      * 735      * @return true if so 736      */ 737   public boolean supportsNonNullableColumns() throws SQLException { 738     try { 739       return rmiMetadata_.supportsNonNullableColumns(); 740     } catch(RemoteException e) { 741       throw new java.sql.SQLException (e.getMessage()); 742     } 743   } 744 745     /** 746      * Is the ODBC Minimum SQL grammar supported? 747      * 748      * All JDBC-Compliant drivers must return true. 749      * 750      * @return true if so 751      */ 752   public boolean supportsMinimumSQLGrammar() throws SQLException { 753     try { 754       return rmiMetadata_.supportsMinimumSQLGrammar(); 755     } catch(RemoteException e) { 756       throw new java.sql.SQLException (e.getMessage()); 757     } 758   } 759 760     /** 761      * Is the ODBC Core SQL grammar supported? 762      * 763      * @return true if so 764      */ 765   public boolean supportsCoreSQLGrammar() throws SQLException { 766     try { 767       return rmiMetadata_.supportsCoreSQLGrammar(); 768     } catch(RemoteException e) { 769       throw new java.sql.SQLException (e.getMessage()); 770     } 771   } 772 773     /** 774      * Is the ODBC Extended SQL grammar supported? 775      * 776      * @return true if so 777      */ 778   public boolean supportsExtendedSQLGrammar() throws SQLException { 779     try { 780       return rmiMetadata_.supportsExtendedSQLGrammar(); 781     } catch(RemoteException e) { 782       throw new java.sql.SQLException (e.getMessage()); 783     } 784   } 785 786     /** 787      * Is the ANSI92 entry level SQL grammar supported? 788      * 789      * All JDBC-Compliant drivers must return true. 790      * 791      * @return true if so 792      */ 793   public boolean supportsANSI92EntryLevelSQL() throws SQLException { 794     try { 795       return rmiMetadata_.supportsANSI92EntryLevelSQL(); 796     } catch(RemoteException e) { 797       throw new java.sql.SQLException (e.getMessage()); 798     } 799   } 800 801     /** 802      * Is the ANSI92 intermediate SQL grammar supported? 803      * 804      * @return true if so 805      */ 806   public boolean supportsANSI92IntermediateSQL() throws SQLException { 807     try { 808       return rmiMetadata_.supportsANSI92IntermediateSQL(); 809     } catch(RemoteException e) { 810       throw new java.sql.SQLException (e.getMessage()); 811     } 812   } 813 814     /** 815      * Is the ANSI92 full SQL grammar supported? 816      * 817      * @return true if so 818      */ 819   public boolean supportsANSI92FullSQL() throws SQLException { 820     try { 821       return rmiMetadata_.supportsANSI92FullSQL(); 822     } catch(RemoteException e) { 823       throw new java.sql.SQLException (e.getMessage()); 824     } 825   } 826 827     /** 828      * Is the SQL Integrity Enhancement Facility supported? 829      * 830      * @return true if so 831      */ 832   public boolean supportsIntegrityEnhancementFacility() throws SQLException { 833     try { 834       return rmiMetadata_.supportsIntegrityEnhancementFacility(); 835     } catch(RemoteException e) { 836       throw new java.sql.SQLException (e.getMessage()); 837     } 838   } 839 840     /** 841      * Is some form of outer join supported? 842      * 843      * @return true if so 844      */ 845   public boolean supportsOuterJoins() throws SQLException { 846     try { 847       return rmiMetadata_.supportsOuterJoins(); 848     } catch(RemoteException e) { 849       throw new java.sql.SQLException (e.getMessage()); 850     } 851   } 852 853     /** 854      * Are full nested outer joins supported? 855      * 856      * @return true if so 857      */ 858   public boolean supportsFullOuterJoins() throws SQLException { 859     try { 860       return rmiMetadata_.supportsFullOuterJoins(); 861     } catch(RemoteException e) { 862       throw new java.sql.SQLException (e.getMessage()); 863     } 864   } 865 866     /** 867      * Is there limited support for outer joins? (This will be true 868      * if supportFullOuterJoins is true.) 869      * 870      * @return true if so 871      */ 872   public boolean supportsLimitedOuterJoins() throws SQLException { 873     try { 874       return rmiMetadata_.supportsLimitedOuterJoins(); 875     } catch(RemoteException e) { 876       throw new java.sql.SQLException (e.getMessage()); 877     } 878   } 879 880     /** 881      * What's the database vendor's preferred term for "schema"? 882      * 883      * @return the vendor term 884      */ 885   public String getSchemaTerm() throws SQLException { 886     try { 887       return rmiMetadata_.getSchemaTerm(); 888     } catch(RemoteException e) { 889       throw new java.sql.SQLException (e.getMessage()); 890     } 891   } 892 893     /** 894      * What's the database vendor's preferred term for "procedure"? 895      * 896      * @return the vendor term 897      */ 898   public String getProcedureTerm() throws SQLException { 899     try { 900       return rmiMetadata_.getProcedureTerm(); 901     } catch(RemoteException e) { 902       throw new java.sql.SQLException (e.getMessage()); 903     } 904   } 905 906     /** 907      * What's the database vendor's preferred term for "catalog"? 908      * 909      * @return the vendor term 910      */ 911   public String getCatalogTerm() throws SQLException { 912     try { 913       return rmiMetadata_.getCatalogTerm(); 914     } catch(RemoteException e) { 915       throw new java.sql.SQLException (e.getMessage()); 916     } 917   } 918 919     /** 920      * Does a catalog appear at the start of a qualified table name? 921      * (Otherwise it appears at the end) 922      * 923      * @return true if it appears at the start 924      */ 925   public boolean isCatalogAtStart() throws SQLException { 926     try { 927       return rmiMetadata_.isCatalogAtStart(); 928     } catch(RemoteException e) { 929       throw new java.sql.SQLException (e.getMessage()); 930     } 931   } 932 933     /** 934      * What's the separator between catalog and table name? 935      * 936      * @return the separator string 937      */ 938   public String getCatalogSeparator() throws SQLException { 939     try { 940       return rmiMetadata_.getCatalogSeparator(); 941     } catch(RemoteException e) { 942       throw new java.sql.SQLException (e.getMessage()); 943     } 944   } 945 946     /** 947      * Can a schema name be used in a data manipulation statement? 948      * 949      * @return true if so 950      */ 951   public boolean supportsSchemasInDataManipulation() throws SQLException { 952     try { 953       return rmiMetadata_.supportsSchemasInDataManipulation(); 954     } catch(RemoteException e) { 955       throw new java.sql.SQLException (e.getMessage()); 956     } 957   } 958 959     /** 960      * Can a schema name be used in a procedure call statement? 961      * 962      * @return true if so 963      */ 964   public boolean supportsSchemasInProcedureCalls() throws SQLException { 965     try { 966       return rmiMetadata_.supportsSchemasInProcedureCalls(); 967     } catch(RemoteException e) { 968       throw new java.sql.SQLException (e.getMessage()); 969     } 970   } 971 972     /** 973      * Can a schema name be used in a table definition statement? 974      * 975      * @return true if so 976      */ 977   public boolean supportsSchemasInTableDefinitions() throws SQLException { 978     try { 979       return rmiMetadata_.supportsSchemasInTableDefinitions(); 980     } catch(RemoteException e) { 981       throw new java.sql.SQLException (e.getMessage()); 982     } 983   } 984 985     /** 986      * Can a schema name be used in an index definition statement? 987      * 988      * @return true if so 989      */ 990   public boolean supportsSchemasInIndexDefinitions() throws SQLException { 991     try { 992       return rmiMetadata_.supportsSchemasInIndexDefinitions(); 993     } catch(RemoteException e) { 994       throw new java.sql.SQLException (e.getMessage()); 995     } 996   } 997 998     /** 999      * Can a schema name be used in a privilege definition statement? 1000     * 1001     * @return true if so 1002     */ 1003  public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException { 1004    try { 1005      return rmiMetadata_.supportsSchemasInPrivilegeDefinitions(); 1006    } catch(RemoteException e) { 1007      throw new java.sql.SQLException (e.getMessage()); 1008    } 1009  } 1010 1011    /** 1012     * Can a catalog name be used in a data manipulation statement? 1013     * 1014     * @return true if so 1015     */ 1016  public boolean supportsCatalogsInDataManipulation() throws SQLException { 1017    try { 1018      return rmiMetadata_.supportsCatalogsInDataManipulation(); 1019    } catch(RemoteException e) { 1020      throw new java.sql.SQLException (e.getMessage()); 1021    } 1022  } 1023 1024    /** 1025     * Can a catalog name be used in a procedure call statement? 1026     * 1027     * @return true if so 1028     */ 1029  public boolean supportsCatalogsInProcedureCalls() throws SQLException { 1030    try { 1031      return rmiMetadata_.supportsCatalogsInProcedureCalls(); 1032    } catch(RemoteException e) { 1033      throw new java.sql.SQLException (e.getMessage()); 1034    } 1035  } 1036 1037    /** 1038     * Can a catalog name be used in a table definition statement? 1039     * 1040     * @return true if so 1041     */ 1042  public boolean supportsCatalogsInTableDefinitions() throws SQLException { 1043    try { 1044      return rmiMetadata_.supportsCatalogsInTableDefinitions(); 1045    } catch(RemoteException e) { 1046      throw new java.sql.SQLException (e.getMessage()); 1047    } 1048  } 1049 1050    /** 1051     * Can a catalog name be used in an index definition statement? 1052     * 1053     * @return true if so 1054     */ 1055  public boolean supportsCatalogsInIndexDefinitions() throws SQLException { 1056    try { 1057      return rmiMetadata_.supportsCatalogsInIndexDefinitions(); 1058    } catch(RemoteException e) { 1059      throw new java.sql.SQLException (e.getMessage()); 1060    } 1061  } 1062 1063    /** 1064     * Can a catalog name be used in a privilege definition statement? 1065     * 1066     * @return true if so 1067     */ 1068  public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException { 1069    try { 1070      return rmiMetadata_.supportsCatalogsInPrivilegeDefinitions(); 1071    } catch(RemoteException e) { 1072      throw new java.sql.SQLException (e.getMessage()); 1073    } 1074  } 1075 1076 1077    /** 1078     * Is positioned DELETE supported? 1079     * 1080     * @return true if so 1081     */ 1082  public boolean supportsPositionedDelete() throws SQLException { 1083    try { 1084      return rmiMetadata_.supportsPositionedDelete(); 1085    } catch(RemoteException e) { 1086      throw new java.sql.SQLException (e.getMessage()); 1087    } 1088  } 1089 1090    /** 1091     * Is positioned UPDATE supported? 1092     * 1093     * @return true if so 1094     */ 1095  public boolean supportsPositionedUpdate() throws SQLException { 1096    try { 1097      return rmiMetadata_.supportsPositionedUpdate(); 1098    } catch(RemoteException e) { 1099      throw new java.sql.SQLException (e.getMessage()); 1100    } 1101  } 1102 1103    /** 1104     * Is SELECT for UPDATE supported? 1105     * 1106     * @return true if so 1107     */ 1108  public boolean supportsSelectForUpdate() throws SQLException { 1109    try { 1110      return rmiMetadata_.supportsSelectForUpdate(); 1111    } catch(RemoteException e) { 1112      throw new java.sql.SQLException (e.getMessage()); 1113    } 1114  } 1115 1116    /** 1117     * Are stored procedure calls using the stored procedure escape 1118     * syntax supported? 1119     * 1120     * @return true if so 1121     */ 1122  public boolean supportsStoredProcedures() throws SQLException { 1123    try { 1124      return rmiMetadata_.supportsStoredProcedures(); 1125    } catch(RemoteException e) { 1126      throw new java.sql.SQLException (e.getMessage()); 1127    } 1128  } 1129 1130    /** 1131     * Are subqueries in comparison expressions supported? 1132     * 1133     * A JDBC-Compliant driver always returns true. 1134     * 1135     * @return true if so 1136     */ 1137  public boolean supportsSubqueriesInComparisons() throws SQLException { 1138    try { 1139      return rmiMetadata_.supportsSubqueriesInComparisons(); 1140    } catch(RemoteException e) { 1141      throw new java.sql.SQLException (e.getMessage()); 1142    } 1143  } 1144 1145    /** 1146     * Are subqueries in 'exists' expressions supported? 1147     * 1148     * A JDBC-Compliant driver always returns true. 1149     * 1150     * @return true if so 1151     */ 1152  public boolean supportsSubqueriesInExists() throws SQLException { 1153    try { 1154      return rmiMetadata_.supportsSubqueriesInExists(); 1155    } catch(RemoteException e) { 1156      throw new java.sql.SQLException (e.getMessage()); 1157    } 1158  } 1159 1160    /** 1161     * Are subqueries in 'in' statements supported? 1162     * 1163     * A JDBC-Compliant driver always returns true. 1164     * 1165     * @return true if so 1166     */ 1167  public boolean supportsSubqueriesInIns() throws SQLException { 1168    try { 1169      return rmiMetadata_.supportsSubqueriesInIns(); 1170    } catch(RemoteException e) { 1171      throw new java.sql.SQLException (e.getMessage()); 1172    } 1173  } 1174 1175    /** 1176     * Are subqueries in quantified expressions supported? 1177     * 1178     * A JDBC-Compliant driver always returns true. 1179     * 1180     * @return true if so 1181     */ 1182  public boolean supportsSubqueriesInQuantifieds() throws SQLException { 1183    try { 1184      return rmiMetadata_.supportsSubqueriesInQuantifieds(); 1185    } catch(RemoteException e) { 1186      throw new java.sql.SQLException (e.getMessage()); 1187    } 1188  } 1189 1190    /** 1191     * Are correlated subqueries supported? 1192     * 1193     * A JDBC-Compliant driver always returns true. 1194     * 1195     * @return true if so 1196     */ 1197  public boolean supportsCorrelatedSubqueries() throws SQLException { 1198    try { 1199      return rmiMetadata_.supportsCorrelatedSubqueries(); 1200    } catch(RemoteException e) { 1201      throw new java.sql.SQLException (e.getMessage()); 1202    } 1203  } 1204 1205    /** 1206     * Is SQL UNION supported? 1207     * 1208     * @return true if so 1209     */ 1210  public boolean supportsUnion() throws SQLException { 1211    try { 1212      return rmiMetadata_.supportsUnion(); 1213    } catch(RemoteException e) { 1214      throw new java.sql.SQLException (e.getMessage()); 1215    } 1216  } 1217 1218    /** 1219     * Is SQL UNION ALL supported? 1220     * 1221     * @return true if so 1222     */ 1223  public boolean supportsUnionAll() throws SQLException { 1224    try { 1225      return rmiMetadata_.supportsUnionAll(); 1226    } catch(RemoteException e) { 1227      throw new java.sql.SQLException (e.getMessage()); 1228    } 1229  } 1230 1231    /** 1232     * Can cursors remain open across commits? 1233     * 1234     * @return true if cursors always remain open; 1235     * false if they might not remain open 1236     */ 1237  public boolean supportsOpenCursorsAcrossCommit() throws SQLException { 1238    try { 1239      return rmiMetadata_.supportsOpenCursorsAcrossCommit(); 1240    } catch(RemoteException e) { 1241      throw new java.sql.SQLException (e.getMessage()); 1242    } 1243  } 1244 1245    /** 1246     * Can cursors remain open across rollbacks? 1247     * 1248     * @return true if cursors always remain open; 1249     * false if they might not remain open 1250     */ 1251  public boolean supportsOpenCursorsAcrossRollback() throws SQLException { 1252    try { 1253      return rmiMetadata_.supportsOpenCursorsAcrossRollback(); 1254    } catch(RemoteException e) { 1255      throw new java.sql.SQLException (e.getMessage()); 1256    } 1257  } 1258 1259    /** 1260     * Can statements remain open across commits? 1261     * 1262     * @return true if statements always remain open; 1263     * false if they might not remain open 1264     */ 1265  public boolean supportsOpenStatementsAcrossCommit() throws SQLException { 1266    try { 1267      return rmiMetadata_.supportsOpenStatementsAcrossCommit(); 1268    } catch(RemoteException e) { 1269      throw new java.sql.SQLException (e.getMessage()); 1270    } 1271  } 1272 1273    /** 1274     * Can statements remain open across rollbacks? 1275     * 1276     * @return true if statements always remain open; 1277     * false if they might not remain open 1278     */ 1279  public boolean supportsOpenStatementsAcrossRollback() throws SQLException { 1280    try { 1281      return rmiMetadata_.supportsOpenStatementsAcrossRollback(); 1282    } catch(RemoteException e) { 1283      throw new java.sql.SQLException (e.getMessage()); 1284    } 1285  } 1286 1287    //---------------------------------------------------------------------- 1288 // The following group of methods exposes various limitations 1289 // based on the target database with the current driver. 1290 // Unless otherwise specified, a result of zero means there is no 1291 // limit, or the limit is not known. 1292 1293    /** 1294     * How many hex characters can you have in an inline binary literal? 1295     * 1296     * @return max literal length 1297     */ 1298  public int getMaxBinaryLiteralLength() throws SQLException { 1299    try { 1300      return rmiMetadata_.getMaxBinaryLiteralLength(); 1301    } catch(RemoteException e) { 1302      throw new java.sql.SQLException (e.getMessage()); 1303    } 1304  } 1305 1306    /** 1307     * What's the max length for a character literal? 1308     * 1309     * @return max literal length 1310     */ 1311  public int getMaxCharLiteralLength() throws SQLException { 1312    try { 1313      return rmiMetadata_.getMaxCharLiteralLength(); 1314    } catch(RemoteException e) { 1315      throw new java.sql.SQLException (e.getMessage()); 1316    } 1317  } 1318 1319    /** 1320     * What's the limit on column name length? 1321     * 1322     * @return max literal length 1323     */ 1324  public int getMaxColumnNameLength() throws SQLException { 1325    try { 1326      return rmiMetadata_.getMaxColumnNameLength(); 1327    } catch(RemoteException e) { 1328      throw new java.sql.SQLException (e.getMessage()); 1329    } 1330  } 1331 1332    /** 1333     * What's the maximum number of columns in a "GROUP BY" clause? 1334     * 1335     * @return max number of columns 1336     */ 1337  public int getMaxColumnsInGroupBy() throws SQLException { 1338    try { 1339      return rmiMetadata_.getMaxColumnsInGroupBy(); 1340    } catch(RemoteException e) { 1341      throw new java.sql.SQLException (e.getMessage()); 1342    } 1343  } 1344 1345    /** 1346     * What's the maximum number of columns allowed in an index? 1347     * 1348     * @return max columns 1349     */ 1350  public int getMaxColumnsInIndex() throws SQLException { 1351    try { 1352      return rmiMetadata_.getMaxColumnsInIndex(); 1353    } catch(RemoteException e) { 1354      throw new java.sql.SQLException (e.getMessage()); 1355    } 1356  } 1357 1358    /** 1359     * What's the maximum number of columns in an "ORDER BY" clause? 1360     * 1361     * @return max columns 1362     */ 1363  public int getMaxColumnsInOrderBy() throws SQLException { 1364    try { 1365      return rmiMetadata_.getMaxColumnsInOrderBy(); 1366    } catch(RemoteException e) { 1367      throw new java.sql.SQLException (e.getMessage()); 1368    } 1369  } 1370 1371    /** 1372     * What's the maximum number of columns in a "SELECT" list? 1373     * 1374     * @return max columns 1375     */ 1376  public int getMaxColumnsInSelect() throws SQLException { 1377    try { 1378      return rmiMetadata_.getMaxColumnsInSelect(); 1379    } catch(RemoteException e) { 1380      throw new java.sql.SQLException (e.getMessage()); 1381    } 1382  } 1383 1384    /** 1385     * What's the maximum number of columns in a table? 1386     * 1387     * @return max columns 1388     */ 1389  public int getMaxColumnsInTable() throws SQLException { 1390    try { 1391      return rmiMetadata_.getMaxColumnsInTable(); 1392    } catch(RemoteException e) { 1393      throw new java.sql.SQLException (e.getMessage()); 1394    } 1395  } 1396 1397    /** 1398     * How many active connections can we have at a time to this database? 1399     * 1400     * @return max connections 1401     */ 1402  public int getMaxConnections() throws SQLException { 1403    try { 1404      return rmiMetadata_.getMaxConnections(); 1405    } catch(RemoteException e) { 1406      throw new java.sql.SQLException (e.getMessage()); 1407    } 1408  } 1409 1410    /** 1411     * What's the maximum cursor name length? 1412     * 1413     * @return max cursor name length in bytes 1414     */ 1415  public int getMaxCursorNameLength() throws SQLException { 1416    try { 1417      return rmiMetadata_.getMaxCursorNameLength(); 1418    } catch(RemoteException e) { 1419      throw new java.sql.SQLException (e.getMessage()); 1420    } 1421  } 1422 1423    /** 1424     * What's the maximum length of an index (in bytes)? 1425     * 1426     * @return max index length in bytes 1427     */ 1428  public int getMaxIndexLength() throws SQLException { 1429    try { 1430      return rmiMetadata_.getMaxIndexLength(); 1431    } catch(RemoteException e) { 1432      throw new java.sql.SQLException (e.getMessage()); 1433    } 1434  } 1435 1436    /** 1437     * What's the maximum length allowed for a schema name? 1438     * 1439     * @return max name length in bytes 1440     */ 1441  public int getMaxSchemaNameLength() throws SQLException { 1442    try { 1443      return rmiMetadata_.getMaxSchemaNameLength(); 1444    } catch(RemoteException e) { 1445      throw new java.sql.SQLException (e.getMessage()); 1446    } 1447  } 1448 1449    /** 1450     * What's the maximum length of a procedure name? 1451     * 1452     * @return max name length in bytes 1453     */ 1454  public int getMaxProcedureNameLength() throws SQLException { 1455    try { 1456      return rmiMetadata_.getMaxProcedureNameLength(); 1457    } catch(RemoteException e) { 1458      throw new java.sql.SQLException (e.getMessage()); 1459    } 1460  } 1461 1462    /** 1463     * What's the maximum length of a catalog name? 1464     * 1465     * @return max name length in bytes 1466     */ 1467  public int getMaxCatalogNameLength() throws SQLException { 1468    try { 1469      return rmiMetadata_.getMaxCatalogNameLength(); 1470    } catch(RemoteException e) { 1471      throw new java.sql.SQLException (e.getMessage()); 1472    } 1473  } 1474 1475    /** 1476     * What's the maximum length of a single row? 1477     * 1478     * @return max row size in bytes 1479     */ 1480  public int getMaxRowSize() throws SQLException { 1481    try { 1482      return rmiMetadata_.getMaxRowSize(); 1483    } catch(RemoteException e) { 1484      throw new java.sql.SQLException (e.getMessage()); 1485    } 1486  } 1487 1488    /** 1489     * Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY 1490     * blobs? 1491     * 1492     * @return true if so 1493     */ 1494  public boolean doesMaxRowSizeIncludeBlobs() throws SQLException { 1495    try { 1496      return rmiMetadata_.doesMaxRowSizeIncludeBlobs(); 1497    } catch(RemoteException e) { 1498      throw new java.sql.SQLException (e.getMessage()); 1499    } 1500  } 1501 1502    /** 1503     * What's the maximum length of a SQL statement? 1504     * 1505     * @return max length in bytes 1506     */ 1507  public int getMaxStatementLength() throws SQLException { 1508    try { 1509      return rmiMetadata_.getMaxStatementLength(); 1510    } catch(RemoteException e) { 1511      throw new java.sql.SQLException (e.getMessage()); 1512    } 1513  } 1514 1515    /** 1516     * How many active statements can we have open at one time to this 1517     * database? 1518     * 1519     * @return the maximum 1520     */ 1521  public int getMaxStatements() throws SQLException { 1522    try { 1523      return rmiMetadata_.getMaxStatements(); 1524    } catch(RemoteException e) { 1525      throw new java.sql.SQLException (e.getMessage()); 1526    } 1527  } 1528 1529    /** 1530     * What's the maximum length of a table name? 1531     * 1532     * @return max name length in bytes 1533     */ 1534  public int getMaxTableNameLength() throws SQLException { 1535    try { 1536      return rmiMetadata_.getMaxTableNameLength(); 1537    } catch(RemoteException e) { 1538      throw new java.sql.SQLException (e.getMessage()); 1539    } 1540  } 1541 1542    /** 1543     * What's the maximum number of tables in a SELECT? 1544     * 1545     * @return the maximum 1546     */ 1547  public int getMaxTablesInSelect() throws SQLException { 1548    try { 1549      return rmiMetadata_.getMaxTablesInSelect(); 1550    } catch(RemoteException e) { 1551      throw new java.sql.SQLException (e.getMessage()); 1552    } 1553  } 1554 1555    /** 1556     * What's the maximum length of a user name? 1557     * 1558     * @return max name length in bytes 1559     */ 1560  public int getMaxUserNameLength() throws SQLException { 1561    try { 1562      return rmiMetadata_.getMaxUserNameLength(); 1563    } catch(RemoteException e) { 1564      throw new java.sql.SQLException (e.getMessage()); 1565    } 1566  } 1567 1568    //---------------------------------------------------------------------- 1569 1570    /** 1571     * What's the database's default transaction isolation level? The 1572     * values are defined in java.sql.Connection. 1573     * 1574     * @return the default isolation level 1575     * @see Connection 1576     */ 1577  public int getDefaultTransactionIsolation() throws SQLException { 1578    try { 1579      return rmiMetadata_.getDefaultTransactionIsolation(); 1580    } catch(RemoteException e) { 1581      throw new java.sql.SQLException (e.getMessage()); 1582    } 1583  } 1584 1585    /** 1586     * Are transactions supported? If not, commit is a noop and the 1587     * isolation level is TRANSACTION_NONE. 1588     * 1589     * @return true if transactions are supported 1590     */ 1591  public boolean supportsTransactions() throws SQLException { 1592    try { 1593      return rmiMetadata_.supportsTransactions(); 1594    } catch(RemoteException e) { 1595      throw new java.sql.SQLException (e.getMessage()); 1596    } 1597  } 1598 1599    /** 1600     * Does the database support the given transaction isolation level? 1601     * 1602     * @param level the values are defined in java.sql.Connection 1603     * @return true if so 1604     * @see Connection 1605     */ 1606  public boolean supportsTransactionIsolationLevel(int level) 1607  throws SQLException { 1608    try { 1609      return rmiMetadata_.supportsTransactionIsolationLevel(level); 1610    } catch(RemoteException e) { 1611      throw new java.sql.SQLException (e.getMessage()); 1612    } 1613  } 1614 1615    /** 1616     * Are both data definition and data manipulation statements 1617     * within a transaction supported? 1618     * 1619     * @return true if so 1620     */ 1621  public boolean supportsDataDefinitionAndDataManipulationTransactions() 1622  throws SQLException { 1623    try { 1624      return 1625       rmiMetadata_.supportsDataDefinitionAndDataManipulationTransactions(); 1626    } catch(RemoteException e) { 1627      throw new java.sql.SQLException (e.getMessage()); 1628    } 1629  } 1630 1631    /** 1632     * Are only data manipulation statements within a transaction 1633     * supported? 1634     * 1635     * @return true if so 1636     */ 1637  public boolean supportsDataManipulationTransactionsOnly() 1638  throws SQLException { 1639    try { 1640      return rmiMetadata_.supportsDataManipulationTransactionsOnly(); 1641    } catch(RemoteException e) { 1642      throw new java.sql.SQLException (e.getMessage()); 1643    } 1644  } 1645 1646    /** 1647     * Does a data definition statement within a transaction force the 1648     * transaction to commit? 1649     * 1650     * @return true if so 1651     */ 1652  public boolean dataDefinitionCausesTransactionCommit() 1653  throws SQLException { 1654    try { 1655      return rmiMetadata_.dataDefinitionCausesTransactionCommit(); 1656    } catch(RemoteException e) { 1657      throw new java.sql.SQLException (e.getMessage()); 1658    } 1659  } 1660 1661    /** 1662     * Is a data definition statement within a transaction ignored? 1663     * 1664     * @return true if so 1665     */ 1666  public boolean dataDefinitionIgnoredInTransactions() 1667  throws SQLException { 1668    try { 1669      return rmiMetadata_.dataDefinitionIgnoredInTransactions(); 1670    } catch(RemoteException e) { 1671      throw new java.sql.SQLException (e.getMessage()); 1672    } 1673  } 1674 1675    /** 1676     * Get a description of stored procedures available in a 1677     * catalog. 1678     * 1679     * <P>Only procedure descriptions matching the schema and 1680     * procedure name criteria are returned. They are ordered by 1681     * PROCEDURE_SCHEM, and PROCEDURE_NAME. 1682     * 1683     * <P>Each procedure description has the the following columns: 1684     * <OL> 1685     * <LI><B>PROCEDURE_CAT</B> String => procedure catalog (may be null) 1686     * <LI><B>PROCEDURE_SCHEM</B> String => procedure schema (may be null) 1687     * <LI><B>PROCEDURE_NAME</B> String => procedure name 1688     * <LI> reserved for future use 1689     * <LI> reserved for future use 1690     * <LI> reserved for future use 1691     * <LI><B>REMARKS</B> String => explanatory comment on the procedure 1692     * <LI><B>PROCEDURE_TYPE</B> short => kind of procedure: 1693     * <UL> 1694     * <LI> procedureResultUnknown - May return a result 1695     * <LI> procedureNoResult - Does not return a result 1696     * <LI> procedureReturnsResult - Returns a result 1697     * </UL> 1698     * </OL> 1699     * 1700     * @param catalog a catalog name; "" retrieves those without a 1701     * catalog; null means drop catalog name from the selection criteria 1702     * @param schemaPattern a schema name pattern; "" retrieves those 1703     * without a schema 1704     * @param procedureNamePattern a procedure name pattern 1705     * @return ResultSet - each row is a procedure description 1706     * @see #getSearchStringEscape 1707     */ 1708  public java.sql.ResultSet getProcedures(String catalog, String schemaPattern, 1709  String procedureNamePattern) throws SQLException { 1710    try { 1711      return new RJResultSet( 1712       rmiMetadata_.getProcedures(catalog, schemaPattern, procedureNamePattern), 1713       null); 1714    } catch(RemoteException e) { 1715      throw new java.sql.SQLException (e.getMessage()); 1716    } 1717  } 1718 1719    /** 1720     * Get a description of a catalog's stored procedure parameters 1721     * and result columns. 1722     * 1723     * <P>Only descriptions matching the schema, procedure and 1724     * parameter name criteria are returned. They are ordered by 1725     * PROCEDURE_SCHEM and PROCEDURE_NAME. Within this, the return value, 1726     * if any, is first. Next are the parameter descriptions in call 1727     * order. The column descriptions follow in column number order. 1728     * 1729     * <P>Each row in the ResultSet is a parameter description or 1730     * column description with the following fields: 1731     * <OL> 1732     * <LI><B>PROCEDURE_CAT</B> String => procedure catalog (may be null) 1733     * <LI><B>PROCEDURE_SCHEM</B> String => procedure schema (may be null) 1734     * <LI><B>PROCEDURE_NAME</B> String => procedure name 1735     * <LI><B>COLUMN_NAME</B> String => column/parameter name 1736     * <LI><B>COLUMN_TYPE</B> Short => kind of column/parameter: 1737     * <UL> 1738     * <LI> procedureColumnUnknown - nobody knows 1739     * <LI> procedureColumnIn - IN parameter 1740     * <LI> procedureColumnInOut - INOUT parameter 1741     * <LI> procedureColumnOut - OUT parameter 1742     * <LI> procedureColumnReturn - procedure return value 1743     * <LI> procedureColumnResult - result column in ResultSet 1744     * </UL> 1745     * <LI><B>DATA_TYPE</B> short => SQL type from java.sql.Types 1746     * <LI><B>TYPE_NAME</B> String => SQL type name 1747     * <LI><B>PRECISION</B> int => precision 1748     * <LI><B>LENGTH</B> int => length in bytes of data 1749     * <LI><B>SCALE</B> short => scale 1750     * <LI><B>RADIX</B> short => radix 1751     * <LI><B>NULLABLE</B> short => can it contain NULL? 1752     * <UL> 1753     * <LI> procedureNoNulls - does not allow NULL values 1754     * <LI> procedureNullable - allows NULL values 1755     * <LI> procedureNullableUnknown - nullability unknown 1756     * </UL> 1757     * <LI><B>REMARKS</B> String => comment describing parameter/column 1758     * </OL> 1759     * 1760     * <P><B>Note:</B> Some databases may not return the column 1761     * descriptions for a procedure. Additional columns beyond 1762     * REMARKS can be defined by the database. 1763     * 1764     * @param catalog a catalog name; "" retrieves those without a 1765     * catalog; null means drop catalog name from the selection criteria 1766     * @param schemaPattern a schema name pattern; "" retrieves those 1767     * without a schema 1768     * @param procedureNamePattern a procedure name pattern 1769     * @param columnNamePattern a column name pattern 1770     * @return ResultSet - each row is a stored procedure parameter or 1771     * column description 1772     * @see #getSearchStringEscape 1773     */ 1774  public java.sql.ResultSet getProcedureColumns(String catalog, 1775  String schemaPattern, 1776  String procedureNamePattern, 1777  String columnNamePattern) throws SQLException { 1778    try { 1779      return new RJResultSet( 1780       rmiMetadata_.getProcedureColumns(catalog, schemaPattern, 1781         procedureNamePattern, columnNamePattern), 1782       null); 1783    } catch(RemoteException e) { 1784      throw new java.sql.SQLException (e.getMessage()); 1785    } 1786  } 1787 1788    /** 1789     * Get a description of tables available in a catalog. 1790     * 1791     * <P>Only table descriptions matching the catalog, schema, table 1792     * name and type criteria are returned. They are ordered by 1793     * TABLE_TYPE, TABLE_SCHEM and TABLE_NAME. 1794     * 1795     * <P>Each table description has the following columns: 1796     * <OL> 1797     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 1798     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 1799     * <LI><B>TABLE_NAME</B> String => table name 1800     * <LI><B>TABLE_TYPE</B> String => table type. Typical types are "TABLE", 1801     * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", 1802     * "LOCAL TEMPORARY", "ALIAS", "SYNONYM". 1803     * <LI><B>REMARKS</B> String => explanatory comment on the table 1804     * </OL> 1805     * 1806     * <P><B>Note:</B> Some databases may not return information for 1807     * all tables. 1808     * 1809     * @param catalog a catalog name; "" retrieves those without a 1810     * catalog; null means drop catalog name from the selection criteria 1811     * @param schemaPattern a schema name pattern; "" retrieves those 1812     * without a schema 1813     * @param tableNamePattern a table name pattern 1814     * @param types a list of table types to include; null returns all types 1815     * @return ResultSet - each row is a table description 1816     * @see #getSearchStringEscape 1817     */ 1818  public java.sql.ResultSet getTables(String catalog, String schemaPattern, 1819  String tableNamePattern, String types[]) throws SQLException { 1820    try { 1821      return new RJResultSet( 1822       rmiMetadata_.getTables(catalog, schemaPattern, tableNamePattern, types), 1823       null); 1824    } catch(RemoteException e) { 1825      throw new java.sql.SQLException (e.getMessage()); 1826    } 1827  } 1828 1829    /** 1830     * Get the schema names available in this database. The results 1831     * are ordered by schema name. 1832     * 1833     * <P>The schema column is: 1834     * <OL> 1835     * <LI><B>TABLE_SCHEM</B> String => schema name 1836     * </OL> 1837     * 1838     * @return ResultSet - each row has a single String column that is a 1839     * schema name 1840     */ 1841  public java.sql.ResultSet getSchemas() throws SQLException { 1842    try { 1843      return new RJResultSet(rmiMetadata_.getSchemas(), null); 1844    } catch(RemoteException e) { 1845      throw new java.sql.SQLException (e.getMessage()); 1846    } 1847  } 1848 1849    /** 1850     * Get the catalog names available in this database. The results 1851     * are ordered by catalog name. 1852     * 1853     * <P>The catalog column is: 1854     * <OL> 1855     * <LI><B>TABLE_CAT</B> String => catalog name 1856     * </OL> 1857     * 1858     * @return ResultSet - each row has a single String column that is a 1859     * catalog name 1860     */ 1861  public java.sql.ResultSet getCatalogs() throws SQLException { 1862    try { 1863      return new RJResultSet(rmiMetadata_.getCatalogs(), null); 1864    } catch(RemoteException e) { 1865      throw new java.sql.SQLException (e.getMessage()); 1866    } 1867  } 1868 1869    /** 1870     * Get the table types available in this database. The results 1871     * are ordered by table type. 1872     * 1873     * <P>The table type is: 1874     * <OL> 1875     * <LI><B>TABLE_TYPE</B> String => table type. Typical types are "TABLE", 1876     * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", 1877     * "LOCAL TEMPORARY", "ALIAS", "SYNONYM". 1878     * </OL> 1879     * 1880     * @return ResultSet - each row has a single String column that is a 1881     * table type 1882     */ 1883  public java.sql.ResultSet getTableTypes() throws SQLException { 1884    try { 1885      return new RJResultSet(rmiMetadata_.getTableTypes(), null); 1886    } catch(RemoteException e) { 1887      throw new java.sql.SQLException (e.getMessage()); 1888    } 1889  } 1890 1891    /** 1892     * Get a description of table columns available in a catalog. 1893     * 1894     * <P>Only column descriptions matching the catalog, schema, table 1895     * and column name criteria are returned. They are ordered by 1896     * TABLE_SCHEM, TABLE_NAME and ORDINAL_POSITION. 1897     * 1898     * <P>Each column description has the following columns: 1899     * <OL> 1900     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 1901     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 1902     * <LI><B>TABLE_NAME</B> String => table name 1903     * <LI><B>COLUMN_NAME</B> String => column name 1904     * <LI><B>DATA_TYPE</B> short => SQL type from java.sql.Types 1905     * <LI><B>TYPE_NAME</B> String => Data source dependent type name 1906     * <LI><B>COLUMN_SIZE</B> int => column size. For char or date 1907     * types this is the maximum number of characters, for numeric or 1908     * decimal types this is precision. 1909     * <LI><B>BUFFER_LENGTH</B> is not used. 1910     * <LI><B>DECIMAL_DIGITS</B> int => the number of fractional digits 1911     * <LI><B>NUM_PREC_RADIX</B> int => Radix (typically either 10 or 2) 1912     * <LI><B>NULLABLE</B> int => is NULL allowed? 1913     * <UL> 1914     * <LI> columnNoNulls - might not allow NULL values 1915     * <LI> columnNullable - definitely allows NULL values 1916     * <LI> columnNullableUnknown - nullability unknown 1917     * </UL> 1918     * <LI><B>REMARKS</B> String => comment describing column (may be null) 1919     * <LI><B>COLUMN_DEF</B> String => default value (may be null) 1920     * <LI><B>SQL_DATA_TYPE</B> int => unused 1921     * <LI><B>SQL_DATETIME_SUB</B> int => unused 1922     * <LI><B>CHAR_OCTET_LENGTH</B> int => for char types the 1923     * maximum number of bytes in the column 1924     * <LI><B>ORDINAL_POSITION</B> int => index of column in table 1925     * (starting at 1) 1926     * <LI><B>IS_NULLABLE</B> String => "NO" means column definitely 1927     * does not allow NULL values; "YES" means the column might 1928     * allow NULL values. An empty string means nobody knows. 1929     * </OL> 1930     * 1931     * @param catalog a catalog name; "" retrieves those without a 1932     * catalog; null means drop catalog name from the selection criteria 1933     * @param schemaPattern a schema name pattern; "" retrieves those 1934     * without a schema 1935     * @param tableNamePattern a table name pattern 1936     * @param columnNamePattern a column name pattern 1937     * @return ResultSet - each row is a column description 1938     * @see #getSearchStringEscape 1939     */ 1940  public java.sql.ResultSet getColumns(String catalog, String schemaPattern, 1941  String tableNamePattern, String columnNamePattern) throws SQLException { 1942    try { 1943      return new RJResultSet( 1944       rmiMetadata_.getColumns(catalog, schemaPattern, tableNamePattern, 1945        columnNamePattern), 1946       null); 1947    } catch(RemoteException e) { 1948      throw new java.sql.SQLException (e.getMessage()); 1949    } 1950  } 1951 1952    /** 1953     * Get a description of the access rights for a table's columns. 1954     * 1955     * <P>Only privileges matching the column name criteria are 1956     * returned. They are ordered by COLUMN_NAME and PRIVILEGE. 1957     * 1958     * <P>Each privilige description has the following columns: 1959     * <OL> 1960     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 1961     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 1962     * <LI><B>TABLE_NAME</B> String => table name 1963     * <LI><B>COLUMN_NAME</B> String => column name 1964     * <LI><B>GRANTOR</B> => grantor of access (may be null) 1965     * <LI><B>GRANTEE</B> String => grantee of access 1966     * <LI><B>PRIVILEGE</B> String => name of access (SELECT, 1967     * INSERT, UPDATE, REFRENCES, ...) 1968     * <LI><B>IS_GRANTABLE</B> String => "YES" if grantee is permitted 1969     * to grant to others; "NO" if not; null if unknown 1970     * </OL> 1971     * 1972     * @param catalog a catalog name; "" retrieves those without a 1973     * catalog; null means drop catalog name from the selection criteria 1974     * @param schema a schema name; "" retrieves those without a schema 1975     * @param table a table name 1976     * @param columnNamePattern a column name pattern 1977     * @return ResultSet - each row is a column privilege description 1978     * @see #getSearchStringEscape 1979     */ 1980  public java.sql.ResultSet getColumnPrivileges(String catalog, String schema, 1981  String table, String columnNamePattern) throws SQLException { 1982    try { 1983      return new RJResultSet( 1984       rmiMetadata_.getColumnPrivileges(catalog, schema, table, 1985         columnNamePattern), 1986       null); 1987    } catch(RemoteException e) { 1988      throw new java.sql.SQLException (e.getMessage()); 1989    } 1990  } 1991 1992    /** 1993     * Get a description of the access rights for each table available 1994     * in a catalog. Note that a table privilege applies to one or 1995     * more columns in the table. It would be wrong to assume that 1996     * this priviledge applies to all columns (this may be true for 1997     * some systems but is not true for all.) 1998     * 1999     * <P>Only privileges matching the schema and table name 2000     * criteria are returned. They are ordered by TABLE_SCHEM, 2001     * TABLE_NAME, and PRIVILEGE. 2002     * 2003     * <P>Each privilige description has the following columns: 2004     * <OL> 2005     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 2006     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 2007     * <LI><B>TABLE_NAME</B> String => table name 2008     * <LI><B>GRANTOR</B> => grantor of access (may be null) 2009     * <LI><B>GRANTEE</B> String => grantee of access 2010     * <LI><B>PRIVILEGE</B> String => name of access (SELECT, 2011     * INSERT, UPDATE, REFRENCES, ...) 2012     * <LI><B>IS_GRANTABLE</B> String => "YES" if grantee is permitted 2013     * to grant to others; "NO" if not; null if unknown 2014     * </OL> 2015     * 2016     * @param catalog a catalog name; "" retrieves those without a 2017     * catalog; null means drop catalog name from the selection criteria 2018     * @param schemaPattern a schema name pattern; "" retrieves those 2019     * without a schema 2020     * @param tableNamePattern a table name pattern 2021     * @return ResultSet - each row is a table privilege description 2022     * @see #getSearchStringEscape 2023     */ 2024  public java.sql.ResultSet getTablePrivileges(String catalog, 2025  String schemaPattern, String tableNamePattern) throws SQLException { 2026    try { 2027      return new RJResultSet( 2028       rmiMetadata_.getTablePrivileges(catalog, schemaPattern, 2029         tableNamePattern), 2030       null); 2031    } catch(RemoteException e) { 2032      throw new java.sql.SQLException (e.getMessage()); 2033    } 2034  } 2035 2036    /** 2037     * Get a description of a table's optimal set of columns that 2038     * uniquely identifies a row. They are ordered by SCOPE. 2039     * 2040     * <P>Each column description has the following columns: 2041     * <OL> 2042     * <LI><B>SCOPE</B> short => actual scope of result 2043     * <UL> 2044     * <LI> bestRowTemporary - very temporary, while using row 2045     * <LI> bestRowTransaction - valid for remainder of current transaction 2046     * <LI> bestRowSession - valid for remainder of current session 2047     * </UL> 2048     * <LI><B>COLUMN_NAME</B> String => column name 2049     * <LI><B>DATA_TYPE</B> short => SQL data type from java.sql.Types 2050     * <LI><B>TYPE_NAME</B> String => Data source dependent type name 2051     * <LI><B>COLUMN_SIZE</B> int => precision 2052     * <LI><B>BUFFER_LENGTH</B> int => not used 2053     * <LI><B>DECIMAL_DIGITS</B> short => scale 2054     * <LI><B>PSEUDO_COLUMN</B> short => is this a pseudo column 2055     * like an Oracle ROWID 2056     * <UL> 2057     * <LI> bestRowUnknown - may or may not be pseudo column 2058     * <LI> bestRowNotPseudo - is NOT a pseudo column 2059     * <LI> bestRowPseudo - is a pseudo column 2060     * </UL> 2061     * </OL> 2062     * 2063     * @param catalog a catalog name; "" retrieves those without a 2064     * catalog; null means drop catalog name from the selection criteria 2065     * @param schema a schema name; "" retrieves those without a schema 2066     * @param table a table name 2067     * @param scope the scope of interest; use same values as SCOPE 2068     * @param nullable include columns that are nullable? 2069     * @return ResultSet - each row is a column description 2070     */ 2071  public java.sql.ResultSet getBestRowIdentifier(String catalog, String schema, 2072  String table, int scope, boolean nullable) throws SQLException { 2073    try { 2074      return new RJResultSet( 2075       rmiMetadata_.getBestRowIdentifier(catalog, schema, table, scope, 2076         nullable), 2077       null); 2078    } catch(RemoteException e) { 2079      throw new java.sql.SQLException (e.getMessage()); 2080    } 2081  } 2082 2083    /** 2084     * Get a description of a table's columns that are automatically 2085     * updated when any value in a row is updated. They are 2086     * unordered. 2087     * 2088     * <P>Each column description has the following columns: 2089     * <OL> 2090     * <LI><B>SCOPE</B> short => is not used 2091     * <LI><B>COLUMN_NAME</B> String => column name 2092     * <LI><B>DATA_TYPE</B> short => SQL data type from java.sql.Types 2093     * <LI><B>TYPE_NAME</B> String => Data source dependent type name 2094     * <LI><B>COLUMN_SIZE</B> int => precision 2095     * <LI><B>BUFFER_LENGTH</B> int => length of column value in bytes 2096     * <LI><B>DECIMAL_DIGITS</B> short => scale 2097     * <LI><B>PSEUDO_COLUMN</B> short => is this a pseudo column 2098     * like an Oracle ROWID 2099     * <UL> 2100     * <LI> versionColumnUnknown - may or may not be pseudo column 2101     * <LI> versionColumnNotPseudo - is NOT a pseudo column 2102     * <LI> versionColumnPseudo - is a pseudo column 2103     * </UL> 2104     * </OL> 2105     * 2106     * @param catalog a catalog name; "" retrieves those without a 2107     * catalog; null means drop catalog name from the selection criteria 2108     * @param schema a schema name; "" retrieves those without a schema 2109     * @param table a table name 2110     * @return ResultSet - each row is a column description 2111     */ 2112  public java.sql.ResultSet getVersionColumns(String catalog, String schema, 2113  String table) throws SQLException { 2114    try { 2115      return new RJResultSet( 2116       rmiMetadata_.getVersionColumns(catalog, schema, table), 2117       null); 2118    } catch(RemoteException e) { 2119      throw new java.sql.SQLException (e.getMessage()); 2120    } 2121  } 2122 2123    /** 2124     * Get a description of a table's primary key columns. They 2125     * are ordered by COLUMN_NAME. 2126     * 2127     * <P>Each primary key column description has the following columns: 2128     * <OL> 2129     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 2130     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 2131     * <LI><B>TABLE_NAME</B> String => table name 2132     * <LI><B>COLUMN_NAME</B> String => column name 2133     * <LI><B>KEY_SEQ</B> short => sequence number within primary key 2134     * <LI><B>PK_NAME</B> String => primary key name (may be null) 2135     * </OL> 2136     * 2137     * @param catalog a catalog name; "" retrieves those without a 2138     * catalog; null means drop catalog name from the selection criteria 2139     * @param schema a schema name pattern; "" retrieves those 2140     * without a schema 2141     * @param table a table name 2142     * @return ResultSet - each row is a primary key column description 2143     */ 2144  public java.sql.ResultSet getPrimaryKeys(String catalog, String schema, 2145  String table) throws SQLException { 2146    try { 2147      return new RJResultSet( 2148       rmiMetadata_.getPrimaryKeys(catalog, schema, table), 2149       null); 2150    } catch(RemoteException e) { 2151      throw new java.sql.SQLException (e.getMessage()); 2152    } 2153  } 2154 2155    /** 2156     * Get a description of the primary key columns that are 2157     * referenced by a table's foreign key columns (the primary keys 2158     * imported by a table). They are ordered by PKTABLE_CAT, 2159     * PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ. 2160     * 2161     * <P>Each primary key column description has the following columns: 2162     * <OL> 2163     * <LI><B>PKTABLE_CAT</B> String => primary key table catalog 2164     * being imported (may be null) 2165     * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema 2166     * being imported (may be null) 2167     * <LI><B>PKTABLE_NAME</B> String => primary key table name 2168     * being imported 2169     * <LI><B>PKCOLUMN_NAME</B> String => primary key column name 2170     * being imported 2171     * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be null) 2172     * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be null) 2173     * <LI><B>FKTABLE_NAME</B> String => foreign key table name 2174     * <LI><B>FKCOLUMN_NAME</B> String => foreign key column name 2175     * <LI><B>KEY_SEQ</B> short => sequence number within foreign key 2176     * <LI><B>UPDATE_RULE</B> short => What happens to 2177     * foreign key when primary is updated: 2178     * <UL> 2179     * <LI> importedNoAction - do not allow update of primary 2180     * key if it has been imported 2181     * <LI> importedKeyCascade - change imported key to agree 2182     * with primary key update 2183     * <LI> importedKeySetNull - change imported key to NULL if 2184     * its primary key has been updated 2185     * <LI> importedKeySetDefault - change imported key to default values 2186     * if its primary key has been updated 2187     * <LI> importedKeyRestrict - same as importedKeyNoAction 2188     * (for ODBC 2.x compatibility) 2189     * </UL> 2190     * <LI><B>DELETE_RULE</B> short => What happens to 2191     * the foreign key when primary is deleted. 2192     * <UL> 2193     * <LI> importedKeyNoAction - do not allow delete of primary 2194     * key if it has been imported 2195     * <LI> importedKeyCascade - delete rows that import a deleted key 2196     * <LI> importedKeySetNull - change imported key to NULL if 2197     * its primary key has been deleted 2198     * <LI> importedKeyRestrict - same as importedKeyNoAction 2199     * (for ODBC 2.x compatibility) 2200     * <LI> importedKeySetDefault - change imported key to default if 2201     * its primary key has been deleted 2202     * </UL> 2203     * <LI><B>FK_NAME</B> String => foreign key name (may be null) 2204     * <LI><B>PK_NAME</B> String => primary key name (may be null) 2205     * <LI><B>DEFERRABILITY</B> short => can the evaluation of foreign key 2206     * constraints be deferred until commit 2207     * <UL> 2208     * <LI> importedKeyInitiallyDeferred - see SQL92 for definition 2209     * <LI> importedKeyInitiallyImmediate - see SQL92 for definition 2210     * <LI> importedKeyNotDeferrable - see SQL92 for definition 2211     * </UL> 2212     * </OL> 2213     * 2214     * @param catalog a catalog name; "" retrieves those without a 2215     * catalog; null means drop catalog name from the selection criteria 2216     * @param schema a schema name pattern; "" retrieves those 2217     * without a schema 2218     * @param table a table name 2219     * @return ResultSet - each row is a primary key column description 2220     * @see #getExportedKeys 2221     */ 2222  public java.sql.ResultSet getImportedKeys(String catalog, String schema, 2223  String table) throws SQLException { 2224    try { 2225      return new RJResultSet( 2226       rmiMetadata_.getImportedKeys(catalog, schema, table), 2227       null); 2228    } catch(RemoteException e) { 2229      throw new java.sql.SQLException (e.getMessage()); 2230    } 2231  } 2232 2233    /** 2234     * Get a description of the foreign key columns that reference a 2235     * table's primary key columns (the foreign keys exported by a 2236     * table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM, 2237     * FKTABLE_NAME, and KEY_SEQ. 2238     * 2239     * <P>Each foreign key column description has the following columns: 2240     * <OL> 2241     * <LI><B>PKTABLE_CAT</B> String => primary key table catalog (may be null) 2242     * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema (may be null) 2243     * <LI><B>PKTABLE_NAME</B> String => primary key table name 2244     * <LI><B>PKCOLUMN_NAME</B> String => primary key column name 2245     * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be null) 2246     * being exported (may be null) 2247     * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be null) 2248     * being exported (may be null) 2249     * <LI><B>FKTABLE_NAME</B> String => foreign key table name 2250     * being exported 2251     * <LI><B>FKCOLUMN_NAME</B> String => foreign key column name 2252     * being exported 2253     * <LI><B>KEY_SEQ</B> short => sequence number within foreign key 2254     * <LI><B>UPDATE_RULE</B> short => What happens to 2255     * foreign key when primary is updated: 2256     * <UL> 2257     * <LI> importedNoAction - do not allow update of primary 2258     * key if it has been imported 2259     * <LI> importedKeyCascade - change imported key to agree 2260     * with primary key update 2261     * <LI> importedKeySetNull - change imported key to NULL if 2262     * its primary key has been updated 2263     * <LI> importedKeySetDefault - change imported key to default values 2264     * if its primary key has been updated 2265     * <LI> importedKeyRestrict - same as importedKeyNoAction 2266     * (for ODBC 2.x compatibility) 2267     * </UL> 2268     * <LI><B>DELETE_RULE</B> short => What happens to 2269     * the foreign key when primary is deleted. 2270     * <UL> 2271     * <LI> importedKeyNoAction - do not allow delete of primary 2272     * key if it has been imported 2273     * <LI> importedKeyCascade - delete rows that import a deleted key 2274     * <LI> importedKeySetNull - change imported key to NULL if 2275     * its primary key has been deleted 2276     * <LI> importedKeyRestrict - same as importedKeyNoAction 2277     * (for ODBC 2.x compatibility) 2278     * <LI> importedKeySetDefault - change imported key to default if 2279     * its primary key has been deleted 2280     * </UL> 2281     * <LI><B>FK_NAME</B> String => foreign key name (may be null) 2282     * <LI><B>PK_NAME</B> String => primary key name (may be null) 2283     * <LI><B>DEFERRABILITY</B> short => can the evaluation of foreign key 2284     * constraints be deferred until commit 2285     * <UL> 2286     * <LI> importedKeyInitiallyDeferred - see SQL92 for definition 2287     * <LI> importedKeyInitiallyImmediate - see SQL92 for definition 2288     * <LI> importedKeyNotDeferrable - see SQL92 for definition 2289     * </UL> 2290     * </OL> 2291     * 2292     * @param catalog a catalog name; "" retrieves those without a 2293     * catalog; null means drop catalog name from the selection criteria 2294     * @param schema a schema name pattern; "" retrieves those 2295     * without a schema 2296     * @param table a table name 2297     * @return ResultSet - each row is a foreign key column description 2298     * @see #getImportedKeys 2299     */ 2300  public java.sql.ResultSet getExportedKeys(String catalog, String schema, 2301  String table) throws SQLException { 2302    try { 2303      return new RJResultSet( 2304       rmiMetadata_.getExportedKeys(catalog, schema, table), 2305       null); 2306    } catch(RemoteException e) { 2307      throw new java.sql.SQLException (e.getMessage()); 2308    } 2309  } 2310 2311    /** 2312     * Get a description of the foreign key columns in the foreign key 2313     * table that reference the primary key columns of the primary key 2314     * table (describe how one table imports another's key.) This 2315     * should normally return a single foreign key/primary key pair 2316     * (most tables only import a foreign key from a table once.) They 2317     * are ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and 2318     * KEY_SEQ. 2319     * 2320     * <P>Each foreign key column description has the following columns: 2321     * <OL> 2322     * <LI><B>PKTABLE_CAT</B> String => primary key table catalog (may be null) 2323     * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema (may be null) 2324     * <LI><B>PKTABLE_NAME</B> String => primary key table name 2325     * <LI><B>PKCOLUMN_NAME</B> String => primary key column name 2326     * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be null) 2327     * being exported (may be null) 2328     * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be null) 2329     * being exported (may be null) 2330     * <LI><B>FKTABLE_NAME</B> String => foreign key table name 2331     * being exported 2332     * <LI><B>FKCOLUMN_NAME</B> String => foreign key column name 2333     * being exported 2334     * <LI><B>KEY_SEQ</B> short => sequence number within foreign key 2335     * <LI><B>UPDATE_RULE</B> short => What happens to 2336     * foreign key when primary is updated: 2337     * <UL> 2338     * <LI> importedNoAction - do not allow update of primary 2339     * key if it has been imported 2340     * <LI> importedKeyCascade - change imported key to agree 2341     * with primary key update 2342     * <LI> importedKeySetNull - change imported key to NULL if 2343     * its primary key has been updated 2344     * <LI> importedKeySetDefault - change imported key to default values 2345     * if its primary key has been updated 2346     * <LI> importedKeyRestrict - same as importedKeyNoAction 2347     * (for ODBC 2.x compatibility) 2348     * </UL> 2349     * <LI><B>DELETE_RULE</B> short => What happens to 2350     * the foreign key when primary is deleted. 2351     * <UL> 2352     * <LI> importedKeyNoAction - do not allow delete of primary 2353     * key if it has been imported 2354     * <LI> importedKeyCascade - delete rows that import a deleted key 2355     * <LI> importedKeySetNull - change imported key to NULL if 2356     * its primary key has been deleted 2357     * <LI> importedKeyRestrict - same as importedKeyNoAction 2358     * (for ODBC 2.x compatibility) 2359     * <LI> importedKeySetDefault - change imported key to default if 2360     * its primary key has been deleted 2361     * </UL> 2362     * <LI><B>FK_NAME</B> String => foreign key name (may be null) 2363     * <LI><B>PK_NAME</B> String => primary key name (may be null) 2364     * <LI><B>DEFERRABILITY</B> short => can the evaluation of foreign key 2365     * constraints be deferred until commit 2366     * <UL> 2367     * <LI> importedKeyInitiallyDeferred - see SQL92 for definition 2368     * <LI> importedKeyInitiallyImmediate - see SQL92 for definition 2369     * <LI> importedKeyNotDeferrable - see SQL92 for definition 2370     * </UL> 2371     * </OL> 2372     * 2373     * @param primaryCatalog a catalog name; "" retrieves those without a 2374     * catalog; null means drop catalog name from the selection criteria 2375     * @param primarySchema a schema name pattern; "" retrieves those 2376     * without a schema 2377     * @param primaryTable the table name that exports the key 2378     * @param foreignCatalog a catalog name; "" retrieves those without a 2379     * catalog; null means drop catalog name from the selection criteria 2380     * @param foreignSchema a schema name pattern; "" retrieves those 2381     * without a schema 2382     * @param foreignTable the table name that imports the key 2383     * @return ResultSet - each row is a foreign key column description 2384     * @see #getImportedKeys 2385     */ 2386  public java.sql.ResultSet getCrossReference( 2387  String primaryCatalog, String primarySchema, String primaryTable, 2388  String foreignCatalog, String foreignSchema, String foreignTable) 2389  throws SQLException { 2390    try { 2391      return new RJResultSet( 2392       rmiMetadata_.getCrossReference( 2393         primaryCatalog, primarySchema, primaryTable, 2394         foreignCatalog, foreignSchema, foreignTable), 2395       null); 2396    } catch(RemoteException e) { 2397      throw new java.sql.SQLException (e.getMessage()); 2398    } 2399  } 2400 2401    /** 2402     * Get a description of all the standard SQL types supported by 2403     * this database. They are ordered by DATA_TYPE and then by how 2404     * closely the data type maps to the corresponding JDBC SQL type. 2405     * 2406     * <P>Each type description has the following columns: 2407     * <OL> 2408     * <LI><B>TYPE_NAME</B> String => Type name 2409     * <LI><B>DATA_TYPE</B> short => SQL data type from java.sql.Types 2410     * <LI><B>PRECISION</B> int => maximum precision 2411     * <LI><B>LITERAL_PREFIX</B> String => prefix used to quote a literal 2412     * (may be null) 2413     * <LI><B>LITERAL_SUFFIX</B> String => suffix used to quote a literal 2414            (may be null) 2415     * <LI><B>CREATE_PARAMS</B> String => parameters used in creating 2416     * the type (may be null) 2417     * <LI><B>NULLABLE</B> short => can you use NULL for this type? 2418     * <UL> 2419     * <LI> typeNoNulls - does not allow NULL values 2420     * <LI> typeNullable - allows NULL values 2421     * <LI> typeNullableUnknown - nullability unknown 2422     * </UL> 2423     * <LI><B>CASE_SENSITIVE</B> boolean=> is it case sensitive? 2424     * <LI><B>SEARCHABLE</B> short => can you use "WHERE" based on this type: 2425     * <UL> 2426     * <LI> typePredNone - No support 2427     * <LI> typePredChar - Only supported with WHERE .. LIKE 2428     * <LI> typePredBasic - Supported except for WHERE .. LIKE 2429     * <LI> typeSearchable - Supported for all WHERE .. 2430     * </UL> 2431     * <LI><B>UNSIGNED_ATTRIBUTE</B> boolean => is it unsigned? 2432     * <LI><B>FIXED_PREC_SCALE</B> boolean => can it be a money value? 2433     * <LI><B>AUTO_INCREMENT</B> boolean => can it be used for an 2434     * auto-increment value? 2435     * <LI><B>LOCAL_TYPE_NAME</B> String => localized version of type name 2436     * (may be null) 2437     * <LI><B>MINIMUM_SCALE</B> short => minimum scale supported 2438     * <LI><B>MAXIMUM_SCALE</B> short => maximum scale supported 2439     * <LI><B>SQL_DATA_TYPE</B> int => unused 2440     * <LI><B>SQL_DATETIME_SUB</B> int => unused 2441     * <LI><B>NUM_PREC_RADIX</B> int => usually 2 or 10 2442     * </OL> 2443     * 2444     * @return ResultSet - each row is a SQL type description 2445     */ 2446  public java.sql.ResultSet getTypeInfo() throws SQLException { 2447    try { 2448      return new RJResultSet(rmiMetadata_.getTypeInfo(), null); 2449    } catch(RemoteException e) { 2450      throw new java.sql.SQLException (e.getMessage()); 2451    } 2452  } 2453  2454    /** 2455     * Get a description of a table's indices and statistics. They are 2456     * ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION. 2457     * 2458     * <P>Each index column description has the following columns: 2459     * <OL> 2460     * <LI><B>TABLE_CAT</B> String => table catalog (may be null) 2461     * <LI><B>TABLE_SCHEM</B> String => table schema (may be null) 2462     * <LI><B>TABLE_NAME</B> String => table name 2463     * <LI><B>NON_UNIQUE</B> boolean => Can index values be non-unique? 2464     * false when TYPE is tableIndexStatistic 2465     * <LI><B>INDEX_QUALIFIER</B> String => index catalog (may be null); 2466     * null when TYPE is tableIndexStatistic 2467     * <LI><B>INDEX_NAME</B> String => index name; null when TYPE is 2468     * tableIndexStatistic 2469     * <LI><B>TYPE</B> short => index type: 2470     * <UL> 2471     * <LI> tableIndexStatistic - this identifies table statistics that are 2472     * returned in conjuction with a table's index descriptions 2473     * <LI> tableIndexClustered - this is a clustered index 2474     * <LI> tableIndexHashed - this is a hashed index 2475     * <LI> tableIndexOther - this is some other style of index 2476     * </UL> 2477     * <LI><B>ORDINAL_POSITION</B> short => column sequence number 2478     * within index; zero when TYPE is tableIndexStatistic 2479     * <LI><B>COLUMN_NAME</B> String => column name; null when TYPE is 2480     * tableIndexStatistic 2481     * <LI><B>ASC_OR_DESC</B> String => column sort sequence, "A" => ascending, 2482     * "D" => descending, may be null if sort sequence is not supported; 2483     * null when TYPE is tableIndexStatistic 2484     * <LI><B>CARDINALITY</B> int => When TYPE is tableIndexStatistic, then 2485     * this is the number of rows in the table; otherwise, it is the 2486     * number of unique values in the index. 2487     * <LI><B>PAGES</B> int => When TYPE is tableIndexStatisic then 2488     * this is the number of pages used for the table, otherwise it 2489     * is the number of pages used for the current index. 2490     * <LI><B>FILTER_CONDITION</B> String => Filter condition, if any. 2491     * (may be null) 2492     * </OL> 2493     * 2494     * @param catalog a catalog name; "" retrieves those without a 2495     * catalog; null means drop catalog name from the selection criteria 2496     * @param schema a schema name pattern; "" retrieves those without a schema 2497     * @param table a table name 2498     * @param unique when true, return only indices for unique values; 2499     * when false, return indices regardless of whether unique or not 2500     * @param approximate when true, result is allowed to reflect approximate 2501     * or out of data values; when false, results are requested to be 2502     * accurate 2503     * @return ResultSet - each row is an index column description 2504     */ 2505  public java.sql.ResultSet getIndexInfo(String catalog, String schema, 2506  String table, boolean unique, boolean approximate) throws SQLException { 2507    try { 2508      return new RJResultSet( 2509       rmiMetadata_.getIndexInfo(catalog, schema, table, unique, approximate), 2510       null); 2511    } catch(RemoteException e) { 2512      throw new java.sql.SQLException (e.getMessage()); 2513    } 2514  } 2515 2516 2517// JDBC 2.0 methods 2518 2519public boolean updatesAreDetected(int type) throws SQLException 2520  { 2521    try { 2522      return rmiMetadata_.updatesAreDetected(type); 2523    } catch(RemoteException e) { 2524      throw new java.sql.SQLException (e.getMessage()); 2525    } 2526  } 2527 2528public boolean supportsResultSetType(int type) throws SQLException 2529  { 2530    try { 2531      return rmiMetadata_.supportsResultSetType(type); 2532    } catch(RemoteException e) { 2533      throw new java.sql.SQLException (e.getMessage()); 2534    } 2535  } 2536 2537public boolean supportsResultSetConcurrency(int type, 2538                                            int concurrency) throws SQLException 2539  { 2540    try { 2541      return rmiMetadata_.supportsResultSetConcurrency(type,concurrency); 2542    } catch(RemoteException e) { 2543      throw new java.sql.SQLException (e.getMessage()); 2544    } 2545  } 2546 2547public boolean ownUpdatesAreVisible(int type) throws SQLException 2548  { 2549    try { 2550      return rmiMetadata_.ownUpdatesAreVisible(type); 2551    } catch(RemoteException e) { 2552      throw new java.sql.SQLException (e.getMessage()); 2553    } 2554  } 2555 2556public boolean ownInsertsAreVisible(int type) throws SQLException 2557  { 2558    try { 2559      return rmiMetadata_.ownInsertsAreVisible(type); 2560    } catch(RemoteException e) { 2561      throw new java.sql.SQLException (e.getMessage()); 2562    } 2563  } 2564 2565public boolean ownDeletesAreVisible(int type) throws SQLException 2566  { 2567    try { 2568      return rmiMetadata_.ownDeletesAreVisible(type); 2569    } catch(RemoteException e) { 2570      throw new java.sql.SQLException (e.getMessage()); 2571    } 2572  } 2573 2574public boolean othersUpdatesAreVisible(int type) throws SQLException 2575  { 2576    try { 2577      return rmiMetadata_.othersUpdatesAreVisible(type); 2578    } catch(RemoteException e) { 2579      throw new java.sql.SQLException (e.getMessage()); 2580    } 2581  } 2582 2583public boolean othersInsertsAreVisible(int type) throws SQLException 2584  { 2585    try { 2586      return rmiMetadata_.othersInsertsAreVisible(type); 2587    } catch(RemoteException e) { 2588      throw new java.sql.SQLException (e.getMessage()); 2589    } 2590  } 2591 2592public boolean othersDeletesAreVisible(int type) throws SQLException 2593  { 2594    try { 2595      return rmiMetadata_.othersDeletesAreVisible(type); 2596    } catch(RemoteException e) { 2597      throw new java.sql.SQLException (e.getMessage()); 2598    } 2599  } 2600 2601public boolean insertsAreDetected(int type) throws SQLException 2602  { 2603    try { 2604      return rmiMetadata_.insertsAreDetected(type); 2605    } catch(RemoteException e) { 2606      throw new java.sql.SQLException (e.getMessage()); 2607    } 2608  } 2609 2610 2611  public ResultSet getUDTs(String catalog, String schemaPattern, 2612  String typeNamePattern, int[] types) throws SQLException { 2613    try { 2614      return new RJResultSet( 2615       rmiMetadata_.getUDTs(catalog,schemaPattern,typeNamePattern,types), 2616       null); 2617    } catch(RemoteException e) { 2618      throw new java.sql.SQLException (e.getMessage()); 2619    } 2620  } 2621 2622 2623public boolean supportsBatchUpdates() throws SQLException 2624  { 2625    try { 2626      return rmiMetadata_.supportsBatchUpdates(); 2627    } catch(RemoteException e) { 2628      throw new java.sql.SQLException (e.getMessage()); 2629    } 2630  } 2631 2632  public Connection getConnection() throws SQLException { 2633    return connection_; 2634  } 2635 2636public boolean deletesAreDetected(int type) throws SQLException 2637  { 2638    try { 2639      return rmiMetadata_.deletesAreDetected(type); 2640    } catch(RemoteException e) { 2641      throw new java.sql.SQLException (e.getMessage()); 2642    } 2643  } 2644 2645  // ------------------- JDBC 3.0 ------------------------- 2646 2647  public boolean supportsSavepoints() throws SQLException { 2648    try { 2649      return rmiMetadata_.supportsSavepoints(); 2650    } catch(RemoteException e) { 2651      throw new java.sql.SQLException (e.getMessage()); 2652    } 2653  } 2654 2655  public boolean supportsNamedParameters() throws SQLException { 2656    try { 2657      return rmiMetadata_.supportsNamedParameters(); 2658    } catch(RemoteException e) { 2659      throw new java.sql.SQLException (e.getMessage()); 2660    } 2661  } 2662 2663  public boolean supportsMultipleOpenResults() throws SQLException { 2664    try { 2665      return rmiMetadata_.supportsMultipleOpenResults(); 2666    } catch(RemoteException e) { 2667      throw new java.sql.SQLException (e.getMessage()); 2668    } 2669  } 2670 2671  public boolean supportsGetGeneratedKeys() throws SQLException { 2672    try { 2673      return rmiMetadata_.supportsGetGeneratedKeys(); 2674    } catch(RemoteException e) { 2675      throw new java.sql.SQLException (e.getMessage()); 2676    } 2677  } 2678 2679  public ResultSet getSuperTypes(String catalog, String schemaPattern, 2680  String typeNamePattern) throws SQLException { 2681    try { 2682      return new RJResultSet( 2683       rmiMetadata_.getSuperTypes(catalog, schemaPattern, typeNamePattern), 2684       null); 2685    } catch(RemoteException e) { 2686      throw new java.sql.SQLException (e.getMessage()); 2687    } 2688  } 2689 2690  public ResultSet getSuperTables(String catalog, String schemaPattern, 2691  String tableNamePattern) throws SQLException { 2692    try { 2693      return new RJResultSet( 2694       rmiMetadata_.getSuperTables(catalog, schemaPattern, tableNamePattern), 2695       null); 2696    } catch(RemoteException e) { 2697      throw new java.sql.SQLException (e.getMessage()); 2698    } 2699  } 2700 2701  public ResultSet getAttributes(String catalog, String schemaPattern, 2702  String typeNamePattern, String attributeNamePattern) throws SQLException { 2703    try { 2704      return new RJResultSet( 2705       rmiMetadata_.getAttributes(catalog, schemaPattern, typeNamePattern, 2706         attributeNamePattern), 2707       null); 2708    } catch(RemoteException e) { 2709      throw new java.sql.SQLException (e.getMessage()); 2710    } 2711  } 2712 2713  public boolean supportsResultSetHoldability(int holdability) 2714  throws SQLException { 2715    try { 2716      return rmiMetadata_.supportsResultSetHoldability(holdability); 2717    } catch(RemoteException e) { 2718      throw new java.sql.SQLException (e.getMessage()); 2719    } 2720  } 2721 2722  public int getResultSetHoldability() throws SQLException { 2723    try { 2724      return rmiMetadata_.getResultSetHoldability(); 2725    } catch(RemoteException e) { 2726      throw new java.sql.SQLException (e.getMessage()); 2727    } 2728  } 2729 2730  public int getDatabaseMajorVersion() throws SQLException { 2731    try { 2732      return rmiMetadata_.getDatabaseMajorVersion(); 2733    } catch(RemoteException e) { 2734      throw new java.sql.SQLException (e.getMessage()); 2735    } 2736  } 2737 2738  public int getDatabaseMinorVersion() throws SQLException { 2739    try { 2740      return rmiMetadata_.getDatabaseMinorVersion(); 2741    } catch(RemoteException e) { 2742      throw new java.sql.SQLException (e.getMessage()); 2743    } 2744  } 2745 2746  public int getJDBCMajorVersion() throws SQLException { 2747    try { 2748      return rmiMetadata_.getJDBCMajorVersion(); 2749    } catch(RemoteException e) { 2750      throw new java.sql.SQLException (e.getMessage()); 2751    } 2752  } 2753 2754  public int getJDBCMinorVersion() throws SQLException { 2755    try { 2756      return rmiMetadata_.getJDBCMinorVersion(); 2757    } catch(RemoteException e) { 2758      throw new java.sql.SQLException (e.getMessage()); 2759    } 2760  } 2761 2762  public int getSQLStateType() throws SQLException { 2763    try { 2764      return rmiMetadata_.getSQLStateType(); 2765    } catch(RemoteException e) { 2766      throw new java.sql.SQLException (e.getMessage()); 2767    } 2768  } 2769 2770  public boolean locatorsUpdateCopy() throws SQLException { 2771    try { 2772      return rmiMetadata_.locatorsUpdateCopy(); 2773    } catch(RemoteException e) { 2774      throw new java.sql.SQLException (e.getMessage()); 2775    } 2776  } 2777 2778  public boolean supportsStatementPooling() throws SQLException { 2779    try { 2780      return rmiMetadata_.supportsStatementPooling(); 2781    } catch(RemoteException e) { 2782      throw new java.sql.SQLException (e.getMessage()); 2783    } 2784  } 2785 2786}; 2787 2788

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