Java API By Example, From Geeks To Geeks.

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

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