Java API By Example, From Geeks To Geeks.

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

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