Java API By Example, From Geeks To Geeks.

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

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