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

This page was automatically generated by Maven