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