View Javadoc
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 */ 1009 public 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 */ 1022 public 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 */ 1039 public 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 */ 1052 public 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 */ 1064 public 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 */ 1078 public 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 */ 1092 public 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 */ 1103 public 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 */ 1141 public 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 */ 1167 public 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 */ 1181 public 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 */ 1205 public 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 */ 1219 public 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 */ 1237 public 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 */ 1250 public 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 */ 1265 public 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 */ 1280 public 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 */ 1297 public 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 */ 1313 public 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 */ 1330 public 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 */ 1346 public 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 */ 1362 public 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 */ 1379 public 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 */ 1395 public 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 */ 1411 public 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 */ 1427 public 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 */ 1443 public 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 */ 1459 public 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 */ 1476 public 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 */ 1493 public 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 */ 1509 public 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 */ 1525 public 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 */ 1541 public 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 */ 1558 public 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 */ 1576 public 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 */ 1594 public 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 */ 1612 public 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 */ 1633 public 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 */ 1650 public 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 */ 1665 public 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 */ 1681 public 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 */ 1698 public 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 */ 1714 public 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 */ 1730 public 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 */ 1746 public 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 */ 1762 public 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 */ 1778 public 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 */ 1795 public 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 */ 1812 public 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 */ 1829 public 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 */ 1845 public 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 */ 1861 public 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 */ 1878 public 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 */ 1896 public 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 */ 1914 public 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 */ 1933 public 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 */ 1954 public 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 */ 1971 public 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 */ 1986 public 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 */ 1999 public 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 */ 2012 public 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 */ 2041 public 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 */ 2060 public 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 */ 2085 public 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 */ 2098 public 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 */ 2115 public 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 */ 2136 public 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 */ 2151 public 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 */ 2166 public 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 */ 2181 public 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 */ 2196 public 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 */ 2217 public 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 */ 2232 public 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 */ 2247 public 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 */ 2262 public 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 */ 2277 public 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 */ 2298 public 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 */ 2320 public 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 */ 2341 public 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 */ 2362 public 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 */ 2383 public 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 */ 2405 public 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 }

This page was automatically generated by Maven