Java API By Example, From Geeks To Geeks.

1 /* 2  $Id: GroovyResultSet.java,v 1.5 2004/03/26 18:54:09 jstrachan Exp $ 3 4  Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved. 5 6  Redistribution and use of this software and associated documentation 7  ("Software"), with or without modification, are permitted provided 8  that the following conditions are met: 9 10  1. Redistributions of source code must retain copyright 11     statements and notices. Redistributions must also contain a 12     copy of this document. 13 14  2. Redistributions in binary form must reproduce the 15     above copyright notice, this list of conditions and the 16     following disclaimer in the documentation and/or other 17     materials provided with the distribution. 18 19  3. The name "groovy" must not be used to endorse or promote 20     products derived from this Software without prior written 21     permission of The Codehaus. For written permission, 22     please contact info@codehaus.org. 23 24  4. Products derived from this Software may not be called "groovy" 25     nor may "groovy" appear in their names without prior written 26     permission of The Codehaus. "groovy" is a registered 27     trademark of The Codehaus. 28 29  5. Due credit should be given to The Codehaus - 30     http://groovy.codehaus.org/ 31 32  THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS 33  ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT 34  NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 35  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 36  THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 37  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 38  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 39  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 40  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 41  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 42  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 43  OF THE POSSIBILITY OF SUCH DAMAGE. 44 45  */ 46 package groovy.sql; 47 48 import groovy.lang.GroovyObjectSupport; 49 import groovy.lang.MissingPropertyException; 50 51 import java.math.BigDecimal ; 52 import java.sql.Array ; 53 import java.sql.Blob ; 54 import java.sql.Clob ; 55 import java.sql.Ref ; 56 import java.sql.ResultSet ; 57 import java.sql.ResultSetMetaData ; 58 import java.sql.SQLException ; 59 import java.sql.SQLWarning ; 60 import java.sql.Statement ; 61 import java.util.Calendar ; 62 import java.util.Iterator ; 63 import java.util.Map ; 64 65 /** 66  * Represents an extent of objects 67  * 68  * @Author Chris Stevenson 69  * @author <a HREF="mailto:james@coredevelopers.net">James Strachan</a> 70  * @author <a HREF="mailto:ivan_ganza@yahoo.com">Ivan Ganza</a> 71  * @version $Revision: 1.5 $ 72  */ 73 public class GroovyResultSet extends GroovyObjectSupport implements ResultSet { 74 75     private ResultSet resultSet; 76     private boolean updated; 77 78     public GroovyResultSet(ResultSet resultSet) { 79         this.resultSet = resultSet; 80     } 81 82     public Object getProperty(String property) { 83         try { 84             return resultSet.getObject(property); 85         } 86         catch (SQLException e) { 87             throw new MissingPropertyException(property, GroovyResultSet.class, e); 88         } 89     } 90 91     public void setProperty(String property, Object newValue) { 92         try { 93             resultSet.updateObject(property, newValue); 94             updated = true; 95         } 96         catch (SQLException e) { 97             throw new MissingPropertyException(property, GroovyResultSet.class, e); 98         } 99     } 100 101     /** 102      * Supports integer based subscript operators for accessing at numbered columns 103      * starting at zero. Negative indices are supported, they will count from the last column backwards. 104      * 105      * @param index is the number of the column to look at starting at 1 106      * @return 107      */ 108     public Object getAt(int index) throws SQLException { 109         index = normalizeIndex(index); 110         return resultSet.getObject(index); 111     } 112 113     /** 114      * Supports integer based subscript operators for updating the values of numbered columns 115      * starting at zero. Negative indices are supported, they will count from the last column backwards. 116      * 117      * @param index is the number of the column to look at starting at 1 118      * @return 119      */ 120     public void putAt(int index, Object newValue) throws SQLException { 121         index = normalizeIndex(index); 122         resultSet.updateObject(index, newValue); 123     } 124 125     /** 126      * Adds a new row to this result set 127      * @param values 128      */ 129     public void add(Map values) throws SQLException { 130         resultSet.moveToInsertRow(); 131         for (Iterator iter = values.entrySet().iterator(); iter.hasNext();) { 132             Map.Entry entry = (Map.Entry ) iter.next(); 133             resultSet.updateObject(entry.getKey().toString(), entry.getValue()); 134         } 135         resultSet.insertRow(); 136     } 137      138     /** 139      * Takes a zero based index and convert it into an SQL based 1 based index. 140      * A negative index will count backwards from the last column. 141      * 142      * @param index 143      * @return a JDBC index 144      * @throws SQLException if some exception occurs finding out the column count 145      */ 146     protected int normalizeIndex(int index) throws SQLException { 147         if (index < 0) { 148             int columnCount = resultSet.getMetaData().getColumnCount(); 149             do { 150                 index += columnCount; 151             } 152             while (index < 0); 153         } 154         return index + 1; 155     } 156 157     // Implementation of java.sql.ResultSet 158 // ------------------------------------------------------------ 159 160     /** 161      * Moves the cursor down one row from its current position. 162      * A <code>ResultSet</code> cursor is initially positioned 163      * before the first row; the first call to the method 164      * <code>next</code> makes the first row the current row; the 165      * second call makes the second row the current row, and so on. 166      * 167      * <P>If an input stream is open for the current row, a call 168      * to the method <code>next</code> will 169      * implicitly close it. A <code>ResultSet</code> object's 170      * warning chain is cleared when a new row is read. 171      * 172      * @return <code>true</code> if the new current row is valid; 173      * <code>false</code> if there are no more rows 174      * @exception SQLException if a database access error occurs 175      */ 176     public boolean next() throws SQLException { 177         if (updated) { 178             resultSet.updateRow(); 179             updated = false; 180         } 181         return resultSet.next(); 182     } 183 184 185     /** 186      * Releases this <code>ResultSet</code> object's database and 187      * JDBC resources immediately instead of waiting for 188      * this to happen when it is automatically closed. 189      * 190      * <P><B>Note:</B> A <code>ResultSet</code> object 191      * is automatically closed by the 192      * <code>Statement</code> object that generated it when 193      * that <code>Statement</code> object is closed, 194      * re-executed, or is used to retrieve the next result from a 195      * sequence of multiple results. A <code>ResultSet</code> object 196      * is also automatically closed when it is garbage collected. 197      * 198      * @exception SQLException if a database access error occurs 199      */ 200     public void close() throws SQLException { 201         resultSet.close(); 202     } 203 204     /** 205      * Reports whether 206      * the last column read had a value of SQL <code>NULL</code>. 207      * Note that you must first call one of the getter methods 208      * on a column to try to read its value and then call 209      * the method <code>wasNull</code> to see if the value read was 210      * SQL <code>NULL</code>. 211      * 212      * @return <code>true</code> if the last column value read was SQL 213      * <code>NULL</code> and <code>false</code> otherwise 214      * @exception SQLException if a database access error occurs 215      */ 216     public boolean wasNull() throws SQLException { 217         return resultSet.wasNull(); 218     } 219      220     //====================================================================== 221 // Methods for accessing results by column index 222 //====================================================================== 223 224     /** 225      * Retrieves the value of the designated column in the current row 226      * of this <code>ResultSet</code> object as 227      * a <code>String</code> in the Java programming language. 228      * 229      * @param columnIndex the first column is 1, the second is 2, ... 230      * @return the column value; if the value is SQL <code>NULL</code>, the 231      * value returned is <code>null</code> 232      * @exception SQLException if a database access error occurs 233      */ 234     public String getString(int columnIndex) throws SQLException { 235         return resultSet.getString(columnIndex); 236     } 237 238     /** 239      * Retrieves the value of the designated column in the current row 240      * of this <code>ResultSet</code> object as 241      * a <code>boolean</code> in the Java programming language. 242      * 243      * @param columnIndex the first column is 1, the second is 2, ... 244      * @return the column value; if the value is SQL <code>NULL</code>, the 245      * value returned is <code>false</code> 246      * @exception SQLException if a database access error occurs 247      */ 248     public boolean getBoolean(int columnIndex) throws SQLException { 249         return resultSet.getBoolean(columnIndex); 250     } 251 252     /** 253      * Retrieves the value of the designated column in the current row 254      * of this <code>ResultSet</code> object as 255      * a <code>byte</code> in the Java programming language. 256      * 257      * @param columnIndex the first column is 1, the second is 2, ... 258      * @return the column value; if the value is SQL <code>NULL</code>, the 259      * value returned is <code>0</code> 260      * @exception SQLException if a database access error occurs 261      */ 262     public byte getByte(int columnIndex) throws SQLException { 263         return resultSet.getByte(columnIndex); 264     } 265 266     /** 267      * Retrieves the value of the designated column in the current row 268      * of this <code>ResultSet</code> object as 269      * a <code>short</code> in the Java programming language. 270      * 271      * @param columnIndex the first column is 1, the second is 2, ... 272      * @return the column value; if the value is SQL <code>NULL</code>, the 273      * value returned is <code>0</code> 274      * @exception SQLException if a database access error occurs 275      */ 276     public short getShort(int columnIndex) throws SQLException { 277         return resultSet.getShort(columnIndex); 278     } 279 280     /** 281      * Retrieves the value of the designated column in the current row 282      * of this <code>ResultSet</code> object as 283      * an <code>int</code> in the Java programming language. 284      * 285      * @param columnIndex the first column is 1, the second is 2, ... 286      * @return the column value; if the value is SQL <code>NULL</code>, the 287      * value returned is <code>0</code> 288      * @exception SQLException if a database access error occurs 289      */ 290     public int getInt(int columnIndex) throws SQLException { 291         return resultSet.getInt(columnIndex); 292     } 293 294     /** 295      * Retrieves the value of the designated column in the current row 296      * of this <code>ResultSet</code> object as 297      * a <code>long</code> in the Java programming language. 298      * 299      * @param columnIndex the first column is 1, the second is 2, ... 300      * @return the column value; if the value is SQL <code>NULL</code>, the 301      * value returned is <code>0</code> 302      * @exception SQLException if a database access error occurs 303      */ 304     public long getLong(int columnIndex) throws SQLException { 305         return resultSet.getLong(columnIndex); 306     } 307 308     /** 309      * Retrieves the value of the designated column in the current row 310      * of this <code>ResultSet</code> object as 311      * a <code>float</code> in the Java programming language. 312      * 313      * @param columnIndex the first column is 1, the second is 2, ... 314      * @return the column value; if the value is SQL <code>NULL</code>, the 315      * value returned is <code>0</code> 316      * @exception SQLException if a database access error occurs 317      */ 318     public float getFloat(int columnIndex) throws SQLException { 319         return resultSet.getFloat(columnIndex); 320     } 321 322     /** 323      * Retrieves the value of the designated column in the current row 324      * of this <code>ResultSet</code> object as 325      * a <code>double</code> in the Java programming language. 326      * 327      * @param columnIndex the first column is 1, the second is 2, ... 328      * @return the column value; if the value is SQL <code>NULL</code>, the 329      * value returned is <code>0</code> 330      * @exception SQLException if a database access error occurs 331      */ 332     public double getDouble(int columnIndex) throws SQLException { 333         return resultSet.getDouble(columnIndex); 334     } 335 336     /** 337      * Retrieves the value of the designated column in the current row 338      * of this <code>ResultSet</code> object as 339      * a <code>java.sql.BigDecimal</code> in the Java programming language. 340      * 341      * @param columnIndex the first column is 1, the second is 2, ... 342      * @param scale the number of digits to the right of the decimal point 343      * @return the column value; if the value is SQL <code>NULL</code>, the 344      * value returned is <code>null</code> 345      * @exception SQLException if a database access error occurs 346      * @deprecated 347      */ 348     public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException { 349         return resultSet.getBigDecimal(columnIndex, scale); 350     } 351 352     /** 353      * Retrieves the value of the designated column in the current row 354      * of this <code>ResultSet</code> object as 355      * a <code>byte</code> array in the Java programming language. 356      * The bytes represent the raw values returned by the driver. 357      * 358      * @param columnIndex the first column is 1, the second is 2, ... 359      * @return the column value; if the value is SQL <code>NULL</code>, the 360      * value returned is <code>null</code> 361      * @exception SQLException if a database access error occurs 362      */ 363     public byte[] getBytes(int columnIndex) throws SQLException { 364         return resultSet.getBytes(columnIndex); 365     } 366 367     /** 368      * Retrieves the value of the designated column in the current row 369      * of this <code>ResultSet</code> object as 370      * a <code>java.sql.Date</code> object in the Java programming language. 371      * 372      * @param columnIndex the first column is 1, the second is 2, ... 373      * @return the column value; if the value is SQL <code>NULL</code>, the 374      * value returned is <code>null</code> 375      * @exception SQLException if a database access error occurs 376      */ 377     public java.sql.Date getDate(int columnIndex) throws SQLException { 378         return resultSet.getDate(columnIndex); 379     } 380 381     /** 382      * Retrieves the value of the designated column in the current row 383      * of this <code>ResultSet</code> object as 384      * a <code>java.sql.Time</code> object in the Java programming language. 385      * 386      * @param columnIndex the first column is 1, the second is 2, ... 387      * @return the column value; if the value is SQL <code>NULL</code>, the 388      * value returned is <code>null</code> 389      * @exception SQLException if a database access error occurs 390      */ 391     public java.sql.Time getTime(int columnIndex) throws SQLException { 392         return resultSet.getTime(columnIndex); 393     } 394 395     /** 396      * Retrieves the value of the designated column in the current row 397      * of this <code>ResultSet</code> object as 398      * a <code>java.sql.Timestamp</code> object in the Java programming language. 399      * 400      * @param columnIndex the first column is 1, the second is 2, ... 401      * @return the column value; if the value is SQL <code>NULL</code>, the 402      * value returned is <code>null</code> 403      * @exception SQLException if a database access error occurs 404      */ 405     public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException { 406         return resultSet.getTimestamp(columnIndex); 407     } 408 409     /** 410      * Retrieves the value of the designated column in the current row 411      * of this <code>ResultSet</code> object as 412      * a stream of ASCII characters. The value can then be read in chunks from the 413      * stream. This method is particularly 414      * suitable for retrieving large <char>LONGVARCHAR</char> values. 415      * The JDBC driver will 416      * do any necessary conversion from the database format into ASCII. 417      * 418      * <P><B>Note:</B> All the data in the returned stream must be 419      * read prior to getting the value of any other column. The next 420      * call to a getter method implicitly closes the stream. Also, a 421      * stream may return <code>0</code> when the method 422      * <code>InputStream.available</code> 423      * is called whether there is data available or not. 424      * 425      * @param columnIndex the first column is 1, the second is 2, ... 426      * @return a Java input stream that delivers the database column value 427      * as a stream of one-byte ASCII characters; 428      * if the value is SQL <code>NULL</code>, the 429      * value returned is <code>null</code> 430      * @exception SQLException if a database access error occurs 431      */ 432     public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException { 433         return resultSet.getAsciiStream(columnIndex); 434     } 435 436     /** 437      * Retrieves the value of the designated column in the current row 438      * of this <code>ResultSet</code> object as 439      * as a stream of two-byte Unicode characters. The first byte is 440      * the high byte; the second byte is the low byte. 441      * 442      * The value can then be read in chunks from the 443      * stream. This method is particularly 444      * suitable for retrieving large <code>LONGVARCHAR</code>values. The 445      * JDBC driver will do any necessary conversion from the database 446      * format into Unicode. 447      * 448      * <P><B>Note:</B> All the data in the returned stream must be 449      * read prior to getting the value of any other column. The next 450      * call to a getter method implicitly closes the stream. 451      * Also, a stream may return <code>0</code> when the method 452      * <code>InputStream.available</code> 453      * is called, whether there is data available or not. 454      * 455      * @param columnIndex the first column is 1, the second is 2, ... 456      * @return a Java input stream that delivers the database column value 457      * as a stream of two-byte Unicode characters; 458      * if the value is SQL <code>NULL</code>, the value returned is 459      * <code>null</code> 460      * 461      * @exception SQLException if a database access error occurs 462      * @deprecated use <code>getCharacterStream</code> in place of 463      * <code>getUnicodeStream</code> 464      */ 465     public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException { 466         return resultSet.getUnicodeStream(columnIndex); 467     } 468 469     /** 470      * Retrieves the value of the designated column in the current row 471      * of this <code>ResultSet</code> object as a binary stream of 472      * uninterpreted bytes. The value can then be read in chunks from the 473      * stream. This method is particularly 474      * suitable for retrieving large <code>LONGVARBINARY</code> values. 475      * 476      * <P><B>Note:</B> All the data in the returned stream must be 477      * read prior to getting the value of any other column. The next 478      * call to a getter method implicitly closes the stream. Also, a 479      * stream may return <code>0</code> when the method 480      * <code>InputStream.available</code> 481      * is called whether there is data available or not. 482      * 483      * @param columnIndex the first column is 1, the second is 2, ... 484      * @return a Java input stream that delivers the database column value 485      * as a stream of uninterpreted bytes; 486      * if the value is SQL <code>NULL</code>, the value returned is 487      * <code>null</code> 488      * @exception SQLException if a database access error occurs 489      */ 490     public java.io.InputStream getBinaryStream(int columnIndex) 491         throws SQLException { 492 493         return resultSet.getBinaryStream(columnIndex); 494     } 495 496 497     //====================================================================== 498 // Methods for accessing results by column name 499 //====================================================================== 500 501     /** 502      * Retrieves the value of the designated column in the current row 503      * of this <code>ResultSet</code> object as 504      * a <code>String</code> in the Java programming language. 505      * 506      * @param columnName the SQL name of the column 507      * @return the column value; if the value is SQL <code>NULL</code>, the 508      * value returned is <code>null</code> 509      * @exception SQLException if a database access error occurs 510      */ 511     public String getString(String columnName) throws SQLException { 512         return resultSet.getString(columnName); 513     } 514 515     /** 516      * Retrieves the value of the designated column in the current row 517      * of this <code>ResultSet</code> object as 518      * a <code>boolean</code> in the Java programming language. 519      * 520      * @param columnName the SQL name of the column 521      * @return the column value; if the value is SQL <code>NULL</code>, the 522      * value returned is <code>false</code> 523      * @exception SQLException if a database access error occurs 524      */ 525     public boolean getBoolean(String columnName) throws SQLException { 526         return resultSet.getBoolean(columnName); 527     } 528 529     /** 530      * Retrieves the value of the designated column in the current row 531      * of this <code>ResultSet</code> object as 532      * a <code>byte</code> in the Java programming language. 533      * 534      * @param columnName the SQL name of the column 535      * @return the column value; if the value is SQL <code>NULL</code>, the 536      * value returned is <code>0</code> 537      * @exception SQLException if a database access error occurs 538      */ 539     public byte getByte(String columnName) throws SQLException { 540         return resultSet.getByte(columnName); 541     } 542 543     /** 544      * Retrieves the value of the designated column in the current row 545      * of this <code>ResultSet</code> object as 546      * a <code>short</code> in the Java programming language. 547      * 548      * @param columnName the SQL name of the column 549      * @return the column value; if the value is SQL <code>NULL</code>, the 550      * value returned is <code>0</code> 551      * @exception SQLException if a database access error occurs 552      */ 553     public short getShort(String columnName) throws SQLException { 554         return resultSet.getShort(columnName); 555     } 556 557     /** 558      * Retrieves the value of the designated column in the current row 559      * of this <code>ResultSet</code> object as 560      * an <code>int</code> in the Java programming language. 561      * 562      * @param columnName the SQL name of the column 563      * @return the column value; if the value is SQL <code>NULL</code>, the 564      * value returned is <code>0</code> 565      * @exception SQLException if a database access error occurs 566      */ 567     public int getInt(String columnName) throws SQLException { 568         return resultSet.getInt(columnName); 569     } 570 571     /** 572      * Retrieves the value of the designated column in the current row 573      * of this <code>ResultSet</code> object as 574      * a <code>long</code> in the Java programming language. 575      * 576      * @param columnName the SQL name of the column 577      * @return the column value; if the value is SQL <code>NULL</code>, the 578      * value returned is <code>0</code> 579      * @exception SQLException if a database access error occurs 580      */ 581     public long getLong(String columnName) throws SQLException { 582         return resultSet.getLong(columnName); 583     } 584 585     /** 586      * Retrieves the value of the designated column in the current row 587      * of this <code>ResultSet</code> object as 588      * a <code>float</code> in the Java programming language. 589      * 590      * @param columnName the SQL name of the column 591      * @return the column value; if the value is SQL <code>NULL</code>, the 592      * value returned is <code>0</code> 593      * @exception SQLException if a database access error occurs 594      */ 595     public float getFloat(String columnName) throws SQLException { 596         return resultSet.getFloat(columnName); 597     } 598 599     /** 600      * Retrieves the value of the designated column in the current row 601      * of this <code>ResultSet</code> object as 602      * a <code>double</code> in the Java programming language. 603      * 604      * @param columnName the SQL name of the column 605      * @return the column value; if the value is SQL <code>NULL</code>, the 606      * value returned is <code>0</code> 607      * @exception SQLException if a database access error occurs 608      */ 609     public double getDouble(String columnName) throws SQLException { 610         return resultSet.getDouble(columnName); 611     } 612 613     /** 614      * Retrieves the value of the designated column in the current row 615      * of this <code>ResultSet</code> object as 616      * a <code>java.math.BigDecimal</code> in the Java programming language. 617      * 618      * @param columnName the SQL name of the column 619      * @param scale the number of digits to the right of the decimal point 620      * @return the column value; if the value is SQL <code>NULL</code>, the 621      * value returned is <code>null</code> 622      * @exception SQLException if a database access error occurs 623      * @deprecated 624      */ 625     public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException { 626         return resultSet.getBigDecimal(columnName, scale); 627     } 628 629     /** 630      * Retrieves the value of the designated column in the current row 631      * of this <code>ResultSet</code> object as 632      * a <code>byte</code> array in the Java programming language. 633      * The bytes represent the raw values returned by the driver. 634      * 635      * @param columnName the SQL name of the column 636      * @return the column value; if the value is SQL <code>NULL</code>, the 637      * value returned is <code>null</code> 638      * @exception SQLException if a database access error occurs 639      */ 640     public byte[] getBytes(String columnName) throws SQLException { 641         return resultSet.getBytes(columnName); 642     } 643 644     /** 645      * Retrieves the value of the designated column in the current row 646      * of this <code>ResultSet</code> object as 647      * a <code>java.sql.Date</code> object in the Java programming language. 648      * 649      * @param columnName the SQL name of the column 650      * @return the column value; if the value is SQL <code>NULL</code>, the 651      * value returned is <code>null</code> 652      * @exception SQLException if a database access error occurs 653      */ 654     public java.sql.Date getDate(String columnName) throws SQLException { 655         return resultSet.getDate(columnName); 656     } 657 658     /** 659      * Retrieves the value of the designated column in the current row 660      * of this <code>ResultSet</code> object as 661      * a <code>java.sql.Time</code> object in the Java programming language. 662      * 663      * @param columnName the SQL name of the column 664      * @return the column value; 665      * if the value is SQL <code>NULL</code>, 666      * the value returned is <code>null</code> 667      * @exception SQLException if a database access error occurs 668      */ 669     public java.sql.Time getTime(String columnName) throws SQLException { 670         return resultSet.getTime(columnName); 671     } 672 673     /** 674      * Retrieves the value of the designated column in the current row 675      * of this <code>ResultSet</code> object as 676      * a <code>java.sql.Timestamp</code> object. 677      * 678      * @param columnName the SQL name of the column 679      * @return the column value; if the value is SQL <code>NULL</code>, the 680      * value returned is <code>null</code> 681      * @exception SQLException if a database access error occurs 682      */ 683     public java.sql.Timestamp getTimestamp(String columnName) throws SQLException { 684         return resultSet.getTimestamp(columnName); 685     } 686 687     /** 688      * Retrieves the value of the designated column in the current row 689      * of this <code>ResultSet</code> object as a stream of 690      * ASCII characters. The value can then be read in chunks from the 691      * stream. This method is particularly 692      * suitable for retrieving large <code>LONGVARCHAR</code> values. 693      * The JDBC driver will 694      * do any necessary conversion from the database format into ASCII. 695      * 696      * <P><B>Note:</B> All the data in the returned stream must be 697      * read prior to getting the value of any other column. The next 698      * call to a getter method implicitly closes the stream. Also, a 699      * stream may return <code>0</code> when the method <code>available</code> 700      * is called whether there is data available or not. 701      * 702      * @param columnName the SQL name of the column 703      * @return a Java input stream that delivers the database column value 704      * as a stream of one-byte ASCII characters. 705      * If the value is SQL <code>NULL</code>, 706      * the value returned is <code>null</code>. 707      * @exception SQLException if a database access error occurs 708      */ 709     public java.io.InputStream getAsciiStream(String columnName) throws SQLException { 710         return resultSet.getAsciiStream(columnName); 711     } 712 713     /** 714      * Retrieves the value of the designated column in the current row 715      * of this <code>ResultSet</code> object as a stream of two-byte 716      * Unicode characters. The first byte is the high byte; the second 717      * byte is the low byte. 718      * 719      * The value can then be read in chunks from the 720      * stream. This method is particularly 721      * suitable for retrieving large <code>LONGVARCHAR</code> values. 722      * The JDBC technology-enabled driver will 723      * do any necessary conversion from the database format into Unicode. 724      * 725      * <P><B>Note:</B> All the data in the returned stream must be 726      * read prior to getting the value of any other column. The next 727      * call to a getter method implicitly closes the stream. 728      * Also, a stream may return <code>0</code> when the method 729      * <code>InputStream.available</code> is called, whether there 730      * is data available or not. 731      * 732      * @param columnName the SQL name of the column 733      * @return a Java input stream that delivers the database column value 734      * as a stream of two-byte Unicode characters. 735      * If the value is SQL <code>NULL</code>, the value returned 736      * is <code>null</code>. 737      * @exception SQLException if a database access error occurs 738      * @deprecated use <code>getCharacterStream</code> instead 739      */ 740     public java.io.InputStream getUnicodeStream(String columnName) throws SQLException { 741         return resultSet.getUnicodeStream(columnName); 742     } 743 744     /** 745      * Retrieves the value of the designated column in the current row 746      * of this <code>ResultSet</code> object as a stream of uninterpreted 747      * <code>byte</code>s. 748      * The value can then be read in chunks from the 749      * stream. This method is particularly 750      * suitable for retrieving large <code>LONGVARBINARY</code> 751      * values. 752      * 753      * <P><B>Note:</B> All the data in the returned stream must be 754      * read prior to getting the value of any other column. The next 755      * call to a getter method implicitly closes the stream. Also, a 756      * stream may return <code>0</code> when the method <code>available</code> 757      * is called whether there is data available or not. 758      * 759      * @param columnName the SQL name of the column 760      * @return a Java input stream that delivers the database column value 761      * as a stream of uninterpreted bytes; 762      * if the value is SQL <code>NULL</code>, the result is <code>null</code> 763      * @exception SQLException if a database access error occurs 764      */ 765     public java.io.InputStream getBinaryStream(String columnName) 766         throws SQLException { 767 768         return resultSet.getBinaryStream(columnName); 769     } 770 771 772     //===================================================================== 773 // Advanced features: 774 //===================================================================== 775 776     /** 777      * Retrieves the first warning reported by calls on this 778      * <code>ResultSet</code> object. 779      * Subsequent warnings on this <code>ResultSet</code> object 780      * will be chained to the <code>SQLWarning</code> object that 781      * this method returns. 782      * 783      * <P>The warning chain is automatically cleared each time a new 784      * row is read. This method may not be called on a <code>ResultSet</code> 785      * object that has been closed; doing so will cause an 786      * <code>SQLException</code> to be thrown. 787      * <P> 788      * <B>Note:</B> This warning chain only covers warnings caused 789      * by <code>ResultSet</code> methods. Any warning caused by 790      * <code>Statement</code> methods 791      * (such as reading OUT parameters) will be chained on the 792      * <code>Statement</code> object. 793      * 794      * @return the first <code>SQLWarning</code> object reported or 795      * <code>null</code> if there are none 796      * @exception SQLException if a database access error occurs or this method is 797      * called on a closed result set 798      */ 799     public SQLWarning getWarnings() throws SQLException { 800         return resultSet.getWarnings(); 801     } 802 803     /** 804      * Clears all warnings reported on this <code>ResultSet</code> object. 805      * After this method is called, the method <code>getWarnings</code> 806      * returns <code>null</code> until a new warning is 807      * reported for this <code>ResultSet</code> object. 808      * 809      * @exception SQLException if a database access error occurs 810      */ 811     public void clearWarnings() throws SQLException { 812         resultSet.clearWarnings(); 813     } 814 815     /** 816      * Retrieves the name of the SQL cursor used by this <code>ResultSet</code> 817      * object. 818      * 819      * <P>In SQL, a result table is retrieved through a cursor that is 820      * named. The current row of a result set can be updated or deleted 821      * using a positioned update/delete statement that references the 822      * cursor name. To insure that the cursor has the proper isolation 823      * level to support update, the cursor's <code>SELECT</code> statement 824      * should be of the form <code>SELECT FOR UPDATE</code>. If 825      * <code>FOR UPDATE</code> is omitted, the positioned updates may fail. 826      * 827      * <P>The JDBC API supports this SQL feature by providing the name of the 828      * SQL cursor used by a <code>ResultSet</code> object. 829      * The current row of a <code>ResultSet</code> object 830      * is also the current row of this SQL cursor. 831      * 832      * <P><B>Note:</B> If positioned update is not supported, a 833      * <code>SQLException</code> is thrown. 834      * 835      * @return the SQL name for this <code>ResultSet</code> object's cursor 836      * @exception SQLException if a database access error occurs 837      */ 838     public String getCursorName() throws SQLException { 839         return resultSet.getCursorName(); 840     } 841 842     /** 843      * Retrieves the number, types and properties of 844      * this <code>ResultSet</code> object's columns. 845      * 846      * @return the description of this <code>ResultSet</code> object's columns 847      * @exception SQLException if a database access error occurs 848      */ 849     public ResultSetMetaData getMetaData() throws SQLException { 850         return resultSet.getMetaData(); 851     } 852 853     /** 854      * <p>Gets the value of the designated column in the current row 855      * of this <code>ResultSet</code> object as 856      * an <code>Object</code> in the Java programming language. 857      * 858      * <p>This method will return the value of the given column as a 859      * Java object. The type of the Java object will be the default 860      * Java object type corresponding to the column's SQL type, 861      * following the mapping for built-in types specified in the JDBC 862      * specification. If the value is an SQL <code>NULL</code>, 863      * the driver returns a Java <code>null</code>. 864      * 865      * <p>This method may also be used to read database-specific 866      * abstract data types. 867      * 868      * In the JDBC 2.0 API, the behavior of method 869      * <code>getObject</code> is extended to materialize 870      * data of SQL user-defined types. When a column contains 871      * a structured or distinct value, the behavior of this method is as 872      * if it were a call to: <code>getObject(columnIndex, 873      * this.getStatement().getConnection().getTypeMap())</code>. 874      * 875      * @param columnIndex the first column is 1, the second is 2, ... 876      * @return a <code>java.lang.Object</code> holding the column value 877      * @exception SQLException if a database access error occurs 878      */ 879     public Object getObject(int columnIndex) throws SQLException { 880         return resultSet.getObject(columnIndex); 881     } 882 883     /** 884      * <p>Gets the value of the designated column in the current row 885      * of this <code>ResultSet</code> object as 886      * an <code>Object</code> in the Java programming language. 887      * 888      * <p>This method will return the value of the given column as a 889      * Java object. The type of the Java object will be the default 890      * Java object type corresponding to the column's SQL type, 891      * following the mapping for built-in types specified in the JDBC 892      * specification. If the value is an SQL <code>NULL</code>, 893      * the driver returns a Java <code>null</code>. 894      * <P> 895      * This method may also be used to read database-specific 896      * abstract data types. 897      * <P> 898      * In the JDBC 2.0 API, the behavior of the method 899      * <code>getObject</code> is extended to materialize 900      * data of SQL user-defined types. When a column contains 901      * a structured or distinct value, the behavior of this method is as 902      * if it were a call to: <code>getObject(columnIndex, 903      * this.getStatement().getConnection().getTypeMap())</code>. 904      * 905      * @param columnName the SQL name of the column 906      * @return a <code>java.lang.Object</code> holding the column value 907      * @exception SQLException if a database access error occurs 908      */ 909     public Object getObject(String columnName) throws SQLException { 910         return resultSet.getObject(columnName); 911     } 912 913     //---------------------------------------------------------------- 914 915     /** 916      * Maps the given <code>ResultSet</code> column name to its 917      * <code>ResultSet</code> column index. 918      * 919      * @param columnName the name of the column 920      * @return the column index of the given column name 921      * @exception SQLException if the <code>ResultSet</code> object 922      * does not contain <code>columnName</code> or a database access error occurs 923      */ 924     public int findColumn(String columnName) throws SQLException { 925         return resultSet.findColumn(columnName); 926     } 927 928 929     //--------------------------JDBC 2.0----------------------------------- 930 931     //--------------------------------------------------------------------- 932 // Getters and Setters 933 //--------------------------------------------------------------------- 934 935     /** 936      * Retrieves the value of the designated column in the current row 937      * of this <code>ResultSet</code> object as a 938      * <code>java.io.Reader</code> object. 939      * @return a <code>java.io.Reader</code> object that contains the column 940      * value; if the value is SQL <code>NULL</code>, the value returned is 941      * <code>null</code> in the Java programming language. 942      * @param columnIndex the first column is 1, the second is 2, ... 943      * @exception SQLException if a database access error occurs 944      * @since 1.2 945      */ 946     public java.io.Reader getCharacterStream(int columnIndex) throws SQLException { 947         return resultSet.getCharacterStream(columnIndex); 948     } 949 950     /** 951      * Retrieves the value of the designated column in the current row 952      * of this <code>ResultSet</code> object as a 953      * <code>java.io.Reader</code> object. 954      * 955      * @param columnName the name of the column 956      * @return a <code>java.io.Reader</code> object that contains the column 957      * value; if the value is SQL <code>NULL</code>, the value returned is 958      * <code>null</code> in the Java programming language 959      * @exception SQLException if a database access error occurs 960      * @since 1.2 961      */ 962     public java.io.Reader getCharacterStream(String columnName) throws SQLException { 963         return resultSet.getCharacterStream(columnName); 964     } 965 966     /** 967      * Retrieves the value of the designated column in the current row 968      * of this <code>ResultSet</code> object as a 969      * <code>java.math.BigDecimal</code> with full precision. 970      * 971      * @param columnIndex the first column is 1, the second is 2, ... 972      * @return the column value (full precision); 973      * if the value is SQL <code>NULL</code>, the value returned is 974      * <code>null</code> in the Java programming language. 975      * @exception SQLException if a database access error occurs 976      * @since 1.2 977      */ 978     public BigDecimal getBigDecimal(int columnIndex) throws SQLException { 979         return resultSet.getBigDecimal(columnIndex); 980     } 981 982     /** 983      * Retrieves the value of the designated column in the current row 984      * of this <code>ResultSet</code> object as a 985      * <code>java.math.BigDecimal</code> with full precision. 986      * 987      * @param columnName the column name 988      * @return the column value (full precision); 989      * if the value is SQL <code>NULL</code>, the value returned is 990      * <code>null</code> in the Java programming language. 991      * @exception SQLException if a database access error occurs 992      * @since 1.2 993      * 994      */ 995     public BigDecimal getBigDecimal(String columnName) throws SQLException { 996         return resultSet.getBigDecimal(columnName); 997     } 998 999     //--------------------------------------------------------------------- 1000 // Traversal/Positioning 1001 //--------------------------------------------------------------------- 1002 1003    /** 1004     * Retrieves whether the cursor is before the first row in 1005     * this <code>ResultSet</code> object. 1006     * 1007     * @return <code>true</code> if the cursor is before the first row; 1008     * <code>false</code> if the cursor is at any other position or the 1009     * result set contains no rows 1010     * @exception SQLException if a database access error occurs 1011     * @since 1.2 1012     */ 1013    public boolean isBeforeFirst() throws SQLException { 1014        return resultSet.isBeforeFirst(); 1015    } 1016       1017    /** 1018     * Retrieves whether the cursor is after the last row in 1019     * this <code>ResultSet</code> object. 1020     * 1021     * @return <code>true</code> if the cursor is after the last row; 1022     * <code>false</code> if the cursor is at any other position or the 1023     * result set contains no rows 1024     * @exception SQLException if a database access error occurs 1025     * @since 1.2 1026     */ 1027    public boolean isAfterLast() throws SQLException { 1028        return resultSet.isAfterLast(); 1029    } 1030  1031    /** 1032     * Retrieves whether the cursor is on the first row of 1033     * this <code>ResultSet</code> object. 1034     * 1035     * @return <code>true</code> if the cursor is on the first row; 1036     * <code>false</code> otherwise 1037     * @exception SQLException if a database access error occurs 1038     * @since 1.2 1039     */ 1040    public boolean isFirst() throws SQLException { 1041        return resultSet.isFirst(); 1042    } 1043  1044    /** 1045     * Retrieves whether the cursor is on the last row of 1046     * this <code>ResultSet</code> object. 1047     * Note: Calling the method <code>isLast</code> may be expensive 1048     * because the JDBC driver 1049     * might need to fetch ahead one row in order to determine 1050     * whether the current row is the last row in the result set. 1051     * 1052     * @return <code>true</code> if the cursor is on the last row; 1053     * <code>false</code> otherwise 1054     * @exception SQLException if a database access error occurs 1055     * @since 1.2 1056     */ 1057    public boolean isLast() throws SQLException { 1058        return resultSet.isLast(); 1059    } 1060 1061    /** 1062     * Moves the cursor to the front of 1063     * this <code>ResultSet</code> object, just before the 1064     * first row. This method has no effect if the result set contains no rows. 1065     * 1066     * @exception SQLException if a database access error 1067     * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code> 1068     * @since 1.2 1069     */ 1070    public void beforeFirst() throws SQLException { 1071        resultSet.beforeFirst(); 1072    } 1073 1074    /** 1075     * Moves the cursor to the end of 1076     * this <code>ResultSet</code> object, just after the 1077     * last row. This method has no effect if the result set contains no rows. 1078     * @exception SQLException if a database access error 1079     * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code> 1080     * @since 1.2 1081     */ 1082    public void afterLast() throws SQLException { 1083        resultSet.afterLast(); 1084    } 1085 1086    /** 1087     * Moves the cursor to the first row in 1088     * this <code>ResultSet</code> object. 1089     * 1090     * @return <code>true</code> if the cursor is on a valid row; 1091     * <code>false</code> if there are no rows in the result set 1092     * @exception SQLException if a database access error 1093     * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code> 1094     * @since 1.2 1095     */ 1096    public boolean first() throws SQLException { 1097        return resultSet.first(); 1098    } 1099 1100    /** 1101     * Moves the cursor to the last row in 1102     * this <code>ResultSet</code> object. 1103     * 1104     * @return <code>true</code> if the cursor is on a valid row; 1105     * <code>false</code> if there are no rows in the result set 1106     * @exception SQLException if a database access error 1107     * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code> 1108     * @since 1.2 1109     */ 1110    public boolean last() throws SQLException { 1111        return resultSet.last(); 1112    } 1113 1114    /** 1115     * Retrieves the current row number. The first row is number 1, the 1116     * second number 2, and so on. 1117     * 1118     * @return the current row number; <code>0</code> if there is no current row 1119     * @exception SQLException if a database access error occurs 1120     * @since 1.2 1121     */ 1122    public int getRow() throws SQLException { 1123        return resultSet.getRow(); 1124    } 1125 1126    /** 1127     * Moves the cursor to the given row number in 1128     * this <code>ResultSet</code> object. 1129     * 1130     * <p>If the row number is positive, the cursor moves to 1131     * the given row number with respect to the 1132     * beginning of the result set. The first row is row 1, the second 1133     * is row 2, and so on. 1134     * 1135     * <p>If the given row number is negative, the cursor moves to 1136     * an absolute row position with respect to 1137     * the end of the result set. For example, calling the method 1138     * <code>absolute(-1)</code> positions the 1139     * cursor on the last row; calling the method <code>absolute(-2)</code> 1140     * moves the cursor to the next-to-last row, and so on. 1141     * 1142     * <p>An attempt to position the cursor beyond the first/last row in 1143     * the result set leaves the cursor before the first row or after 1144     * the last row. 1145     * 1146     * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same 1147     * as calling <code>first()</code>. Calling <code>absolute(-1)</code> 1148     * is the same as calling <code>last()</code>. 1149     * 1150     * @param row the number of the row to which the cursor should move. 1151     * A positive number indicates the row number counting from the 1152     * beginning of the result set; a negative number indicates the 1153     * row number counting from the end of the result set 1154     * @return <code>true</code> if the cursor is on the result set; 1155     * <code>false</code> otherwise 1156     * @exception SQLException if a database access error 1157     * occurs, or the result set type is <code>TYPE_FORWARD_ONLY</code> 1158     * @since 1.2 1159     */ 1160    public boolean absolute( int row ) throws SQLException { 1161        return resultSet.absolute(row); 1162    } 1163 1164    /** 1165     * Moves the cursor a relative number of rows, either positive or negative. 1166     * Attempting to move beyond the first/last row in the 1167     * result set positions the cursor before/after the 1168     * the first/last row. Calling <code>relative(0)</code> is valid, but does 1169     * not change the cursor position. 1170     * 1171     * <p>Note: Calling the method <code>relative(1)</code> 1172     * is identical to calling the method <code>next()</code> and 1173     * calling the method <code>relative(-1)</code> is identical 1174     * to calling the method <code>previous()</code>. 1175     * 1176     * @param rows an <code>int</code> specifying the number of rows to 1177     * move from the current row; a positive number moves the cursor 1178     * forward; a negative number moves the cursor backward 1179     * @return <code>true</code> if the cursor is on a row; 1180     * <code>false</code> otherwise 1181     * @exception SQLException if a database access error occurs, 1182     * there is no current row, or the result set type is 1183     * <code>TYPE_FORWARD_ONLY</code> 1184     * @since 1.2 1185     */ 1186    public boolean relative( int rows ) throws SQLException { 1187        return resultSet.relative(rows); 1188    } 1189 1190    /** 1191     * Moves the cursor to the previous row in this 1192     * <code>ResultSet</code> object. 1193     * 1194     * @return <code>true</code> if the cursor is on a valid row; 1195     * <code>false</code> if it is off the result set 1196     * @exception SQLException if a database access error 1197     * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code> 1198     * @since 1.2 1199     */ 1200    public boolean previous() throws SQLException { 1201        if (updated) { 1202            resultSet.updateRow(); 1203            updated = false; 1204        } 1205        return resultSet.previous(); 1206    } 1207 1208    /** 1209     * Gives a hint as to the direction in which the rows in this 1210     * <code>ResultSet</code> object will be processed. 1211     * The initial value is determined by the 1212     * <code>Statement</code> object 1213     * that produced this <code>ResultSet</code> object. 1214     * The fetch direction may be changed at any time. 1215     * 1216     * @param direction an <code>int</code> specifying the suggested 1217     * fetch direction; one of <code>ResultSet.FETCH_FORWARD</code>, 1218     * <code>ResultSet.FETCH_REVERSE</code>, or 1219     * <code>ResultSet.FETCH_UNKNOWN</code> 1220     * @exception SQLException if a database access error occurs or 1221     * the result set type is <code>TYPE_FORWARD_ONLY</code> and the fetch 1222     * direction is not <code>FETCH_FORWARD</code> 1223     * @since 1.2 1224     * @see Statement#setFetchDirection 1225     * @see #getFetchDirection 1226     */ 1227    public void setFetchDirection(int direction) throws SQLException { 1228        resultSet.setFetchDirection(direction); 1229    } 1230 1231    /** 1232     * Retrieves the fetch direction for this 1233     * <code>ResultSet</code> object. 1234     * 1235     * @return the current fetch direction for this <code>ResultSet</code> object 1236     * @exception SQLException if a database access error occurs 1237     * @since 1.2 1238     * @see #setFetchDirection 1239     */ 1240    public int getFetchDirection() throws SQLException { 1241        return resultSet.getFetchDirection(); 1242    } 1243 1244    /** 1245     * Gives the JDBC driver a hint as to the number of rows that should 1246     * be fetched from the database when more rows are needed for this 1247     * <code>ResultSet</code> object. 1248     * If the fetch size specified is zero, the JDBC driver 1249     * ignores the value and is free to make its own best guess as to what 1250     * the fetch size should be. The default value is set by the 1251     * <code>Statement</code> object 1252     * that created the result set. The fetch size may be changed at any time. 1253     * 1254     * @param rows the number of rows to fetch 1255     * @exception SQLException if a database access error occurs or the 1256     * condition <code>0 <= rows <= Statement.getMaxRows()</code> is not satisfied 1257     * @since 1.2 1258     * @see #getFetchSize 1259     */ 1260    public void setFetchSize(int rows) throws SQLException { 1261        resultSet.setFetchSize(rows); 1262    } 1263 1264    /** 1265     * Retrieves the fetch size for this 1266     * <code>ResultSet</code> object. 1267     * 1268     * @return the current fetch size for this <code>ResultSet</code> object 1269     * @exception SQLException if a database access error occurs 1270     * @since 1.2 1271     * @see #setFetchSize 1272     */ 1273    public int getFetchSize() throws SQLException { 1274        return resultSet.getFetchSize(); 1275    } 1276 1277    /** 1278     * Retrieves the type of this <code>ResultSet</code> object. 1279     * The type is determined by the <code>Statement</code> object 1280     * that created the result set. 1281     * 1282     * @return <code>ResultSet.TYPE_FORWARD_ONLY</code>, 1283     * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, 1284     * or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> 1285     * @exception SQLException if a database access error occurs 1286     * @since 1.2 1287     */ 1288    public int getType() throws SQLException { 1289        return resultSet.getType(); 1290    } 1291 1292    /** 1293     * Retrieves the concurrency mode of this <code>ResultSet</code> object. 1294     * The concurrency used is determined by the 1295     * <code>Statement</code> object that created the result set. 1296     * 1297     * @return the concurrency type, either 1298     * <code>ResultSet.CONCUR_READ_ONLY</code> 1299     * or <code>ResultSet.CONCUR_UPDATABLE</code> 1300     * @exception SQLException if a database access error occurs 1301     * @since 1.2 1302     */ 1303    public int getConcurrency() throws SQLException { 1304        return resultSet.getConcurrency(); 1305    } 1306 1307    //--------------------------------------------------------------------- 1308 // Updates 1309 //--------------------------------------------------------------------- 1310 1311    /** 1312     * Retrieves whether the current row has been updated. The value returned 1313     * depends on whether or not the result set can detect updates. 1314     * 1315     * @return <code>true</code> if both (1) the row has been visibly updated 1316     * by the owner or another and (2) updates are detected 1317     * @exception SQLException if a database access error occurs 1318     * @see DatabaseMetaData#updatesAreDetected 1319     * @since 1.2 1320     */ 1321    public boolean rowUpdated() throws SQLException { 1322        return resultSet.rowUpdated(); 1323    } 1324 1325    /** 1326     * Retrieves whether the current row has had an insertion. 1327     * The value returned depends on whether or not this 1328     * <code>ResultSet</code> object can detect visible inserts. 1329     * 1330     * @return <code>true</code> if a row has had an insertion 1331     * and insertions are detected; <code>false</code> otherwise 1332     * @exception SQLException if a database access error occurs 1333     * 1334     * @see DatabaseMetaData#insertsAreDetected 1335     * @since 1.2 1336     */ 1337    public boolean rowInserted() throws SQLException { 1338        return resultSet.rowInserted(); 1339    } 1340    1341    /** 1342     * Retrieves whether a row has been deleted. A deleted row may leave 1343     * a visible "hole" in a result set. This method can be used to 1344     * detect holes in a result set. The value returned depends on whether 1345     * or not this <code>ResultSet</code> object can detect deletions. 1346     * 1347     * @return <code>true</code> if a row was deleted and deletions are detected; 1348     * <code>false</code> otherwise 1349     * @exception SQLException if a database access error occurs 1350     * 1351     * @see DatabaseMetaData#deletesAreDetected 1352     * @since 1.2 1353     */ 1354    public boolean rowDeleted() throws SQLException { 1355        return resultSet.rowDeleted(); 1356    } 1357 1358    /** 1359     * Gives a nullable column a null value. 1360     * 1361     * The updater methods are used to update column values in the 1362     * current row or the insert row. The updater methods do not 1363     * update the underlying database; instead the <code>updateRow</code> 1364     * or <code>insertRow</code> methods are called to update the database. 1365     * 1366     * @param columnIndex the first column is 1, the second is 2, ... 1367     * @exception SQLException if a database access error occurs 1368     * @since 1.2 1369     */ 1370    public void updateNull(int columnIndex) throws SQLException { 1371        resultSet.updateNull(columnIndex); 1372    } 1373 1374    /** 1375     * Updates the designated column with a <code>boolean</code> value. 1376     * The updater methods are used to update column values in the 1377     * current row or the insert row. The updater methods do not 1378     * update the underlying database; instead the <code>updateRow</code> or 1379     * <code>insertRow</code> methods are called to update the database. 1380     * 1381     * @param columnIndex the first column is 1, the second is 2, ... 1382     * @param x the new column value 1383     * @exception SQLException if a database access error occurs 1384     * @since 1.2 1385     */ 1386    public void updateBoolean(int columnIndex, boolean x) throws SQLException { 1387        resultSet.updateBoolean(columnIndex, x); 1388    } 1389 1390    /** 1391     * Updates the designated column with a <code>byte</code> value. 1392     * The updater methods are used to update column values in the 1393     * current row or the insert row. The updater methods do not 1394     * update the underlying database; instead the <code>updateRow</code> or 1395     * <code>insertRow</code> methods are called to update the database. 1396     * 1397     * 1398     * @param columnIndex the first column is 1, the second is 2, ... 1399     * @param x the new column value 1400     * @exception SQLException if a database access error occurs 1401     * @since 1.2 1402     */ 1403    public void updateByte(int columnIndex, byte x) throws SQLException { 1404        resultSet.updateByte(columnIndex, x); 1405    } 1406 1407    /** 1408     * Updates the designated column with a <code>short</code> value. 1409     * The updater methods are used to update column values in the 1410     * current row or the insert row. The updater methods do not 1411     * update the underlying database; instead the <code>updateRow</code> or 1412     * <code>insertRow</code> methods are called to update the database. 1413     * 1414     * @param columnIndex the first column is 1, the second is 2, ... 1415     * @param x the new column value 1416     * @exception SQLException if a database access error occurs 1417     * @since 1.2 1418     */ 1419    public void updateShort(int columnIndex, short x) throws SQLException { 1420        resultSet.updateShort(columnIndex, x); 1421    } 1422 1423    /** 1424     * Updates the designated column with an <code>int</code> value. 1425     * The updater methods are used to update column values in the 1426     * current row or the insert row. The updater methods do not 1427     * update the underlying database; instead the <code>updateRow</code> or 1428     * <code>insertRow</code> methods are called to update the database. 1429     * 1430     * @param columnIndex the first column is 1, the second is 2, ... 1431     * @param x the new column value 1432     * @exception SQLException if a database access error occurs 1433     * @since 1.2 1434     */ 1435    public void updateInt(int columnIndex, int x) throws SQLException { 1436        resultSet.updateInt(columnIndex, x); 1437    } 1438 1439    /** 1440     * Updates the designated column with a <code>long</code> value. 1441     * The updater methods are used to update column values in the 1442     * current row or the insert row. The updater methods do not 1443     * update the underlying database; instead the <code>updateRow</code> or 1444     * <code>insertRow</code> methods are called to update the database. 1445     * 1446     * @param columnIndex the first column is 1, the second is 2, ... 1447     * @param x the new column value 1448     * @exception SQLException if a database access error occurs 1449     * @since 1.2 1450     */ 1451    public void updateLong(int columnIndex, long x) throws SQLException { 1452        resultSet.updateLong(columnIndex, x); 1453    } 1454 1455    /** 1456     * Updates the designated column with a <code>float</code> value. 1457     * The updater methods are used to update column values in the 1458     * current row or the insert row. The updater methods do not 1459     * update the underlying database; instead the <code>updateRow</code> or 1460     * <code>insertRow</code> methods are called to update the database. 1461     * 1462     * @param columnIndex the first column is 1, the second is 2, ... 1463     * @param x the new column value 1464     * @exception SQLException if a database access error occurs 1465     * @since 1.2 1466     */ 1467    public void updateFloat(int columnIndex, float x) throws SQLException { 1468        resultSet.updateFloat(columnIndex, x); 1469    } 1470 1471    /** 1472     * Updates the designated column with a <code>double</code> value. 1473     * The updater methods are used to update column values in the 1474     * current row or the insert row. The updater methods do not 1475     * update the underlying database; instead the <code>updateRow</code> or 1476     * <code>insertRow</code> methods are called to update the database. 1477     * 1478     * @param columnIndex the first column is 1, the second is 2, ... 1479     * @param x the new column value 1480     * @exception SQLException if a database access error occurs 1481     * @since 1.2 1482     */ 1483    public void updateDouble(int columnIndex, double x) throws SQLException { 1484        resultSet.updateDouble(columnIndex, x); 1485    } 1486 1487    /** 1488     * Updates the designated column with a <code>java.math.BigDecimal</code> 1489     * value. 1490     * The updater methods are used to update column values in the 1491     * current row or the insert row. The updater methods do not 1492     * update the underlying database; instead the <code>updateRow</code> or 1493     * <code>insertRow</code> methods are called to update the database. 1494     * 1495     * @param columnIndex the first column is 1, the second is 2, ... 1496     * @param x the new column value 1497     * @exception SQLException if a database access error occurs 1498     * @since 1.2 1499     */ 1500    public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException { 1501        resultSet.updateBigDecimal(columnIndex, x); 1502    } 1503 1504    /** 1505     * Updates the designated column with a <code>String</code> value. 1506     * The updater methods are used to update column values in the 1507     * current row or the insert row. The updater methods do not 1508     * update the underlying database; instead the <code>updateRow</code> or 1509     * <code>insertRow</code> methods are called to update the database. 1510     * 1511     * @param columnIndex the first column is 1, the second is 2, ... 1512     * @param x the new column value 1513     * @exception SQLException if a database access error occurs 1514     * @since 1.2 1515     */ 1516    public void updateString(int columnIndex, String x) throws SQLException { 1517        resultSet.updateString(columnIndex, x); 1518    } 1519 1520    /** 1521     * Updates the designated column with a <code>byte</code> array value. 1522     * The updater methods are used to update column values in the 1523     * current row or the insert row. The updater methods do not 1524     * update the underlying database; instead the <code>updateRow</code> or 1525     * <code>insertRow</code> methods are called to update the database. 1526     * 1527     * @param columnIndex the first column is 1, the second is 2, ... 1528     * @param x the new column value 1529     * @exception SQLException if a database access error occurs 1530     * @since 1.2 1531     */ 1532    public void updateBytes(int columnIndex, byte x[]) throws SQLException { 1533        resultSet.updateBytes(columnIndex, x); 1534    } 1535 1536    /** 1537     * Updates the designated column with a <code>java.sql.Date</code> value. 1538     * The updater methods are used to update column values in the 1539     * current row or the insert row. The updater methods do not 1540     * update the underlying database; instead the <code>updateRow</code> or 1541     * <code>insertRow</code> methods are called to update the database. 1542     * 1543     * @param columnIndex the first column is 1, the second is 2, ... 1544     * @param x the new column value 1545     * @exception SQLException if a database access error occurs 1546     * @since 1.2 1547     */ 1548    public void updateDate(int columnIndex, java.sql.Date x) throws SQLException { 1549        resultSet.updateDate(columnIndex, x); 1550    } 1551 1552    /** 1553     * Updates the designated column with a <code>java.sql.Time</code> value. 1554     * The updater methods are used to update column values in the 1555     * current row or the insert row. The updater methods do not 1556     * update the underlying database; instead the <code>updateRow</code> or 1557     * <code>insertRow</code> methods are called to update the database. 1558     * 1559     * @param columnIndex the first column is 1, the second is 2, ... 1560     * @param x the new column value 1561     * @exception SQLException if a database access error occurs 1562     * @since 1.2 1563     */ 1564    public void updateTime(int columnIndex, java.sql.Time x) throws SQLException { 1565        resultSet.updateTime(columnIndex, x); 1566    } 1567 1568    /** 1569     * Updates the designated column with a <code>java.sql.Timestamp</code> 1570     * value. 1571     * The updater methods are used to update column values in the 1572     * current row or the insert row. The updater methods do not 1573     * update the underlying database; instead the <code>updateRow</code> or 1574     * <code>insertRow</code> methods are called to update the database. 1575     * 1576     * @param columnIndex the first column is 1, the second is 2, ... 1577     * @param x the new column value 1578     * @exception SQLException if a database access error occurs 1579     * @since 1.2 1580     */ 1581    public void updateTimestamp(int columnIndex, java.sql.Timestamp x) 1582        throws SQLException { 1583        resultSet.updateTimestamp(columnIndex, x); 1584    } 1585 1586    /** 1587     * Updates the designated column with an ascii stream value. 1588     * The updater methods are used to update column values in the 1589     * current row or the insert row. The updater methods do not 1590     * update the underlying database; instead the <code>updateRow</code> or 1591     * <code>insertRow</code> methods are called to update the database. 1592     * 1593     * @param columnIndex the first column is 1, the second is 2, ... 1594     * @param x the new column value 1595     * @param length the length of the stream 1596     * @exception SQLException if a database access error occurs 1597     * @since 1.2 1598     */ 1599    public void updateAsciiStream(int columnIndex, 1600                                  java.io.InputStream x, 1601                                  int length) throws SQLException { 1602        resultSet.updateAsciiStream(columnIndex, x, length); 1603    } 1604 1605    /** 1606     * Updates the designated column with a binary stream value. 1607     * The updater methods are used to update column values in the 1608     * current row or the insert row. The updater methods do not 1609     * update the underlying database; instead the <code>updateRow</code> or 1610     * <code>insertRow</code> methods are called to update the database. 1611     * 1612     * @param columnIndex the first column is 1, the second is 2, ... 1613     * @param x the new column value 1614     * @param length the length of the stream 1615     * @exception SQLException if a database access error occurs 1616     * @since 1.2 1617     */ 1618    public void updateBinaryStream(int columnIndex, 1619                java.io.InputStream x, 1620                                   int length) throws SQLException { 1621        resultSet.updateBinaryStream(columnIndex, x, length); 1622    } 1623 1624    /** 1625     * Updates the designated column with a character stream value. 1626     * The updater methods are used to update column values in the 1627     * current row or the insert row. The updater methods do not 1628     * update the underlying database; instead the <code>updateRow</code> or 1629     * <code>insertRow</code> methods are called to update the database. 1630     * 1631     * @param columnIndex the first column is 1, the second is 2, ... 1632     * @param x the new column value 1633     * @param length the length of the stream 1634     * @exception SQLException if a database access error occurs 1635     * @since 1.2 1636     */ 1637    public void updateCharacterStream(int columnIndex, 1638                               java.io.Reader x, 1639                               int length) throws SQLException { 1640        resultSet.updateCharacterStream(columnIndex, x, length); 1641    } 1642 1643    /** 1644     * Updates the designated column with an <code>Object</code> value. 1645     * The updater methods are used to update column values in the 1646     * current row or the insert row. The updater methods do not 1647     * update the underlying database; instead the <code>updateRow</code> or 1648     * <code>insertRow</code> methods are called to update the database. 1649     * 1650     * @param columnIndex the first column is 1, the second is 2, ... 1651     * @param x the new column value 1652     * @param scale for <code>java.sql.Types.DECIMA</code> 1653     * or <code>java.sql.Types.NUMERIC</code> types, 1654     * this is the number of digits after the decimal point. For all other 1655     * types this value will be ignored. 1656     * @exception SQLException if a database access error occurs 1657     * @since 1.2 1658     */ 1659    public void updateObject(int columnIndex, Object x, int scale) 1660        throws SQLException { 1661        resultSet.updateObject(columnIndex, x, scale); 1662    } 1663 1664    /** 1665     * Updates the designated column with an <code>Object</code> value. 1666     * The updater methods are used to update column values in the 1667     * current row or the insert row. The updater methods do not 1668     * update the underlying database; instead the <code>updateRow</code> or 1669     * <code>insertRow</code> methods are called to update the database. 1670     * 1671     * @param columnIndex the first column is 1, the second is 2, ... 1672     * @param x the new column value 1673     * @exception SQLException if a database access error occurs 1674     * @since 1.2 1675     */ 1676    public void updateObject(int columnIndex, Object x) throws SQLException { 1677        resultSet.updateObject(columnIndex, x); 1678    } 1679 1680    /** 1681     * Updates the designated column with a <code>null</code> value. 1682     * The updater methods are used to update column values in the 1683     * current row or the insert row. The updater methods do not 1684     * update the underlying database; instead the <code>updateRow</code> or 1685     * <code>insertRow</code> methods are called to update the database. 1686     * 1687     * @param columnName the name of the column 1688     * @exception SQLException if a database access error occurs 1689     * @since 1.2 1690     */ 1691    public void updateNull(String columnName) throws SQLException { 1692        resultSet.updateNull(columnName); 1693    } 1694 1695    /** 1696     * Updates the designated column with a <code>boolean</code> value. 1697     * The updater methods are used to update column values in the 1698     * current row or the insert row. The updater methods do not 1699     * update the underlying database; instead the <code>updateRow</code> or 1700     * <code>insertRow</code> methods are called to update the database. 1701     * 1702     * @param columnName the name of the column 1703     * @param x the new column value 1704     * @exception SQLException if a database access error occurs 1705     * @since 1.2 1706     */ 1707    public void updateBoolean(String columnName, boolean x) throws SQLException { 1708        resultSet.updateBoolean(columnName, x); 1709    } 1710 1711    /** 1712     * Updates the designated column with a <code>byte</code> value. 1713     * The updater methods are used to update column values in the 1714     * current row or the insert row. The updater methods do not 1715     * update the underlying database; instead the <code>updateRow</code> or 1716     * <code>insertRow</code> methods are called to update the database. 1717     * 1718     * @param columnName the name of the column 1719     * @param x the new column value 1720     * @exception SQLException if a database access error occurs 1721     * @since 1.2 1722     */ 1723    public void updateByte(String columnName, byte x) throws SQLException { 1724        resultSet.updateByte(columnName, x); 1725    } 1726 1727    /** 1728     * Updates the designated column with a <code>short</code> value. 1729     * The updater methods are used to update column values in the 1730     * current row or the insert row. The updater methods do not 1731     * update the underlying database; instead the <code>updateRow</code> or 1732     * <code>insertRow</code> methods are called to update the database. 1733     * 1734     * @param columnName the name of the column 1735     * @param x the new column value 1736     * @exception SQLException if a database access error occurs 1737     * @since 1.2 1738     */ 1739    public void updateShort(String columnName, short x) throws SQLException { 1740        resultSet.updateShort(columnName, x); 1741    } 1742 1743    /** 1744     * Updates the designated column with an <code>int</code> value. 1745     * The updater methods are used to update column values in the 1746     * current row or the insert row. The updater methods do not 1747     * update the underlying database; instead the <code>updateRow</code> or 1748     * <code>insertRow</code> methods are called to update the database. 1749     * 1750     * @param columnName the name of the column 1751     * @param x the new column value 1752     * @exception SQLException if a database access error occurs 1753     * @since 1.2 1754     */ 1755    public void updateInt(String columnName, int x) throws SQLException { 1756        resultSet.updateInt(columnName, x); 1757    } 1758 1759    /** 1760     * Updates the designated column with a <code>long</code> value. 1761     * The updater methods are used to update column values in the 1762     * current row or the insert row. The updater methods do not 1763     * update the underlying database; instead the <code>updateRow</code> or 1764     * <code>insertRow</code> methods are called to update the database. 1765     * 1766     * @param columnName the name of the column 1767     * @param x the new column value 1768     * @exception SQLException if a database access error occurs 1769     * @since 1.2 1770     */ 1771    public void updateLong(String columnName, long x) throws SQLException { 1772        resultSet.updateLong(columnName, x); 1773    } 1774 1775    /** 1776     * Updates the designated column with a <code>float </code> value. 1777     * The updater methods are used to update column values in the 1778     * current row or the insert row. The updater methods do not 1779     * update the underlying database; instead the <code>updateRow</code> or 1780     * <code>insertRow</code> methods are called to update the database. 1781     * 1782     * @param columnName the name of the column 1783     * @param x the new column value 1784     * @exception SQLException if a database access error occurs 1785     * @since 1.2 1786     */ 1787    public void updateFloat(String columnName, float x) throws SQLException { 1788        resultSet.updateFloat(columnName, x); 1789    } 1790 1791    /** 1792     * Updates the designated column with a <code>double</code> value. 1793     * The updater methods are used to update column values in the 1794     * current row or the insert row. The updater methods do not 1795     * update the underlying database; instead the <code>updateRow</code> or 1796     * <code>insertRow</code> methods are called to update the database. 1797     * 1798     * @param columnName the name of the column 1799     * @param x the new column value 1800     * @exception SQLException if a database access error occurs 1801     * @since 1.2 1802     */ 1803    public void updateDouble(String columnName, double x) throws SQLException { 1804        resultSet.updateDouble(columnName, x); 1805    } 1806 1807    /** 1808     * Updates the designated column with a <code>java.sql.BigDecimal</code> 1809     * value. 1810     * The updater methods are used to update column values in the 1811     * current row or the insert row. The updater methods do not 1812     * update the underlying database; instead the <code>updateRow</code> or 1813     * <code>insertRow</code> methods are called to update the database. 1814     * 1815     * @param columnName the name of the column 1816     * @param x the new column value 1817     * @exception SQLException if a database access error occurs 1818     * @since 1.2 1819     */ 1820    public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException { 1821        resultSet.updateBigDecimal(columnName, x); 1822    } 1823 1824    /** 1825     * Updates the designated column with a <code>String</code> value. 1826     * The updater methods are used to update column values in the 1827     * current row or the insert row. The updater methods do not 1828     * update the underlying database; instead the <code>updateRow</code> or 1829     * <code>insertRow</code> methods are called to update the database. 1830     * 1831     * @param columnName the name of the column 1832     * @param x the new column value 1833     * @exception SQLException if a database access error occurs 1834     * @since 1.2 1835     */ 1836    public void updateString(String columnName, String x) throws SQLException { 1837        resultSet.updateString(columnName, x); 1838    } 1839 1840    /** 1841     * Updates the designated column with a byte array value. 1842     * 1843     * The updater methods are used to update column values in the 1844     * current row or the insert row. The updater methods do not 1845     * update the underlying database; instead the <code>updateRow</code> 1846     * or <code>insertRow</code> methods are called to update the database. 1847     * 1848     * @param columnName the name of the column 1849     * @param x the new column value 1850     * @exception SQLException if a database access error occurs 1851     * @since 1.2 1852     */ 1853    public void updateBytes(String columnName, byte x[]) throws SQLException { 1854        resultSet.updateBytes(columnName, x); 1855    } 1856 1857    /** 1858     * Updates the designated column with a <code>java.sql.Date</code> value. 1859     * The updater methods are used to update column values in the 1860     * current row or the insert row. The updater methods do not 1861     * update the underlying database; instead the <code>updateRow</code> or 1862     * <code>insertRow</code> methods are called to update the database. 1863     * 1864     * @param columnName the name of the column 1865     * @param x the new column value 1866     * @exception SQLException if a database access error occurs 1867     * @since 1.2 1868     */ 1869    public void updateDate(String columnName, java.sql.Date x) throws SQLException { 1870        resultSet.updateDate(columnName, x); 1871    } 1872 1873    /** 1874     * Updates the designated column with a <code>java.sql.Time</code> value. 1875     * The updater methods are used to update column values in the 1876     * current row or the insert row. The updater methods do not 1877     * update the underlying database; instead the <code>updateRow</code> or 1878     * <code>insertRow</code> methods are called to update the database. 1879     * 1880     * @param columnName the name of the column 1881     * @param x the new column value 1882     * @exception SQLException if a database access error occurs 1883     * @since 1.2 1884     */ 1885    public void updateTime(String columnName, java.sql.Time x) throws SQLException { 1886        resultSet.updateTime(columnName, x); 1887    } 1888 1889    /** 1890     * Updates the designated column with a <code>java.sql.Timestamp</code> 1891     * value. 1892     * The updater methods are used to update column values in the 1893     * current row or the insert row. The updater methods do not 1894     * update the underlying database; instead the <code>updateRow</code> or 1895     * <code>insertRow</code> methods are called to update the database. 1896     * 1897     * @param columnName the name of the column 1898     * @param x the new column value 1899     * @exception SQLException if a database access error occurs 1900     * @since 1.2 1901     */ 1902    public void updateTimestamp(String columnName, java.sql.Timestamp x) 1903        throws SQLException { 1904        resultSet.updateTimestamp(columnName, x); 1905    } 1906 1907    /** 1908     * Updates the designated column with an ascii stream value. 1909     * The updater methods are used to update column values in the 1910     * current row or the insert row. The updater methods do not 1911     * update the underlying database; instead the <code>updateRow</code> or 1912     * <code>insertRow</code> methods are called to update the database. 1913     * 1914     * @param columnName the name of the column 1915     * @param x the new column value 1916     * @param length the length of the stream 1917     * @exception SQLException if a database access error occurs 1918     * @since 1.2 1919     */ 1920    public void updateAsciiStream(String columnName, 1921               java.io.InputStream x, 1922                                  int length) throws SQLException { 1923        resultSet.updateAsciiStream(columnName, x, length); 1924    } 1925 1926    /** 1927     * Updates the designated column with a binary stream value. 1928     * The updater methods are used to update column values in the 1929     * current row or the insert row. The updater methods do not 1930     * update the underlying database; instead the <code>updateRow</code> or 1931     * <code>insertRow</code> methods are called to update the database. 1932     * 1933     * @param columnName the name of the column 1934     * @param x the new column value 1935     * @param length the length of the stream 1936     * @exception SQLException if a database access error occurs 1937     * @since 1.2 1938     */ 1939    public void updateBinaryStream(String columnName, 1940                java.io.InputStream x, 1941                int length) throws SQLException { 1942        resultSet.updateBinaryStream(columnName, x, length); 1943    } 1944 1945    /** 1946     * Updates the designated column with a character stream value. 1947     * The updater methods are used to update column values in the 1948     * current row or the insert row. The updater methods do not 1949     * update the underlying database; instead the <code>updateRow</code> or 1950     * <code>insertRow</code> methods are called to update the database. 1951     * 1952     * @param columnName the name of the column 1953     * @param reader the <code>java.io.Reader</code> object containing 1954     * the new column value 1955     * @param length the length of the stream 1956     * @exception SQLException if a database access error occurs 1957     * @since 1.2 1958     */ 1959    public void updateCharacterStream(String columnName, 1960                                      java.io.Reader reader, 1961                                      int length) throws SQLException { 1962        resultSet.updateCharacterStream(columnName, reader, length); 1963    } 1964 1965    /** 1966     * Updates the designated column with an <code>Object</code> value. 1967     * The updater methods are used to update column values in the 1968     * current row or the insert row. The updater methods do not 1969     * update the underlying database; instead the <code>updateRow</code> or 1970     * <code>insertRow</code> methods are called to update the database. 1971     * 1972     * @param columnName the name of the column 1973     * @param x the new column value 1974     * @param scale for <code>java.sql.Types.DECIMAL</code> 1975     * or <code>java.sql.Types.NUMERIC</code> types, 1976     * this is the number of digits after the decimal point. For all other 1977     * types this value will be ignored. 1978     * @exception SQLException if a database access error occurs 1979     * @since 1.2 1980     */ 1981    public void updateObject(String columnName, Object x, int scale) 1982        throws SQLException { 1983        resultSet.updateObject(columnName, x, scale); 1984    } 1985 1986    /** 1987     * Updates the designated column with an <code>Object</code> value. 1988     * The updater methods are used to update column values in the 1989     * current row or the insert row. The updater methods do not 1990     * update the underlying database; instead the <code>updateRow</code> or 1991     * <code>insertRow</code> methods are called to update the database. 1992     * 1993     * @param columnName the name of the column 1994     * @param x the new column value 1995     * @exception SQLException if a database access error occurs 1996     * @since 1.2 1997     */ 1998    public void updateObject(String columnName, Object x) throws SQLException { 1999        resultSet.updateObject(columnName, x); 2000    } 2001 2002    /** 2003     * Inserts the contents of the insert row into this 2004     * <code>ResultSet</code> object and into the database. 2005     * The cursor must be on the insert row when this method is called. 2006     * 2007     * @exception SQLException if a database access error occurs, 2008     * if this method is called when the cursor is not on the insert row, 2009     * or if not all of non-nullable columns in 2010     * the insert row have been given a value 2011     * @since 1.2 2012     */ 2013    public void insertRow() throws SQLException { 2014        resultSet.insertRow(); 2015    } 2016 2017    /** 2018     * Updates the underlying database with the new contents of the 2019     * current row of this <code>ResultSet</code> object. 2020     * This method cannot be called when the cursor is on the insert row. 2021     * 2022     * @exception SQLException if a database access error occurs or 2023     * if this method is called when the cursor is on the insert row 2024     * @since 1.2 2025     */ 2026    public void updateRow() throws SQLException { 2027        resultSet.updateRow(); 2028    } 2029     2030    /** 2031     * Deletes the current row from this <code>ResultSet</code> object 2032     * and from the underlying database. This method cannot be called when 2033     * the cursor is on the insert row. 2034     * 2035     * @exception SQLException if a database access error occurs 2036     * or if this method is called when the cursor is on the insert row 2037     * @since 1.2 2038     */ 2039    public void deleteRow() throws SQLException { 2040        resultSet.deleteRow(); 2041    } 2042 2043    /** 2044     * Refreshes the current row with its most recent value in 2045     * the database. This method cannot be called when 2046     * the cursor is on the insert row. 2047     * 2048     * <P>The <code>refreshRow</code> method provides a way for an 2049     * application to 2050     * explicitly tell the JDBC driver to refetch a row(s) from the 2051     * database. An application may want to call <code>refreshRow</code> when 2052     * caching or prefetching is being done by the JDBC driver to 2053     * fetch the latest value of a row from the database. The JDBC driver 2054     * may actually refresh multiple rows at once if the fetch size is 2055     * greater than one. 2056     * 2057     * <P> All values are refetched subject to the transaction isolation 2058     * level and cursor sensitivity. If <code>refreshRow</code> is called after 2059     * calling an updater method, but before calling 2060     * the method <code>updateRow</code>, then the 2061     * updates made to the row are lost. Calling the method 2062     * <code>refreshRow</code> frequently will likely slow performance. 2063     * 2064     * @exception SQLException if a database access error 2065     * occurs or if this method is called when the cursor is on the insert row 2066     * @since 1.2 2067     */ 2068    public void refreshRow() throws SQLException { 2069        resultSet.refreshRow(); 2070    } 2071 2072    /** 2073     * Cancels the updates made to the current row in this 2074     * <code>ResultSet</code> object. 2075     * This method may be called after calling an 2076     * updater method(s) and before calling 2077     * the method <code>updateRow</code> to roll back 2078     * the updates made to a row. If no updates have been made or 2079     * <code>updateRow</code> has already been called, this method has no 2080     * effect. 2081     * 2082     * @exception SQLException if a database access error 2083     * occurs or if this method is called when the cursor is 2084     * on the insert row 2085     * @since 1.2 2086     */ 2087    public void cancelRowUpdates() throws SQLException { 2088        resultSet.cancelRowUpdates(); 2089    } 2090 2091    /** 2092     * Moves the cursor to the insert row. The current cursor position is 2093     * remembered while the cursor is positioned on the insert row. 2094     * 2095     * The insert row is a special row associated with an updatable 2096     * result set. It is essentially a buffer where a new row may 2097     * be constructed by calling the updater methods prior to 2098     * inserting the row into the result set. 2099     * 2100     * Only the updater, getter, 2101     * and <code>insertRow</code> methods may be 2102     * called when the cursor is on the insert row. All of the columns in 2103     * a result set must be given a value each time this method is 2104     * called before calling <code>insertRow</code>. 2105     * An updater method must be called before a 2106     * getter method can be called on a column value. 2107     * 2108     * @exception SQLException if a database access error occurs 2109     * or the result set is not updatable 2110     * @since 1.2 2111     */ 2112    public void moveToInsertRow() throws SQLException { 2113        resultSet.moveToInsertRow(); 2114    } 2115 2116    /** 2117     * Moves the cursor to the remembered cursor position, usually the 2118     * current row. This method has no effect if the cursor is not on 2119     * the insert row. 2120     * 2121     * @exception SQLException if a database access error occurs 2122     * or the result set is not updatable 2123     * @since 1.2 2124     */ 2125    public void moveToCurrentRow() throws SQLException { 2126        resultSet.moveToCurrentRow(); 2127    } 2128 2129    /** 2130     * Retrieves the <code>Statement</code> object that produced this 2131     * <code>ResultSet</code> object. 2132     * If the result set was generated some other way, such as by a 2133     * <code>DatabaseMetaData</code> method, this method returns 2134     * <code>null</code>. 2135     * 2136     * @return the <code>Statment</code> object that produced 2137     * this <code>ResultSet</code> object or <code>null</code> 2138     * if the result set was produced some other way 2139     * @exception SQLException if a database access error occurs 2140     * @since 1.2 2141     */ 2142    public Statement getStatement() throws SQLException { 2143        return resultSet.getStatement(); 2144    } 2145 2146    /** 2147     * Retrieves the value of the designated column in the current row 2148     * of this <code>ResultSet</code> object as an <code>Object</code> 2149     * in the Java programming language. 2150     * If the value is an SQL <code>NULL</code>, 2151     * the driver returns a Java <code>null</code>. 2152     * This method uses the given <code>Map</code> object 2153     * for the custom mapping of the 2154     * SQL structured or distinct type that is being retrieved. 2155     * 2156     * @param i the first column is 1, the second is 2, ... 2157     * @param map a <code>java.util.Map</code> object that contains the mapping 2158     * from SQL type names to classes in the Java programming language 2159     * @return an <code>Object</code> in the Java programming language 2160     * representing the SQL value 2161     * @exception SQLException if a database access error occurs 2162     * @since 1.2 2163     */ 2164    public Object getObject(int i, java.util.Map map) throws SQLException { 2165        return resultSet.getObject(i, map); 2166    } 2167 2168    /** 2169     * Retrieves the value of the designated column in the current row 2170     * of this <code>ResultSet</code> object as a <code>Ref</code> object 2171     * in the Java programming language. 2172     * 2173     * @param i the first column is 1, the second is 2, ... 2174     * @return a <code>Ref</code> object representing an SQL <code>REF</code> 2175     * value 2176     * @exception SQLException if a database access error occurs 2177     * @since 1.2 2178     */ 2179    public Ref getRef(int i) throws SQLException { 2180        return resultSet.getRef(i); 2181    } 2182 2183    /** 2184     * Retrieves the value of the designated column in the current row 2185     * of this <code>ResultSet</code> object as a <code>Blob</code> object 2186     * in the Java programming language. 2187     * 2188     * @param i the first column is 1, the second is 2, ... 2189     * @return a <code>Blob</code> object representing the SQL 2190     * <code>BLOB</code> value in the specified column 2191     * @exception SQLException if a database access error occurs 2192     * @since 1.2 2193     */ 2194    public Blob getBlob(int i) throws SQLException { 2195        return resultSet.getBlob(i); 2196    } 2197 2198    /** 2199     * Retrieves the value of the designated column in the current row 2200     * of this <code>ResultSet</code> object as a <code>Clob</code> object 2201     * in the Java programming language. 2202     * 2203     * @param i the first column is 1, the second is 2, ... 2204     * @return a <code>Clob</code> object representing the SQL 2205     * <code>CLOB</code> value in the specified column 2206     * @exception SQLException if a database access error occurs 2207     * @since 1.2 2208     */ 2209    public Clob getClob(int i) throws SQLException { 2210        return resultSet.getClob(i); 2211    } 2212 2213    /** 2214     * Retrieves the value of the designated column in the current row 2215     * of this <code>ResultSet</code> object as an <code>Array</code> object 2216     * in the Java programming language. 2217     * 2218     * @param i the first column is 1, the second is 2, ... 2219     * @return an <code>Array</code> object representing the SQL 2220     * <code>ARRAY</code> value in the specified column 2221     * @exception SQLException if a database access error occurs 2222     * @since 1.2 2223     */ 2224    public Array getArray(int i) throws SQLException { 2225        return resultSet.getArray(i); 2226    } 2227 2228    /** 2229     * Retrieves the value of the designated column in the current row 2230     * of this <code>ResultSet</code> object as an <code>Object</code> 2231     * in the Java programming language. 2232     * If the value is an SQL <code>NULL</code>, 2233     * the driver returns a Java <code>null</code>. 2234     * This method uses the specified <code>Map</code> object for 2235     * custom mapping if appropriate. 2236     * 2237     * @param colName the name of the column from which to retrieve the value 2238     * @param map a <code>java.util.Map</code> object that contains the mapping 2239     * from SQL type names to classes in the Java programming language 2240     * @return an <code>Object</code> representing the SQL value in the 2241     * specified column 2242     * @exception SQLException if a database access error occurs 2243     * @since 1.2 2244     */ 2245    public Object getObject(String colName, java.util.Map map) throws SQLException { 2246        return resultSet.getObject(colName, map); 2247    } 2248 2249    /** 2250     * Retrieves the value of the designated column in the current row 2251     * of this <code>ResultSet</code> object as a <code>Ref</code> object 2252     * in the Java programming language. 2253     * 2254     * @param colName the column name 2255     * @return a <code>Ref</code> object representing the SQL <code>REF</code> 2256     * value in the specified column 2257     * @exception SQLException if a database access error occurs 2258     * @since 1.2 2259     */ 2260    public Ref getRef(String colName) throws SQLException { 2261        return resultSet.getRef(colName); 2262    } 2263 2264    /** 2265     * Retrieves the value of the designated column in the current row 2266     * of this <code>ResultSet</code> object as a <code>Blob</code> object 2267     * in the Java programming language. 2268     * 2269     * @param colName the name of the column from which to retrieve the value 2270     * @return a <code>Blob</code> object representing the SQL <code>BLOB</code> 2271     * value in the specified column 2272     * @exception SQLException if a database access error occurs 2273     * @since 1.2 2274     */ 2275    public Blob getBlob(String colName) throws SQLException { 2276        return resultSet.getBlob(colName); 2277    } 2278 2279    /** 2280     * Retrieves the value of the designated column in the current row 2281     * of this <code>ResultSet</code> object as a <code>Clob</code> object 2282     * in the Java programming language. 2283     * 2284     * @param colName the name of the column from which to retrieve the value 2285     * @return a <code>Clob</code> object representing the SQL <code>CLOB</code> 2286     * value in the specified column 2287     * @exception SQLException if a database access error occurs 2288     * @since 1.2 2289     */ 2290    public Clob getClob(String colName) throws SQLException { 2291        return resultSet.getClob(colName); 2292    } 2293 2294    /** 2295     * Retrieves the value of the designated column in the current row 2296     * of this <code>ResultSet</code> object as an <code>Array</code> object 2297     * in the Java programming language. 2298     * 2299     * @param colName the name of the column from which to retrieve the value 2300     * @return an <code>Array</code> object representing the SQL <code>ARRAY</code> value in 2301     * the specified column 2302     * @exception SQLException if a database access error occurs 2303     * @since 1.2 2304     */ 2305    public Array getArray(String colName) throws SQLException { 2306        return resultSet.getArray(colName); 2307    } 2308 2309    /** 2310     * Retrieves the value of the designated column in the current row 2311     * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object 2312     * in the Java programming language. 2313     * This method uses the given calendar to construct an appropriate millisecond 2314     * value for the date if the underlying database does not store 2315     * timezone information. 2316     * 2317     * @param columnIndex the first column is 1, the second is 2, ... 2318     * @param cal the <code>java.util.Calendar</code> object 2319     * to use in constructing the date 2320     * @return the column value as a <code>java.sql.Date</code> object; 2321     * if the value is SQL <code>NULL</code>, 2322     * the value returned is <code>null</code> in the Java programming language 2323     * @exception SQLException if a database access error occurs 2324     * @since 1.2 2325     */ 2326    public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException { 2327        return resultSet.getDate(columnIndex, cal); 2328    } 2329 2330    /** 2331     * Retrieves the value of the designated column in the current row 2332     * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object 2333     * in the Java programming language. 2334     * This method uses the given calendar to construct an appropriate millisecond 2335     * value for the date if the underlying database does not store 2336     * timezone information. 2337     * 2338     * @param columnName the SQL name of the column from which to retrieve the value 2339     * @param cal the <code>java.util.Calendar</code> object 2340     * to use in constructing the date 2341     * @return the column value as a <code>java.sql.Date</code> object; 2342     * if the value is SQL <code>NULL</code>, 2343     * the value returned is <code>null</code> in the Java programming language 2344     * @exception SQLException if a database access error occurs 2345     * @since 1.2 2346     */ 2347    public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException { 2348        return resultSet.getDate(columnName, cal); 2349    } 2350 2351    /** 2352     * Retrieves the value of the designated column in the current row 2353     * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object 2354     * in the Java programming language. 2355     * This method uses the given calendar to construct an appropriate millisecond 2356     * value for the time if the underlying database does not store 2357     * timezone information. 2358     * 2359     * @param columnIndex the first column is 1, the second is 2, ... 2360     * @param cal the <code>java.util.Calendar</code> object 2361     * to use in constructing the time 2362     * @return the column value as a <code>java.sql.Time</code> object; 2363     * if the value is SQL <code>NULL</code>, 2364     * the value returned is <code>null</code> in the Java programming language 2365     * @exception SQLException if a database access error occurs 2366     * @since 1.2 2367     */ 2368    public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException { 2369        return resultSet.getTime(columnIndex, cal); 2370    } 2371 2372    /** 2373     * Retrieves the value of the designated column in the current row 2374     * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object 2375     * in the Java programming language. 2376     * This method uses the given calendar to construct an appropriate millisecond 2377     * value for the time if the underlying database does not store 2378     * timezone information. 2379     * 2380     * @param columnName the SQL name of the column 2381     * @param cal the <code>java.util.Calendar</code> object 2382     * to use in constructing the time 2383     * @return the column value as a <code>java.sql.Time</code> object; 2384     * if the value is SQL <code>NULL</code>, 2385     * the value returned is <code>null</code> in the Java programming language 2386     * @exception SQLException if a database access error occurs 2387     * @since 1.2 2388     */ 2389    public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException { 2390        return resultSet.getTime(columnName, cal); 2391    } 2392 2393    /** 2394     * Retrieves the value of the designated column in the current row 2395     * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object 2396     * in the Java programming language. 2397     * This method uses the given calendar to construct an appropriate millisecond 2398     * value for the timestamp if the underlying database does not store 2399     * timezone information. 2400     * 2401     * @param columnIndex the first column is 1, the second is 2, ... 2402     * @param cal the <code>java.util.Calendar</code> object 2403     * to use in constructing the timestamp 2404     * @return the column value as a <code>java.sql.Timestamp</code> object; 2405     * if the value is SQL <code>NULL</code>, 2406     * the value returned is <code>null</code> in the Java programming language 2407     * @exception SQLException if a database access error occurs 2408     * @since 1.2 2409     */ 2410    public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) 2411        throws SQLException { 2412        return resultSet.getTimestamp(columnIndex, cal); 2413    } 2414 2415    /** 2416     * Retrieves the value of the designated column in the current row 2417     * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object 2418     * in the Java programming language. 2419     * This method uses the given calendar to construct an appropriate millisecond 2420     * value for the timestamp if the underlying database does not store 2421     * timezone information. 2422     * 2423     * @param columnName the SQL name of the column 2424     * @param cal the <code>java.util.Calendar</code> object 2425     * to use in constructing the date 2426     * @return the column value as a <code>java.sql.Timestamp</code> object; 2427     * if the value is SQL <code>NULL</code>, 2428     * the value returned is <code>null</code> in the Java programming language 2429     * @exception SQLException if a database access error occurs 2430     * @since 1.2 2431     */ 2432    public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) 2433        throws SQLException { 2434        return resultSet.getTimestamp(columnName, cal); 2435    } 2436 2437    //-------------------------- JDBC 3.0 ---------------------------------------- 2438 2439    /** 2440     * Retrieves the value of the designated column in the current row 2441     * of this <code>ResultSet</code> object as a <code>java.net.URL</code> 2442     * object in the Java programming language. 2443     * 2444     * @param columnIndex the index of the column 1 is the first, 2 is the second,... 2445     * @return the column value as a <code>java.net.URL</code> object; 2446     * if the value is SQL <code>NULL</code>, 2447     * the value returned is <code>null</code> in the Java programming language 2448     * @exception SQLException if a database access error occurs, 2449     * or if a URL is malformed 2450     * @since 1.4 2451     */ 2452    public java.net.URL getURL(int columnIndex) throws SQLException { 2453        return resultSet.getURL(columnIndex); 2454    } 2455     2456    /** 2457     * Retrieves the value of the designated column in the current row 2458     * of this <code>ResultSet</code> object as a <code>java.net.URL</code> 2459     * object in the Java programming language. 2460     * 2461     * @param columnName the SQL name of the column 2462     * @return the column value as a <code>java.net.URL</code> object; 2463     * if the value is SQL <code>NULL</code>, 2464     * the value returned is <code>null</code> in the Java programming language 2465     * @exception SQLException if a database access error occurs 2466     * or if a URL is malformed 2467     * @since 1.4 2468     */ 2469    public java.net.URL getURL(String columnName) throws SQLException { 2470        return resultSet.getURL(columnName); 2471    } 2472 2473    /** 2474     * Updates the designated column with a <code>java.sql.Ref</code> value. 2475     * The updater methods are used to update column values in the 2476     * current row or the insert row. The updater methods do not 2477     * update the underlying database; instead the <code>updateRow</code> or 2478     * <code>insertRow</code> methods are called to update the database. 2479     * 2480     * @param columnIndex the first column is 1, the second is 2, ... 2481     * @param x the new column value 2482     * @exception SQLException if a database access error occurs 2483     * @since 1.4 2484     */ 2485    public void updateRef(int columnIndex, java.sql.Ref x) throws SQLException { 2486        resultSet.updateRef(columnIndex, x); 2487    } 2488     2489    /** 2490     * Updates the designated column with a <code>java.sql.Ref</code> value. 2491     * The updater methods are used to update column values in the 2492     * current row or the insert row. The updater methods do not 2493     * update the underlying database; instead the <code>updateRow</code> or 2494     * <code>insertRow</code> methods are called to update the database. 2495     * 2496     * @param columnName the name of the column 2497     * @param x the new column value 2498     * @exception SQLException if a database access error occurs 2499     * @since 1.4 2500     */ 2501    public void updateRef(String columnName, java.sql.Ref x) throws SQLException { 2502        resultSet.updateRef(columnName, x); 2503    } 2504 2505    /** 2506     * Updates the designated column with a <code>java.sql.Blob</code> value. 2507     * The updater methods are used to update column values in the 2508     * current row or the insert row. The updater methods do not 2509     * update the underlying database; instead the <code>updateRow</code> or 2510     * <code>insertRow</code> methods are called to update the database. 2511     * 2512     * @param columnIndex the first column is 1, the second is 2, ... 2513     * @param x the new column value 2514     * @exception SQLException if a database access error occurs 2515     * @since 1.4 2516     */ 2517    public void updateBlob(int columnIndex, java.sql.Blob x) throws SQLException { 2518        resultSet.updateBlob(columnIndex, x); 2519    } 2520 2521    /** 2522     * Updates the designated column with a <code>java.sql.Blob</code> value. 2523     * The updater methods are used to update column values in the 2524     * current row or the insert row. The updater methods do not 2525     * update the underlying database; instead the <code>updateRow</code> or 2526     * <code>insertRow</code> methods are called to update the database. 2527     * 2528     * @param columnName the name of the column 2529     * @param x the new column value 2530     * @exception SQLException if a database access error occurs 2531     * @since 1.4 2532     */ 2533    public void updateBlob(String columnName, java.sql.Blob x) throws SQLException { 2534        resultSet.updateBlob(columnName, x); 2535    } 2536 2537    /** 2538     * Updates the designated column with a <code>java.sql.Clob</code> value. 2539     * The updater methods are used to update column values in the 2540     * current row or the insert row. The updater methods do not 2541     * update the underlying database; instead the <code>updateRow</code> or 2542     * <code>insertRow</code> methods are called to update the database. 2543     * 2544     * @param columnIndex the first column is 1, the second is 2, ... 2545     * @param x the new column value 2546     * @exception SQLException if a database access error occurs 2547     * @since 1.4 2548     */ 2549    public void updateClob(int columnIndex, java.sql.Clob x) throws SQLException { 2550        resultSet.updateClob(columnIndex, x); 2551    } 2552 2553    /** 2554     * Updates the designated column with a <code>java.sql.Clob</code> value. 2555     * The updater methods are used to update column values in the 2556     * current row or the insert row. The updater methods do not 2557     * update the underlying database; instead the <code>updateRow</code> or 2558     * <code>insertRow</code> methods are called to update the database. 2559     * 2560     * @param columnName the name of the column 2561     * @param x the new column value 2562     * @exception SQLException if a database access error occurs 2563     * @since 1.4 2564     */ 2565    public void updateClob(String columnName, java.sql.Clob x) throws SQLException { 2566        resultSet.updateClob(columnName, x); 2567    } 2568 2569    /** 2570     * Updates the designated column with a <code>java.sql.Array</code> value. 2571     * The updater methods are used to update column values in the 2572     * current row or the insert row. The updater methods do not 2573     * update the underlying database; instead the <code>updateRow</code> or 2574     * <code>insertRow</code> methods are called to update the database. 2575     * 2576     * @param columnIndex the first column is 1, the second is 2, ... 2577     * @param x the new column value 2578     * @exception SQLException if a database access error occurs 2579     * @since 1.4 2580     */ 2581    public void updateArray(int columnIndex, java.sql.Array x) throws SQLException { 2582        resultSet.updateArray(columnIndex, x); 2583    } 2584 2585    /** 2586     * Updates the designated column with a <code>java.sql.Array</code> value. 2587     * The updater methods are used to update column values in the 2588     * current row or the insert row. The updater methods do not 2589     * update the underlying database; instead the <code>updateRow</code> or 2590     * <code>insertRow</code> methods are called to update the database. 2591     * 2592     * @param columnName the name of the column 2593     * @param x the new column value 2594     * @exception SQLException if a database access error occurs 2595     * @since 1.4 2596     */ 2597    public void updateArray(String columnName, java.sql.Array x) throws SQLException { 2598        resultSet.updateArray(columnName, x); 2599    } 2600} 2601

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