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

This page was automatically generated by Maven